Integre contenido de Blogger con aplicaciones PHP usando la API Blogger Data

Use PHP para recuperar y añadir entradas de Blogger mediante la sofisticada API Blogger Data

Blogger es una plataforma de blogging popular y gratuita que les permite a los usuarios crear sus propios weblogs y publicar mensajes y noticias, mediante una interfaz de edición WYSIWYG. Con la API Blogger Data, la cual está basada en REST usted puede acceder a contenido Blogger a través de cualquier kit de herramientas de programación que cumpla con XML. En este artículo, aprenda cómo usar a API Blogger Data para listar contenido de blog, añadir o editar entradas y para manipular comentarios de blog con el componente Zend_Gdata de la infraestructura Zend. Usted construirá una aplicación simple que demuestra la potencia de la API Blogger.

Vikram Vaswani, Founder, Melonfire

Photo of Vikram VaswaniVikram Vaswani es fundador y CEO de Melonfire, una firma de servicios de consultoría con experiencia y conocimientos en herramientas y tecnologías de fuente abierta. También es el autor de los libros Zend Framework: A Beginners Guide y el PHP: A Beginners Guide.



06-02-2012

Introducción

Tal vez usted haya oído hablar de Blogger, una plataforma de blogging gratuita que le permite crear weblogs fácilmente y publicar entradas sobre cualquier tema. Blogger, que ha estado activa casi desde 1999, fue una de las primeras plataformas de blogging en la web. Fue adquirida por Google e integrada dentro de la suite de servicios Google.

Aplicaciones populares de blogger

Aunque Blogger es una opción popular de plataforma para blogs, existen muchas otras opciones. Por ejemplo, el software IBM Connections incluye capacidades de blog integradas. Otras opciones populares de software para blogs incluyen Wordpress, Drupal y Typepad, entre muchas otras.

Con Blogger, es fácil que las personas sin conocimientos técnicos específicos puedan crear y mantener sus propios weblogs. Blogger:

  • Incluye varias plantillas y diseños predefinidos
  • Soporta comentarios, controles de acceso y dispositivos móviles
  • Está estrechamente integrado con otros servicios (como Twitter, Google AdSense y otros) para intercambio de contenido y monetización.

En pocas palabras, Blogger proporciona todo lo que usted necesita para publica su blog sin tener que preocuparse sobre los detalles técnicos.

Acrónimos de uso frecuente

  • API: Interfaz de Programación de Aplicaciones
  • HTML: Hypertext Markup Language
  • HTTP: Hypertext Transfer Protocol
  • REST: Representational State Transfer
  • RSS: Really Simple Syndication
  • UI: Interfaz de usuario
  • WYSISYG: Lo que ve es o que obtiene
  • XML: Extensible Markup Language

Pero Blogger no solo es interesante para los usuarios. Como muchos otros servicios de Google, Blogger tiene una API de desarrollador que le permite trabajar directamente con las entrañas del servicio y extraer contenido para crear sus propias aplicaciones personalizadas y mashups. Usted puede acceder a la API Blogger, la cual sigue el modelo REST, a través de cualquier kit de herramientas de desarrollo que cumpla con XML. Este ya tiene bibliotecas de cliente para muchos lenguajes comunes de programación, incluyendo mi favorito: PHP.

En este artículo, aprenda sobre la API Blogger Data y sobre cómo integrar y usar contenido Blogger con otras aplicaciones PHP. Muchos ejemplos le guiarán:

  • Conexión y autenticación en la API
  • Recuperando listas de blog y feeds de blog
  • Añadiendo , actualizando y eliminando contenido
  • Trabajando con comentarios de blog

Conceptos clave

Antes de entrar al código PHP, esta sección le ofrece una visión general sobre la API Blogger Data. Así como con todos los servicios basados en REST, la API acepta solicitudes HTTP que contengan uno o más argumentos de entrada, y retorna respuestas basadas en XML que pueden ser analizadas en cualquier cliente que reconozca XML. Con la API Blogger, la respuesta siempre consiste en feeds Atom o RSS que contienen la información solicitada.

Blogger tiene feeds tanto públicos como privados. Usted puede acceder a feeds públicos, como a listas de entradas dentro de un blog, sin autenticación. Los feeds privados requieren autenticación. Por ejemplo, un feed privado requiere autenticación para efectuar operaciones de adición o actualización sobre una entrada o comentario de blog. Los ejemplos en este artículo demuestran ambos tipos de feeds.

Para aprovechar al máximo este artículo, usted debe tener una cuenta en Blogger, con por lo menos un blog y una entrada. Si no la tiene, puede registrarse en Blogger (vea Recursos), crear un nuevo blog, y agregarle una entrada, para propósitos de prueba. Mientras esté en sesión activa, intente acceder al URL http://www.blogger.com/feeds/default/blogs en un navegador web. Usted debe ver algo similar al Listado 1.

Listado 1. Meta-feed Blogger
<?xml version='1.0' encoding='UTF-8'?>
<?xml-stylesheet href="http://www.blogger.com/styles/atom.css" type="text/css"?>
<feed xmlns='http://www.w3.org/2005/Atom' 
 xmlns:openSearch='http://a9.com/-/spec/opensearchrss/1.0/'>
  <id>tag:blogger.com,1999:user-12345USERIDHERE12345.blogs</id>
  <updated>2011-09-02T03:35:34.547Z</updated>
  <title type='text'>V Vaswani's Blogs</title>
  <link rel='http://schemas.google.com/g/2005#feed' type='application/atom+xml' 
   href='http://www.blogger.com/feeds/12345USERIDHERE12345/blogs'/>
  <link rel='self' type='application/atom+xml' 
    href='http://www.blogger.com/feeds/12345USERIDHERE12345/blogs'/>
  <link rel='alternate' type='text/html' 
    href='http://www.blogger.com/profile/12345USERIDHERE12345'/>
  <author>
    <name>V Vaswani</name>
    <email>noreply@blogger.com</email>
  </author>
  <generator version='7.00' uri='http://www.blogger.com'>Blogger</generator>
  <openSearch:totalResults>1</openSearch:totalResults>
  <openSearch:startIndex>1</openSearch:startIndex>
  <openSearch:itemsPerPage>25</openSearch:itemsPerPage>
  <entry>
    <id>tag:blogger.com,1999:user-12345USERIDHERE12345.blog
     -12345BLOGIDHERE12345</id>
    <published>2008-02-19T23:30:41.755-08:00</published>
    <updated>2011-09-01T04:01:19.669-07:00</updated>
    <title type='text'>V Vaswani's Blog</title>
    <summary type='html'></summary>
    <link rel='self' type='application/atom+xml' href='http://www.blogger.com/feeds/
     12345USERIDHERE12345/blogs/12345BLOGIDHERE12345'/>
    <link rel='alternate' type='text/html' href='http://vvaswani.blogspot.com/'/>
    <link rel='http://schemas.google.com/g/2005#feed' 
     type='application/atom+xml' 
     href='http://vvaswani.blogspot.com/feeds/posts/default'/>
    <link rel='http://schemas.google.com/g/2005#post' type='application/atom+xml'
     href='http://www.blogger.com/feeds/12345BLOGIDHERE12345/posts/default'/>
    <link rel='http://schemas.google.com/blogger/2008#template' 
     type='application/atom+xml' 
     href='http://www.blogger.com/feeds/12345BLOGIDHERE12345/template'/>
    <link rel='http://schemas.google.com/blogger/2008#settings' 
     type='application/atom+xml' 
     href='http://www.blogger.com/feeds/12345BLOGIDHERE12345/settings'/>
    <author>
      <name>V Vaswani</name>
      <email>noreply@blogger.com</email>
    </author>
    <gd:extendedProperty xmlns:gd='http://schemas.google.com/g/2005' 
     name='IS_PUBLIC_BLOG' value='true'/>
    <gd:extendedProperty xmlns:gd='http://schemas.google.com/g/2005' 
     name='PICASAWEB_ALBUM_ID' value='0'/>
  </entry>
</feed>

El meta-feed del Listado 1 proporciona una lista de todos los blogs asociados con el usuario autenticado actualmente. Este abre un elemento <feed> como el elemento raíz. El elemento <feed> contiene:

  • <link> que contiene URLs para diferentes versiones del feed
  • Un elemento <author> que especifica el propietario de la cuenta
  • <openSearch> , elementos que contienen estadísticas de resumen

El elemento <feed> más externo encierra uno o más elementos <entry>, cada uno de los cuales representa un blog. Cada <entry> contiene detalles completos, incluyendo el título, descripción, fecha de creación, fecha de última actualización y autor de cada blog. Cada entrada también incluye un conjunto de enlaces de feed, que son feeds que contienen entradas de blog, plantillas de blog y configuraciones de blog.

En el Listado 1, cada blog está asociado con un identificador único, o ID de blog. El ID de blog se usa para construir los URL para los feed específicos de blog. Por ejemplo, para encontrar el feed de publicación para un blog específico, use el URL especificado en el elemento <linkrel='http://schemas.google.com/g/2005#post' ... /> . El Listado 2 muestra cómo se deberá ver el feed de publicación.

Listado 2. Feed de publicación Blogger
<?xml version='1.0' encoding='UTF-8'?>
<?xml-stylesheet href="http://www.blogger.com/styles/atom.css" type="text/css"?>
<feed xmlns='http://www.w3.org/2005/Atom' 
 xmlns:openSearch='http://a9.com/-/spec/opensearchrss/1.0/' 
 xmlns:georss='http://www.georss.org/georss' 
 xmlns:thr='http://purl.org/syndication/thread/1.0'>
  <id>tag:blogger.com,1999:blog-12345BLOGIDHERE12345</id>
  <updated>2011-09-01T21:06:44.240-07:00</updated>
  <title type='text'>V Vaswani's Blog</title>
  <subtitle type='html'></subtitle>
  <link rel='http://schemas.google.com/g/2005#feed' type='application/atom+xml' 
   href='http://vvaswani.blogspot.com/feeds/posts/default'/>
  <link rel='self' type='application/atom+xml' 
   href='http://www.blogger.com/feeds/12345BLOGIDHERE12345/posts/default'/>
  <link rel='http://schemas.google.com/g/2005#post' type='application/atom+xml' 
   href='http://www.blogger.com/feeds/12345BLOGIDHERE12345/posts/default'/>
  <link rel='alternate' type='text/html' href='http://vvaswani.blogspot.com/'/>
  <author>
    <name>V Vaswani</name>
    <email>noreply@blogger.com</email>
  </author>
  <generator version='7.00' uri='http://www.blogger.com'>Blogger</generator>
  <openSearch:totalResults>3</openSearch:totalResults>
  <openSearch:startIndex>1</openSearch:startIndex>
  <openSearch:itemsPerPage>25</openSearch:itemsPerPage>
  <entry>
    <id>tag:blogger.com,1999:blog-12345BLOGIDHERE12345.post-
     12345POSTIDHERE12345</id>
    <published>2011-09-01T03:34:00.001-07:00</published>
    <updated>2011-09-01T21:06:44.258-07:00</updated>
    <title type='text'>My Third Post</title>
    <content type='html'>This is my third post
    <br /></content>
    <link rel='replies' type='application/atom+xml' 
     href='http://vvaswani.blogspot.com/feeds/12345POSTIDHERE12345/comments/default'
     title='Post Comments'/>
    <link rel='replies' type='text/html' 
     href='https://www.blogger.com/comment.g?
     blogID=12345BLOGIDHERE12345&postID=12345POSTIDHERE12345' 
     title='0 Comments'/>
    <link rel='edit' type='application/atom+xml' 
     href='http://www.blogger.com/feeds/12345BLOGIDHERE12345/posts/
     default/12345POSTIDHERE12345'/>
    <link rel='self' type='application/atom+xml' 
     href='http://www.blogger.com/feeds/12345BLOGIDHERE12345/posts/
     default/12345POSTIDHERE12345'/>
    <link rel='alternate' type='text/html' 
     href='http://vvaswani.blogspot.com/2011/09/my-third-d.html' 
     title='My Third Post'/>
    <author>
    <name>V Vaswani</name>
    <email>noreply@blogger.com</email>
    </author>
    <thr:total>0</thr:total>
  </entry>
  ...
</feed>

El Listado 2 revela que el feed de publicación contiene un conjunto de elementos <entry> , y que cada uno representa una publicación individual del blog. Cada <entry> incluye:

  • El título, contenido y fecha de publicación de la publicación.
  • Enlaces al URL público de la publicación, el URL de edición de la publicación, los URLs del feed comentarios y de edición de feed comentarios. Estos feeds se utilizan para ver y editar la publicación o sus comentarios, mediante la API Blogger Data.

Cada publicación tiene también un identificador único, llamado el ID de publicación, que está en el elemento <id> de la entrada. Está compuesto por una cadena de caracteres que incluye el ID de blog y el ID de publicación, en el formato tag:blogger.com,1999:blog-BLOGID.post-POSTID. Por ejemplo, en la siguiente cadena de caracteres tag:blogger.com,1999:blog-1234.post-6789, el identificador de blog es 1234 y el identificador de publicación es 6789.


Recuperando blogs y publicaciones

Ahora que ya sabe cómo acceder al blog y publicar feeds mediante la API, intente lo mismo desde una aplicación PHP. Para generar los feeds de los Listados 1 y 2, primero usted debe iniciar sesión manualmente en Blogger con una cuenta Google. Para recuperar y procesar los feeds desde una aplicación PHP, es necesario ejecutar la misma tarea de autenticación programáticamente.

Efectuar la autenticación manualmente es una tarea bastante complicada y requiere bastante código para incluir los diversos escenarios que se pueden presentar durante una transacción de autenticación típica. Afortunadamente, la infraestructura Zend incluye Zend_Gdata, una biblioteca de cliente PHP diseñada específicamente para desarrolladores que intenten integrar aplicaciones PHP con la API Google Data. Zend_Gdata proporciona una interfaz conveniente y orientada a objetos para la API Google Data (vea el enlace en Recursos para descargarla). Esta encapsula la mayoría de las tareas comunes, incluyendo autenticación, y le deja libre para que se enfoque en las funciones principales de su aplicación.

Después de instalar la biblioteca Data de Zend, observe el Listado 3. Este le muestra cómo procesar el feed del Listado 1 y convertirlo en una página web que lista todos los weblogs del usuario autenticado en Blogger.

Listado 3. Listando blogs
<?php
// load Zend Gdata libraries
require_once 'Zend/Loader.php';
Zend_Loader::loadClass('Zend_Gdata');
Zend_Loader::loadClass('Zend_Gdata_Query');
Zend_Loader::loadClass('Zend_Gdata_ClientLogin');
Zend_Loader::loadClass('Zend_Gdata_Feed');

// set credentials for ClientLogin authentication
$user = "your-username@gmail.com";
$pass = "your-password";

try {
  // perform login 
  // initialize service object
  $client = Zend_Gdata_ClientLogin::getHttpClient(
    $user, $pass, 'blogger');
  $service = new Zend_Gdata($client);

  // get list of all blogs
  $query = new Zend_Gdata_Query('http://www.blogger.com/feeds/default/blogs');
  $feed = $service->getFeed($query);
} catch (Exception $e) {
  die('ERROR:' . $e->getMessage());  
}
?>
<html>
  <head></head>
  <body>
    <h2>Blogs</h2>
    <ul>
      <?php foreach ($feed as $entry): ?>      
      <li>
        <a href="<?php 
         echo $entry->getLink('alternate')->getHref(); ?>">
         <?php echo $entry->getTitle(); ?> 
        </a>          
      </li>
      <?php endforeach; ?>
    </ul>  
  </body>
</html>

El Listado 3 carga las bibliotecas de clase Zend e inicializa una instancia de la clase de servicio Zend_Gdata . Zend_Gdata usa un objeto Zend_Http_Client , al cual se le suministra la información de autenticación de usuario necesaria y que se usa para abrir una conexión autenticada al servicio Blogger. Esta clase también sirve como el punto de control para todas las interacciones subsiguientes con a API Blogger Data.

Una vez abierta una conexión autenticada, el método getFeed() se utiliza para recuperar la lista de blogs. getFeed() acepta un objeto Zend_Gdata_Query , el cual es pasado al URL la el feed de listado de blog. La respuesta al llamado getFeed() de la API es un feed XML similar al del Listado 1, que es luego analizado y convertido en un objeto PHP. Las entradas dentro del feed son representadas como elementos de matriz, haciendo posible:

  • Iterar sobre el feed
  • Recuperar los nombres y URL del blog individual
  • Darles formato para presentarlos en un navegador web

La Figura 1 muestra el resultado que usted podría ver.

Figura 1. Página web de ejemplo que muestra blogs de usuarios
Página web de ejemplo que muestra blogs de usuarios

Como se señaló anteriormente, cada blog y publicación dentro del servicio de Blogger tiene un identificador único. Si usted tiene un identificador único para un blog, puede generar el URL para el feed de blog correspondiente, el cual contiene una lista de todas las publicaciones dentro de ese blog. El Listado 4 muestra el proceso de recuperar procesar un feed de blog de ese tipo con la biblioteca de cliente Zend_Gdata.

Listado 4. Listando publicaciones de blog
<?php
// load Zend Gdata libraries
require_once 'Zend/Loader.php';
Zend_Loader::loadClass('Zend_Gdata');
Zend_Loader::loadClass('Zend_Gdata_Query');
Zend_Loader::loadClass('Zend_Gdata_ClientLogin');
Zend_Loader::loadClass('Zend_Gdata_Feed');

// set credentials for ClientLogin authentication
$user = "your-username@gmail.com";
$pass = "your-password";

try {
  // perform login 
  // initialize service object
  $client = Zend_Gdata_ClientLogin::getHttpClient(
    $user, $pass, 'blogger');
  $service = new Zend_Gdata($client);

  // get list of all posts in blog feed
  $query = new Zend_Gdata_Query(
   'http://www.blogger.com/feeds/YOUR-BLOG-ID-HERE/posts/default');
  $feed = $service->getFeed($query);
} catch (Exception $e) {
  die('ERROR:' . $e->getMessage());  
}
?>
<html>
  <head></head>
  <body>
    <h2>Posts</h2>
    <ul>
      <?php foreach ($feed as $entry): ?>      
      <li>
        <a href="<?php 
         echo $entry->getLink('alternate')->getHref(); ?>">
            <?php echo $entry->getTitle(); ?> 
        </a>          
      </li>
      <?php endforeach; ?>
    </ul>  
  </body>
</html>

Como en el Listado 3, el Listado 4 analiza primero bibliotecas Zend y crea un objeto de servicio Zend_Gdata autenticado. El identificador de blog se utiliza para construir el URL hacia el feed de blog, el cual es convertido en un objeto Zend_Gdata_Query y pasado al método getFeed() . El feed resultante es luego analizado y procesado, de la forma usual, para producir una lista de todas las publicaciones dentro de un blog especificado. La Figura 2 muestra un ejemplo del resultado.

Figura 2. Página web mostrando publicaciones de blog de un usuario
Página web mostrando publicaciones de blog de un usuario

Usted puede combinar el Listado 3 y el Listado 4 para producir una lista de todos los blogs y todas las publicaciones en esos blogs, de los usuarios autenticados. El Listado 5 muestra el código combinado.

Listado 5. Listando blogs y entradas de blogs
<?php
// load Zend Gdata libraries
require_once 'Zend/Loader.php';
Zend_Loader::loadClass('Zend_Gdata');
Zend_Loader::loadClass('Zend_Gdata_Query');
Zend_Loader::loadClass('Zend_Gdata_ClientLogin');
Zend_Loader::loadClass('Zend_Gdata_Feed');

// set credentials for ClientLogin authentication
$user = "your-username@gmail.com";
$pass = "your-password";

try {
  // perform login 
  // initialize service object
  $client = Zend_Gdata_ClientLogin::getHttpClient(
    $user, $pass, 'blogger');
  $service = new Zend_Gdata($client);

  // create array
  $data = array();
  
  // get list of all posts in all blog feeds
  $query1 = new Zend_Gdata_Query('http://www.blogger.com/feeds/default/blogs');
  $feed1 = $service->getFeed($query1);
  foreach ($feed1 as $entry1) {
    $arr = explode('-', (string)$entry1->getId());
    $id = $arr[2];
    $query2 = new Zend_Gdata_Query(
     'http://www.blogger.com/feeds/'.$id.'/posts/default');
    $feed2 = $service->getFeed($query2);
    $blogArray = array(
      'title' => (string)$entry1->getTitle(), 
      'uri' => (string)$entry1->getLink('alternate')->getHref(),
      'posts' => array()
    );
    foreach ($feed2 as $entry2) {
      $postArray = array(
        'title' => (string)$entry2->getTitle(), 
        'uri' => (string)$entry2->getLink('alternate')->getHref()
      );
      $blogArray['posts'][] = $postArray;
    }
    $data[] = $blogArray;
  }
} catch (Exception $e) {
  die('ERROR:' . $e->getMessage());  
}
?>
<html>
  <head></head>
  <body>
    <h2>Blogs and Posts</h2>
    <div id="results">
      <?php foreach ($data as $d): ?>      
      <ul>      
        <li><a href="<?php echo $d['uri']; ?>">
        <?php echo $d['title']; ?></a></li>
          <ul>
          <?php foreach ($d['posts'] as $p): ?>      
            <li><a href="<?php echo $p['uri']; ?>">
            <?php echo $p['title']; ?></a></li>
          <?php endforeach; ?>
          </ul>
      </ul>
      <?php endforeach; ?>
    </div>  
  </body>
</html>

El Listado 5 primero solicita el meta-feed del blog e itera sobre las entradas de este para recuperar el identificador único de cada blog. Este identificador es utilizado luego para construir el URL hacia el feed de publicación del blog, el cual es solicitado y procesado para extraer el título y URL de cada publicación. Toda esta información es almacenada en una matriz anidada, como en el Listado 6.

Listado 6. Matriz anidada
Array
(
  [0] => Array
  (
    [title] => V Vaswani's Blog
    [uri] => http://***.blogspot.com/
    [posts] => Array
    (
      [0] => Array
      (
        [title] => My Fourth Post
        [uri] => http://***.blogspot.com/2011/09/my-fourth-post.html
      )

      [1] => Array
      (
        [title] => My Third Post
        [uri] => http://***.blogspot.com/2011/09/my-third-d.html
      )

      [2] => Array
      (
        [title] => My Second Post
        [uri] => http://***.blogspot.com/2011/08/my-second-post.html
      )

      [3] => Array
      (
        [title] => My First Post
        [uri] => http://***.blogspot.com/2008/02/testing.html
      )
    )
  )

  [1] => Array
  (
    [title] => V Vaswani's Second Blog
    [uri] => http://***.blogspot.com/
    [posts] => Array
    (
      [0] => Array
      (
        [title] => My First Post in my Second Blog
        [uri] => http://***.blogspot.com/2011/09/my-first-post-in-my-second-blog.html
      )
    )
  )
)

En cuanto la matriz se genera completamente, usted simplemente puede iterar sobre este y preparar una lista anidada de blogs y sus publicaciones. La Figura 3 muestra un ejemplo del resultado.

Figura 3. Página web mostrando blogs y publicaciones en blogs de un usuario
Página web mostrando blogs y publicaciones en blogs de un usuario

Añadiendo publicaciones en blogs

Además de permitir la recuperación de ubicaciones, la API Blogger Data también permite que los usuarios autenticados añadan nuevas publicaciones a un blog programáticamente. Cree un nuevo objeto Zend_Gdata_App_Entry , defina su título y contenido, y luego haga un POST en el feed de publicación. El Listado 7 muestra el código de ejemplo.

Listado 7. Añadiendo una publicación de blog
<?php
if (isset($_POST['submit'])) {

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

  // set credentials for ClientLogin authentication
  $user = "your-username@gmail.com";
  $pass = "your-password";

  // set blog id
  $id = 'YOUR-BLOG-ID-HERE';

  try {
    // perform login 
    // initialize service object
    $client = Zend_Gdata_ClientLogin::getHttpClient(
      $user, $pass, 'blogger');
    $service = new Zend_Gdata($client);

    // create a new entry object
    // populate it with user input    
    $uri = 'http://www.blogger.com/feeds/' . $id . '/posts/default';
    $entry = $service->newEntry();
    $entry->title = $service->newTitle($_POST['title']);
    $entry->content = $service->newContent($_POST['body']);
    $entry->content->setType('text');

    // save entry to server
    // return unique id for new post
    $response = $service->insertEntry($entry, $uri);
    $arr = explode('-', $response->getId());
    $id = $arr[2];
    echo 'Successfully added post with ID: ' . $id;

  } catch (Exception $e) {
    die('ERROR:' . $e->getMessage());  
  }
}
?>
<html>
  <head></head>
  <body>
    <h2>Add New Post</h2>
    <form method="post">
      Title: <br/> <input type="text" name="title" 
       size="50" /> <br/>
      Body: <br/> <textarea name="body" cols="40" 
       rows="10"> </textarea> <br/>
      <input type="submit" name="submit" value="Post" />
    </form>
  </body>
</html>

El código del Listado 7, un formulario web simple permite al usuario ingresar un título y un cuerpo para una publicación de blog. Después de ingresado, el script carga la bibliotecas de clase Zend y crea un objeto de servicio autenticado. Luego el script usa el método newEntry() del objeto de servicio para crear un nuevo objeto de entrada, y usa los métodos newTitle() y newContent() para definir el título y el contenido de la ubicación de blog desde la entrada del usuario. Después de que se han configurado estos atributos, el método insertEntry() es usado para guardar la nueva publicación en los servidores de Google.

La Figura 4 muestra un ejemplo del formulario.

Figura 4. Formulario web para añadir una nueva publicación de blog
Formulario web para añadir una nueva publicación de blog

El valor de retorno del método insertEntry() es una entrada que representa una publicación creada recientemente. Ahora esta entrada contiene el identificador único de la publicación, la cual puede ser extraída y mostrada en la página de resultados. Después de que se guardan, las nuevas publicaciones se tornan visibles en e blog público y también aparecen en todos los feed API para ese blog.


Editando y eliminando publicaciones en blog

Usted también puede eliminar o editar publicaciones existentes mediante la API Blogger Data. En ambos casos, la solicitud DELETE o PUT correspondiente debe ser transmitida al URL e edición de publicación (vea el Listado 2 para un ejemplo). Solo los usuarios autenticados pueden efectuar estas dos operaciones.

El código del Listado 8 muestra cómo eliminar una publicación en blog existente mediante la API, suponiendo que usted ya tiene las ID del blog y de la publicación.

Listado 8. Eliminando una publicación de blog
<?php
// load Zend Gdata libraries
require_once 'Zend/Loader.php';
Zend_Loader::loadClass('Zend_Gdata');
Zend_Loader::loadClass('Zend_Gdata_Query');
Zend_Loader::loadClass('Zend_Gdata_ClientLogin');
Zend_Loader::loadClass('Zend_Gdata_Feed');

// set credentials for ClientLogin authentication
$user = "your-username@gmail.com";
$pass = "your-password";

// set blog and post ids
$bid = 'YOUR-BLOG-ID-HERE';
$pid = 'YOUR-POST-ID-HERE';

try {
  // perform login 
  // initialize service object
  $client = Zend_Gdata_ClientLogin::getHttpClient(
    $user, $pass, 'blogger');
  $service = new Zend_Gdata($client);

  // set URI for entry to delete
  // obtain from <link rel=edit ... />
  $uri = 'http://www.blogger.com/feeds/' . $bid . '/posts/default/' . $pid;
  $service->delete($uri);
  echo 'Successfully deleted post with ID: ' . $pid;

} catch (Exception $e) {
  die('ERROR:' . $e->getMessage());  
}
?>

El Listado 8 usa el método delete() del objeto de servicio para eliminar la publicación de blog especificada. El método delete() acepta el URL de edición de la publicación y transmite una solicitud DELETE a ese URL. Después de que es eliminada, la publicación de blog desaparecerá del blog público y de cualquier feed API que la referencie.

Para mostrar el código para actualizar una publicación en blog existente mediante la API, suponiendo de nuevo que usted ya tiene las ID del blog y de la publicación, use el código del Listado 9.

Listado 9. Actualizando una publicación en blog
<?php
// load Zend Gdata libraries
require_once 'Zend/Loader.php';
Zend_Loader::loadClass('Zend_Gdata');
Zend_Loader::loadClass('Zend_Gdata_Query');
Zend_Loader::loadClass('Zend_Gdata_ClientLogin');
Zend_Loader::loadClass('Zend_Gdata_Feed');

// set credentials for ClientLogin authentication
$user = "your-username@gmail.com";
$pass = "your-password";

// set blog and post ids
$bid = 'YOUR-BLOG-ID-HERE';
$pid = 'YOUR-POST-ID-HERE';

try {
  // perform login 
  // initialize service object
  $client = Zend_Gdata_ClientLogin::getHttpClient(
    $user, $pass, 'blogger');
  $service = new Zend_Gdata($client);

  // set URI for entry to update
  // obtain from <link rel=self ... />
  $uri = 'http://www.blogger.com/feeds/' . $bid . '/posts/default/' . $pid;

  // get the existing entry
  // set new values
  // save it back
  $response = $service->get($uri);
  $entry = new Zend_Gdata_App_Entry($response->getBody());
  $entry->title = $service->newTitle("New title");
  $entry->content = $service->newContent("New content");
  $entry->content->setType('text');
  $service->updateEntry($entry);
  echo 'Successfully updated post with ID: ' . $pid;

} catch (Exception $e) {
  die('ERROR:' . $e->getMessage());  
}
?>

Actualizar una publicación en blog mediante la API es un proceso de dos pasos. Primero, usted necesita recuperar la publicación en blog existente y convertirla en un objeto Zend_Gdata_App_Entry . Luego, puede usar métodos de objeto de servicio, como newTitle() y newContent(), para actualizar la entrada y guardarla en el servidor usando el método updateEntry() .

De forma similar al método insertEntry() , el valor de retorno del método updateEntry() es una entrada que representa la publicación, incluyendo su identificador único y su contenido. Después de que se guarda, la publicación actualizada se torna visible en el blog público y en todos los feed API que hagan referencia a ese blog.


Trabajando con comentarios

Tal como usted puede añadir, editar y eliminar publicaciones, usted también puede añadir, editar y eliminar comentarios publicados. En el Listado 2, note que cada entrada de publicación incluye enlaces hacia el feed de comentarios de la publicación. Añadir un nuevo comentario es tan simple como insertar una entrada en el feed de comentarios.

El Listado 10 muestra el proceso de añadir un comentario a una publicación.

Listado 10. Añadiendo un nuevo comentario
<?php
// load Zend Gdata libraries
require_once 'Zend/Loader.php';
Zend_Loader::loadClass('Zend_Gdata');
Zend_Loader::loadClass('Zend_Gdata_Query');
Zend_Loader::loadClass('Zend_Gdata_ClientLogin');
Zend_Loader::loadClass('Zend_Gdata_Feed');

// set credentials for ClientLogin authentication
$user = "your-username@gmail.com";
$pass = "your-password";

// set blog and post ids
$bid = 'YOUR-BLOG-ID-HERE';
$pid = 'YOUR-POST-ID-HERE';

try {
  // perform login 
  // initialize service object
  $client = Zend_Gdata_ClientLogin::getHttpClient(
    $user, $pass, 'blogger');
  $service = new Zend_Gdata($client);

  // create a new entry object
  // populate it with user input    
  $uri = "http://www.blogger.com/feeds/$bid/$pid/comments/default";
  $entry = $service->newEntry();
  $entry->content = $service->newContent('This is a very interesting post.');
  $entry->content->setType('text');

  // save entry to server
  // return unique id for new comment
  $response = $service->insertEntry($entry, $uri);
  $arr = explode('/', $response->getEditLink()->href);
  $id = $arr[8];
  echo 'Successfully added comment with ID: ' . $id;

} catch (Exception $e) {
  die('ERROR:' . $e->getMessage());  
}
?>

Añadir un nuevo comentario es casi lo mismo que añadir una nueva publicación; la única diferencia reside en el URL en el cual se publica la solicitud (en este caso, el URL de feed de comentarios). La respuesta al método insertEntry() es un objeto que representa el comentario añadido recientemente. El objeto puede luego ser analizado para recuperar el identificador único de comentario, el cual se necesita si usted desea eliminar el comentario más adelante.

Suponiendo que usted ya tiene el identificador de comentario, usted puede usar el código del Listado 11 para remover programáticamente el comentario con el método delete() .

Listado 11. Eliminando un comentario
<?php
// load Zend Gdata libraries
require_once 'Zend/Loader.php';
Zend_Loader::loadClass('Zend_Gdata');
Zend_Loader::loadClass('Zend_Gdata_Query');
Zend_Loader::loadClass('Zend_Gdata_ClientLogin');
Zend_Loader::loadClass('Zend_Gdata_Feed');

// set credentials for ClientLogin authentication
$user = "your-username@gmail.com";
$pass = "your-password";

// set blog, post and comment ids
$bid = 'YOUR-BLOG-ID-HERE';
$pid = 'YOUR-POST-ID-HERE';
$cid = 'YOUR-COMMENT-ID-HERE';

try {
  // perform login 
  // initialize service object
  $client = Zend_Gdata_ClientLogin::getHttpClient(
    $user, $pass, 'blogger');
  $service = new Zend_Gdata($client);

  // set URI for entry to delete
  // obtain from <link rel=edit ... />
  $uri = "http://www.blogger.com/feeds/$bid/$pid/comments/default/$cid";
  $service->delete($uri);
  echo 'Successfully deleted comment with ID: ' . $cid;

} catch (Exception $e) {
  die('ERROR:' . $e->getMessage());  
}
?>

Usted también puede usar el mismo URL de feed de comentarios para recuperar una lista de todos los comentarios para una publicación, como en el Listado 12.

Listado 12. Listando los comentarios
<?php
// load Zend Gdata libraries
require_once 'Zend/Loader.php';
Zend_Loader::loadClass('Zend_Gdata');
Zend_Loader::loadClass('Zend_Gdata_Query');
Zend_Loader::loadClass('Zend_Gdata_ClientLogin');
Zend_Loader::loadClass('Zend_Gdata_Feed');

// set credentials for ClientLogin authentication
$user = "your-username@gmail.com";
$pass = "your-password";

// set blog and post ids
$bid = 'YOUR-BLOG-ID-HERE';
$pid = 'YOUR-POST-ID-HERE';

try {
  // perform login 
  // initialize service object
  $client = Zend_Gdata_ClientLogin::getHttpClient(
    $user, $pass, 'blogger');
  $service = new Zend_Gdata($client);

  // get list of all comments for post
  $uri = "http://www.blogger.com/feeds/$bid/$pid/comments/default/";
  $query = new Zend_Gdata_Query($uri);
  $feed = $service->getFeed($query);
} catch (Exception $e) {
  die('ERROR:' . $e->getMessage());  
}
?>
<html>
  <head></head>
  <body>
    <h2>Comments</h2>
    <div id="results">
      <ul>
      <?php foreach ($feed as $entry): ?>      
        <?php $author = $entry->getAuthor(); ?>
        <li><?php echo $entry->getTitle(); ?> 
         - <?php echo $author[0]->getName(); ?> <br/>
        <?php echo date('d M Y H:i', strtotime($entry->getUpdated())); ?>
        </li>          
      <?php endforeach; ?>
    </ul>  
  </body>
</html>

Aplicación de ejemplo: Sistema de Administración de Contenido

Pongamos todo en práctica construyendo una aplicación simple del mundo real que demuestra el poder de la API Blogger Data. La aplicación de ejemplo es un gestor de contenido basado en web que permite a los usuarios ver sus publicaciones de blog existentes, añadir nuevas publicaciones y editar o eliminar las publicaciones existentes. Las ediciones se llevan a cabo mediante un editor WYSIWYG basado en web y transmitidas hacia Blogger mediante la API Blogger Data.

Para comenzar, descargue e instale el editor TinyMCE JavaScript en su servidor de desarrollo (vea Recursos donde encontrará un enlace).Cree un script que contenga el código mostrado en el Listado 13.

Listado 13. Administrando contenido de blog
<?php
// load Zend Gdata libraries
require_once 'Zend/Loader.php';
Zend_Loader::loadClass('Zend_Gdata');
Zend_Loader::loadClass('Zend_Gdata_Query');
Zend_Loader::loadClass('Zend_Gdata_ClientLogin');
Zend_Loader::loadClass('Zend_Gdata_Feed');

// set credentials for ClientLogin authentication
$user = "your-username@gmail.com";
$pass = "your-password";

// set blog id
$bid = 'YOUR-BLOG-ID-HERE';

try {
  // perform login 
  // initialize service object
  $client = Zend_Gdata_ClientLogin::getHttpClient(
    $user, $pass, 'blogger');
  $service = new Zend_Gdata($client);

  // for add and edit operations
  if (isset($_POST['submit'])) {
    // if post id present
    // update post with new content
    if (isset($_POST['pid'])) {      
      $arr = explode('-', $_GET['pid']);
      $pid = $arr[2];
      $uri = 'http://www.blogger.com/feeds/' . $bid . '/posts/default/' . $pid;
      $response = $service->get($uri);
      $entry = new Zend_Gdata_App_Entry($response->getBody());
      $entry->title = $service->newTitle($_POST['title']);
      $entry->content = $service->newContent($_POST['body']);
      $entry->content->setType('text');
      $service->updateEntry($entry);
      echo 'Successfully updated post with ID: ' . $pid;    
    } else {
      // if post id not present
      // create a new post
      // populate it with user input    
      $uri = 'http://www.blogger.com/feeds/' . $bid . '/posts/default';
      $entry = $service->newEntry();
      $entry->title = $service->newTitle($_POST['title']);
      $entry->content = $service->newContent($_POST['body']);
      $entry->content->setType('text');
      $response = $service->insertEntry($entry, $uri);
      $arr = explode('-', $response->getId());
      $id = $arr[2];
      echo 'Successfully added post with ID: ' . $id;  
    }
  }

  // for edit and delete operations
  if (isset($_GET['op'])) {
    // generate post URL
    $arr = explode('-', $_GET['pid']);
    $pid = $arr[2];
    $uri = 'http://www.blogger.com/feeds/' . $bid . '/posts/default/' . $pid;
    switch($_GET['op']) {
      case 'delete':
        // delete post
        $service->delete($uri);
        echo 'Successfully deleted post with ID: ' . $pid;      
        break;
      case 'edit':
        // retrieve post for display in edit form
        $response = $service->get($uri);
        $entry = new Zend_Gdata_App_Entry($response->getBody());
    }
  }
  
  // get list of all posts in blog feed
  $query = new Zend_Gdata_Query(
   'http://www.blogger.com/feeds/'.$bid.'/posts/default');
  $feed = $service->getFeed($query);
} catch (Exception $e) {
  die('ERROR:' . $e->getMessage());  
}
?>
<html>
  <head>
    <script type="text/javascript" 
     src="tinymce/jscripts/tiny_mce/tiny_mce.js"></script>
    <script type="text/javascript">
    tinyMCE.init({
            mode : "textareas",
            theme : "advanced",
            theme_advanced_buttons1 : "bold,italic,underline,|,justifyleft,
             justifycenter,justifyright,|,code,preview,|,forecolor,backcolor,|,sub,sup,
             |,fontsizeselect",
            theme_advanced_buttons2 : "cut,copy,paste,|,bullist,numlist,|,outdent,indent,
             |,undo,redo,|,link,unlink,anchor,image,|,removeformat",
            theme_advanced_buttons3 : "",      
            theme_advanced_toolbar_location : "top",
            theme_advanced_toolbar_align : "left",
            theme_advanced_statusbar_location : "bottom",
            theme_advanced_resizing : true
    });

    </script>
  </head>
  <body>
    <h2>View Posts</h2>
    <ul>
    <?php foreach ($feed as $e): ?>  
      <li><?php echo $e->getTitle(); ?> <br/>
      <a href="<?php 
      echo $e->getLink('alternate')->getHref(); ?>">View</a> 
       | <a href="?op=edit&pid=<?php echo $e->getId(); ?>">Edit</a>
       | <a href="?op=delete&pid=<?php echo $e->getId(); ?>">Delete
       </a>
      </li>
    <?php endforeach; ?>
    </ul>
    <a href="<?php echo $_SERVER['PHP_SELF']; ?>">
     Add a new post</a>
    <?php if (isset($_GET['op']) && $_GET['op'] == 'edit'): ?>
    <h2>Edit Post</h2>
    <form method="post">
      Title: <br/> <input type="text" name="title" size="50" 
       value="<?php echo $entry->title; ?>" /> <br/>
      Body: <br/> <textarea name="body" cols="40" 
       rows="10"><?php echo $entry->content; ?></textarea> <br/>
      <input type="hidden" name="pid" 
       value="<?php echo $entry->id; ?>" />
      <input type="submit" name="submit" value="Post" />
    </form>
    <?php else: ?>
    <h2>Add New Post</h2>
    <form method="post">
      Title: <br/> <input type="text" name="title" 
       size="50" /> <br/>
      Body: <br/> <textarea name="body" cols="40" 
       rows="10"> </textarea> <br/>
      <input type="submit" name="submit" value="Post" />
    </form>
    <?php endif; ?>
  </body>
</html>

El código de arriba puede parecer complejo, pero simplemente son un par de enunciados condicionales empaquetados en torno a código que usted ya ha visto. Puede ser útil desglosarlo, de la siguiente manera.

  • El script comienza cargando las bibliotecas de clase Zend y estableciendo credenciales para autenticación. Este también define a ID de blog. Todas las operaciones subsiguientes tendrán lugar solo en el blog especificado.
  • Suponiendo que no existen parámetros de solicitud, el script se conecta con la API Blogger y solicita una lista de todas las publicaciones en el blog especificado. Luego procesa el feed resultante y muestra una lista de publicaciones en una lista HTML.

    Cada publicación está acompañada por tres enlaces: para View, Edit o Delete la publicación. El enlace View especifica el URL público del post. Los enlaces Edit y Delete simplemente vuelven a invocar el script, pasándole el ID de publicación seleccionado como un parámetro de solicitud GET.

  • Después de generar la lista de las publicaciones actuales, el script también genera un formulario web para que el usuario añada una nueva publicación. El formulario contiene un campo de entrada de texto de una sola línea (para el título de la publicación) y un área de texto multi-líneas (para el cuerpo de la publicación).

    El editor TinyMCE, que también se inicializa en la carga de página, se encarga automáticamente de convertir al área de texto en un área de edición de texto WYSIWYG con controles de formato y de hipervínculo.

  • Lo que sucede después depende de cuál operación seleccione el usuario.
    Si el usuario elige...Entonces...
    Añadir una nueva publicaciónDespués de que el contenido es ingresado en el formulario web y es ingresado, el script crea un nuevo objeto de entrada usando el método newEntry() , lo llena con la entrada ingresada, y lo guarda en el blog usando el métodoinsertEntry() .
    Eliminar una publicación existenteSe recupera el ID de la publicación seleccionada de la solicitud URL y se construye el URL de feed de publicación usando el ID de blog y el ID de publicación. Esta publicación es eliminada luego el método delete() del objeto de servicio.
    Editar una publicación existenteSe recupera el ID de la publicación seleccionada de la solicitud URL y se construye el URL de feed de publicación usando el ID de blog y el ID de publicación. Luego se recupera la publicación usando el método get()del objeto de servicio. El contenido de la publicación es usado para pre-completa el formulario web de edición, junto con un campo oculto que contiene el ID de publicación única.

    Después de que el usuario hace cambios al contenido y vuelve a presentar el formulario, el ID de publicación oculto es usado para identificar y actualizar la publicación existente con el método updateEntry() .

Apuntando a la simplicidad, este script no incluye ninguna validación de entrada. En un ambiente de producción usted necesitará añadir validación para asegurarse de la integridad y la validez de los datos que están siendo recolectados del usuario.

La Figura 5 muestra el ejemplo del sistema de administración de contenido.

Figura 5. Interfaz de administración de contenido de blog
Interfaz de administración de contenido de blog

Conclusión

En este artículo, usted aprendió cómo integrar publicaciones de blog Blogger directamente en una aplicación PHP usando la API Blogger Data y la biblioteca de cliente Zend Gdata. El artículo proporcionó una introducción al formato de feed Blogger. Usted también aprendió a:

  • Recuperar blogs, publicaciones y comentarios
  • Añadir, editar y eliminar publicaciones
  • Ver, añadir y editar comentarios

La API Blogger proporciona un mecanismo sofisticado e independiente en cuanto a formato, para integrar contenido de blog público dentro de cualquier aplicación web. Es formidable para mashups, o para construir su propia interfaz personalizada para Blogger. Inténtelo alguna vez, y verá lo que puede hacer.

Recursos

Aprender

Obtener los productos y tecnologías

Comentar

Comentarios

developerWorks: Ingrese

Los campos obligatorios están marcados con un asterisco (*).


¿Necesita un IBM ID?
¿Olvidó su IBM ID?


¿Olvidó su Password?
Cambie su Password

Al hacer clic en Enviar, usted está de acuerdo con los términos y condiciones de developerWorks.

 


La primera vez que inicie sesión en developerWorks, se creará un perfil para usted. La información en su propio perfil (nombre, país/región y nombre de la empresa) se muestra al público y acompañará a cualquier contenido que publique, a menos que opte por la opción de ocultar el nombre de su empresa. Puede actualizar su cuenta de IBM en cualquier momento.

Toda la información enviada es segura.

Elija su nombre para mostrar



La primera vez que inicia sesión en developerWorks se crea un perfil para usted, teniendo que elegir un nombre para mostrar en el mismo. Este nombre acompañará el contenido que usted publique en developerWorks.

Por favor elija un nombre de 3 - 31 caracteres. Su nombre de usuario debe ser único en la comunidad developerWorks y debe ser distinto a su dirección de email por motivos de privacidad.

Los campos obligatorios están marcados con un asterisco (*).

(Por favor elija un nombre de 3 - 31 caracteres.)

Al hacer clic en Enviar, usted está de acuerdo con los términos y condiciones de developerWorks.

 


Toda la información enviada es segura.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=90
Zone=
ArticleID=791726
ArticleTitle=Integre contenido de Blogger con aplicaciones PHP usando la API Blogger Data
publish-date=02062012