La API de datos de Blogger permite que las aplicaciones cliente vean y actualicen el contenido de Blogger en forma de feeds de la API de datos de Google.
Tu aplicación cliente puede usar la API de datos de Blogger para crear entradas de blog nuevas, editar o borrar entradas de blog existentes, y consultar entradas de blogs que coincidan con criterios específicos.
Además de proporcionar información sobre las capacidades de la API de datos de Blogger, en este documento, se proporcionan ejemplos de interacciones básicas para la API de datos mediante la biblioteca cliente de Python. Si te interesa obtener más información sobre el protocolo subyacente que usa la biblioteca, consulta la sección Protocolo de esta guía para desarrolladores.
Contenido
Público
Este documento está dirigido a programadores que desean escribir aplicaciones cliente de Python que pueden interactuar con Blogger.
En este documento, se supone que comprendes las ideas generales detrás del protocolo de las API de datos de Google.
Para obtener información general de referencia sobre la API de datos de Blogger, consulta la Guía de referencia del protocolo.
Cómo comenzar
Si deseas obtener ayuda para configurar la biblioteca cliente, consulta la Guía de introducción.
La biblioteca cliente de Python requiere Python 2.2 o una versión más reciente. Después de descargar la biblioteca cliente, también deberás descargar y, luego, instalar el paquete ElementTree.
Creación de una cuenta de Blogger
Te recomendamos que te registres en una cuenta de Blogger para realizar pruebas. Blogger usa Cuentas de Google, así que si ya tienes una, ya estás listo.
Cómo ejecutar el código de muestra
Un cliente de muestra funcional completo, que contiene todo el código de muestra que se muestra en este documento, está disponible en el archivo BloggerExample.py, en el directorio gdata-python-client/samples/blogger/.
El cliente de muestra realiza varias operaciones en el blog proporcionado para demostrar el uso de la API de datos de Blogger.
Puedes ejecutar la muestra con los siguientes argumentos:
python BloggerExample.py --email [email_address] --password [password]
Para usar los ejemplos de este documento en tu propio código, necesitarás las siguientes declaraciones import:
from gdata import service import gdata import atom
Autenticación en el servicio de Blogger
Puedes acceder a los feeds públicos y privados mediante la API de datos de Blogger. Los feeds públicos no requieren autenticación, pero son de solo lectura. Si deseas modificar los blogs, tu cliente debe autenticarse antes de solicitar los feeds privados. Se puede autenticar mediante cualquiera de estos tres métodos:autenticación de OAuth, autenticación de proxy de AuthSub o autenticación de nombre de usuario y contraseña de ClientLogin.
Para obtener más información sobre la autenticación con las API de datos de Google en general, consulta la documentación de autenticación.
En la mayoría de los ejemplos de las secciones posteriores de este documento, se supone que tienes una instancia de GDataService autenticada.
Autenticación de OAuth
Para obtener documentación sobre la autenticación de OAuth con la biblioteca de GData de Python, consulta OAuth en las bibliotecas cliente del protocolo de datos de Google.
Autenticación del proxy de AuthSub
Las aplicaciones web que necesitan autenticar a sus usuarios en Cuentas de Google usan la autenticación del proxy de AuthSub. El operador del sitio web y el código de cliente no tienen acceso al nombre de usuario y la contraseña del usuario de Blogger; en cambio, el cliente obtiene tokens especiales de AuthSub que le permiten al cliente actuar en nombre de un usuario en particular. Para obtener información más detallada, consulta la documentación de AuthSub.
Cuando un usuario visita tu aplicación por primera vez, aún no se autenticó. En este caso, debes mostrar información y un vínculo que dirija al usuario a una página de Google para autenticar tu solicitud de acceso a sus blogs. La biblioteca cliente de Python proporciona una función para generar la URL de la página de Google. El siguiente código recupera la URL de la página AuthSubRequest:
def GetAuthSubUrl(): next = 'http://www.example.com/welcome.pyc' scope = 'http://www.blogger.com/feeds/' secure = False session = True blogger_service = service.GDataService() return blogger_service.GenerateAuthSubURL(next, scope, secure, session); authSubUrl = GetAuthSubUrl(); print '<a href="%s">Login to your Google account</a>' % authSubUrl
El método GenerateAuthSubURL toma los siguientes parámetros (correspondientes a los parámetros de consulta que usa el controlador AuthSubRequest):
- siguiente
- Es la URL de la página a la que Google debe redireccionar al usuario después de la autenticación.
- permiso
- Indica que la aplicación solicita un token para acceder a los feeds de Blogger. La string del alcance que se usará es
http://www.blogger.com/feeds/(codificada en la URL, por supuesto). - seguras
- Indica si el cliente solicita un token seguro.
- sesión
- Indica si el token que se muestra se puede intercambiar por un token multiuso (sesión).
En el ejemplo anterior, se muestra una llamada que no solicita un token seguro (el valor de secure es False). La URL de la solicitud resultante podría verse así:
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.pyc
El usuario sigue el vínculo al sitio de Google y se autentica en su cuenta de Google.
Después de que el usuario se autentica, el sistema de AuthSub lo redirecciona a la URL que especificaste en el parámetro de búsqueda next de la URL de AuthSubRequest. El sistema AuthSub agrega un token de autenticación a esa URL, como el valor del parámetro de búsqueda token. Por ejemplo:
http://www.example.com/welcome.pyc?token=yourAuthToken
Hay varias formas de recuperar el valor del token de la URL; por ejemplo:
import cgi parameters = cgi.FieldStorage() authsub_token = parameters['token']
Este valor de token representa un token de AuthSub de uso único. En este ejemplo, dado que se especificó session = True, este token se puede intercambiar por un token de sesión de AuthSub mediante el método UpgradeToSessionToken, que llama al servicio AuthSubSessionToken:
blogger_service = service.GDataService() blogger_service.auth_token = authsub_token blogger_service.UpgradeToSessionToken()
Es decir, debes pasar el token de uso único al método UpgradeToSessionToken, y la interfaz de AuthSub muestra un token de sesión.
Tu aplicación puede usar el valor del token de sesión en interacciones posteriores con Blogger. La biblioteca cliente envía automáticamente el token junto con las solicitudes.
Autenticación de nombre de usuario/contraseña de ClientLogin
Usa la autenticación ClientLogin si tu cliente es un cliente independiente instalado de un solo usuario (como una aplicación de escritorio). Solo debes llamar al método ProgrammaticLogin() en tu instancia de GDataService y se autenticarán todas las interacciones posteriores con Blogger:
blogger_service = service.GDataService('user@example.com', 'secretPassword')
blogger_service.source = 'exampleCo-exampleApp-1.0'
blogger_service.service = 'blogger'
blogger_service.account_type = 'GOOGLE'
blogger_service.server = 'www.blogger.com'
blogger_service.ProgrammaticLogin()
En el fragmento anterior, configuramos tres propiedades en la instancia GDataService. El primero es el nombre de nuestra aplicación con el formato companyName-applicationName-versionID. El segundo es el nombre del servicio con el que queremos interactuar, y el tercero es la dirección del servidor.
Ten en cuenta que account_type se establece explícitamente en GOOGLE. Si no se configura este parámetro, los usuarios de G Suite no podrán usar la API de Blogger correctamente.
Para obtener más información sobre la autenticación de ClientLogin, incluidas las solicitudes y respuestas de muestra, consulta la documentación de Autenticación para aplicaciones instaladas.
Nota: Usa el mismo token para todas las solicitudes de una sesión determinada; no adquieras un token nuevo para cada solicitud de Blogger.
Nota: Como se describe en la documentación de ClientLogin, la solicitud de autenticación puede fallar y solicitar un desafío CAPTCHA. Si deseas que Google emita y maneje la verificación de CAPTCHA, envía al usuario a https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger (en lugar de a la URL de control de CAPTCHA proporcionada en la documentación de ClientLogin).
Cómo recuperar una lista de blogs
La API de datos de Blogger proporciona un feed que enumera los blogs de un usuario en particular. Ese feed se conoce como &meta; metafeed.
En el siguiente código de muestra, se usa una instancia de GDataService autenticada para recuperar el metafeed y, luego, imprimir el título de cada blog.
def PrintUserBlogTitles(blogger_service):
query = service.Query()
query.feed = '/feeds/default/blogs'
feed = blogger_service.Get(query.ToUri())
print feed.title.text
for entry in feed.entry:
print "\t" + entry.title.text
Ten en cuenta la URL que usa el método Get. Esta es la URL de metafeed predeterminada; se muestra una lista de blogs para el usuario autenticado actualmente.
Para acceder a un feed de un usuario diferente, puedes colocar el ID del usuario en lugar de default en la URL del feed de metadatos. El ID del usuario es la string de dígitos que aparece al final de la URL del perfil del usuario.
En el siguiente fragmento de código, se muestra cómo extraer un ID de blog del feed. Necesitarás el ID del blog para realizar operaciones de creación, actualización y eliminación en entradas y comentarios. El siguiente fragmento elige el primer blog recuperado para un usuario.
blog_id = feed.entry[0].GetSelfLink().href.split("/")[-1]
En la muestra BloggerExample.py, se crea una clase BloggerExample y el ID de blog se establece en el constructor para un acceso fácil más adelante. Para la mayoría de los siguientes ejemplos en este documento, blog_id se pasa como una variable.
Crear publicaciones
La API de datos de Blogger te permite crear y publicar entradas de blog nuevas, además de crear borradores de entradas.
Nota: Por el momento, no se admite la configuración de un autor personalizado para las publicaciones. Todas las publicaciones nuevas aparecerán como si fueran creadas por el usuario autenticado actual.
Publicar una entrada de blog
Puedes usar la biblioteca cliente de Python para publicar entradas de blog nuevas.
Primero, crea una instancia de GDataEntry para representar la entrada de blog.
Luego, puedes configurar el título, el contenido y otros atributos de la entrada de blog.
Por último, usa la instancia GDataService para insertar la publicación. A continuación, te mostramos un ejemplo de cómo publicar una entrada de blog nueva:
def CreatePublicPost(blogger_service, blog_id, title, content):
entry = gdata.GDataEntry()
entry.title = atom.Title('xhtml', title)
entry.content = atom.Content(content_type='html', text=content)
return blogger_service.Post(entry, '/feeds/%s/posts/default' % blog_id)
blogEntry = CreatePublicPost(blogger_service, blog_id,
title='I have the answer', content='Eureka! It is 42!')
Creando una entrada de blog en borrador
Los borradores de publicaciones se crean de la misma manera que las publicaciones públicas, pero debes configurar el elemento de extensión draft en la instancia GDataEntry. La entrada de blog anterior podría crearse como borrador si agrega las siguientes líneas destacadas:
def CreateDraftPost(blogger_service, blog_id, title, content):
entry = gdata.GDataEntry()
entry.title = atom.Title('xhtml', title)
entry.content = atom.Content(content_type='html', text=content)
control = atom.Control()
control.draft = atom.Draft(text='yes')
entry.control = control
return blogger_service.Post(entry, '/feeds/%s/posts/default' % blog_id)
draftEntry = CreateDraftPost(blogger_service, blog_id,
title='I have the question',
content='What do you get if you multiply six by nine?')
Puedes convertir un borrador de una entrada de blog en una entrada publicada si recuperas la entrada del borrador, estableces el atributo borrador como no y, luego, actualizas la entrada. Abordaremos la recuperación y la actualización de publicaciones en las siguientes dos secciones.
Recuperando publicaciones
En las siguientes secciones, se describe cómo recuperar una lista de entradas de blog, con y sin parámetros de consulta.
Puedes consultar un feed público de Blogger sin autenticación. Por lo tanto, no necesitas configurar credenciales ni realizar la autenticación de AuthSub antes de recuperar entradas de un blog público.
Recuperando todas las entradas de blog
Para recuperar las entradas del usuario, llama al método GetFeed con la URL del feed de la entrada de blog:
def PrintAllPosts(blogger_service, blog_id):
feed = blogger_service.GetFeed('/feeds/' + blog_id + '/posts/default')
print feed.title.text
for entry in feed.entry:
print "\t" + entry.title.text
print "\t" + entry.content.text
print "\t" + entry.updated.text
print
Cómo recuperar publicaciones con parámetros de búsqueda
La API de datos de Blogger te permite solicitar un conjunto de entradas que coincidan con los criterios especificados, como solicitar entradas de blog publicadas o actualizadas en un período determinado. Para ello, crea una instancia de Query y, luego, llama al método Get().
Por ejemplo, para enviar una consulta de período, configura las propiedades published_min y published_min de la instancia Query.
El siguiente fragmento de código imprime el título y el contenido de cada entrada del blog publicada entre la hora de inicio y la hora de finalización:
def PrintPostsInDateRange(blogger_service, blog_id, start_time='2007-04-01', end_time='2007-04-25'):
query = service.Query()
query.feed = '/feeds/' + blog_id + '/posts/default'
query.published_min = start_time
query.published_max = end_time
feed = blogger_service.Get(query.ToUri())
print feed.title.text + " posts between " + start_time + " and " + end_time
for entry in feed.entry:
print "\t" + entry.title.text
print "\t" + entry.content.text
print "\t" + entry.updated.text
print
Ten en cuenta que el objeto Query se construye con la misma URL de feed de entrada que se usó para recuperar las publicaciones.
La API de datos de Blogger admite las siguientes propiedades de Query:
- categorías
- Especifica las categorías (también conocidas como etiquetas) para filtrar los resultados del feed. Por ejemplo,
http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Lauriemuestra entradas con las etiquetasFritzyLaurie. Para especificar esa consulta de categoría en la biblioteca cliente de Python, puedes usarquery.categories = ['Fritz','Laurie',]. - resultados_máx.
- La cantidad máxima de entradas que se mostrarán.
- mín_publicado, máx. publicado
- Los límites en las fechas de publicación de las entradas
- start_index
- El índice basado en 1 del primer resultado que se recuperará (para la paginación).
- updated_min, updated_max
- Los límites en las fechas de actualización de las entradas. Estos parámetros de búsqueda se ignoran, a menos que el parámetro
orderbyesté configurado comoupdated.
Para obtener más información sobre los parámetros de búsqueda, revisa la Guía de referencia de la API de datos de Blogger y la Guía de referencia de las API de datos de Google.
Actualizando entradas
Para actualizar una entrada de blog existente, primero recuperas la entrada que deseas actualizar, la modificas y, luego, la envías a Blogger con el método Put. El siguiente fragmento de código modifica el título de una entrada de blog, suponiendo que ya recuperaste la entrada del servidor.
def UpdatePostTitle(blogger_service, entry_to_update, new_title='The REAL answer'):
entry_to_update.title = atom.Title('xhtml', new_title)
return blogger_service.Put(entry_to_update, entry_to_update.GetEditLink().href)
El código anterior muestra un GDataEntry que contiene toda la publicación recién actualizada. Para actualizar cualquier otra propiedad, solo debes configurarlas en la instancia GDataEntry antes de llamar a Put.
Nota: Por el momento, no se admite modificar los datos del autor asociados con las publicaciones.
Eliminando publicaciones
Para borrar una publicación, pasa la URL de edición de la publicación al método Delete en tu objeto GDataService de la siguiente manera:
def DeletePost(blogger_service, edit_link_href): blogger_service.Delete(edit_link_href)
Comentarios
La API de datos de Blogger permite crear, recuperar y eliminar comentarios. La actualización de comentarios no es compatible (ni está disponible en la interfaz web).
Creación de comentarios
Para publicar un comentario, crea un objeto GDataEntry y, luego, insértalo de la siguiente manera:
def CreateComment(blogger_service, blog_id, post_id, comment_text='Mostly harmless'): feed_uri = '/feeds/' + blog_id + '/' + post_id + '/comments/default' entry = gdata.GDataEntry() entry.content = atom.Content(content_type='xhtml', text=comment_text) return blogger_service.Post(entry, feed_uri)
Nota: Por el momento, solo puedes publicar comentarios en un blog que pertenezca al usuario autenticado.
Nota: Por el momento, no se admite la configuración de un autor personalizado para los comentarios. Todos los comentarios nuevos aparecerán como si los hubiera creado el usuario autenticado actual.
Recuperando comentarios
Puedes recuperar los comentarios de una entrada en particular desde la URL del feed de comentarios de la entrada:
def PrintAllComments(blogger_service, blog_id, post_id):
feed_url = '/feeds/' + blog_id + '/' + post_id + '/comments/default'
feed = blogger_service.Get(feed_url)
print feed.title.text
for entry in feed.entry:
print "\t" + entry.title.text
print "\t" + entry.updated.text
print
También puedes obtener los comentarios de todas las entradas en la URL del feed de comentarios del blog:
http://www.blogger.com/feeds/blogID/comments/default
Borrando comentarios
Para borrar un comentario, pasa la URL de edición del comentario al método Delete en tu objeto GDataService de la siguiente manera:
def DeleteComment(blogger_service, post_id, comment_id): feed_url = '/feeds/' + post_id + '/comments/default/' + comment_id blogger_service.Delete(feed_url)