La API de Blogger Data permite que las aplicaciones cliente vean y actualicen el contenido de Blogger en forma de feeds de la API de Google Data.
Tu aplicación cliente puede usar la API de datos de Blogger para crear un blog nuevo. entradas de blog, editar o borrar entradas de blog, y buscar entradas de blog que coincidan criterios particulares.
Además de proporcionar información sobre las funciones de la API de datos de Blogger, este documento ofrece ejemplos de interacciones básicas con la API de datos mediante la biblioteca cliente de Python. Si te interesa conocer mejor los conceptos protocolo que usa la biblioteca, consulta la sección Protocolo de esta guía para desarrolladores.
Contenido
Público
Este documento está dirigido a los programadores que desean escribir código de cliente Python. que pueden interactuar con Blogger.
En este documento, se asume que comprendes las ideas generales detrás de las APIs de datos de Google protocolo.
Para obtener información de referencia general de la API de Blogger Data, consulta la Guía de referencia del protocolo.
Cómo comenzar
Para obtener ayuda en la configuración de la biblioteca cliente, consulta el artículo Cómo obtener de la Guía de inicio rápido.
La biblioteca cliente de Python requiere Python 2.2 o una versión posterior. Después de descargar la biblioteca cliente, también deberás descargar e instalar el paquete ElementTree.
Crea una cuenta de Blogger
Te recomendamos que te registres para obtener un Cuenta de Blogger con fines de prueba. Blogger usa Cuentas de Google, así que si ya tienes una Cuenta de Google, no tienes que hacer nada más.
Cómo ejecutar el código de muestra
Un cliente de muestra funcional completo, que contenga todo el código de muestra que aparece en este
está disponible en la BloggerExample.py
en el directorio
gdata-python-client/samples/blogger/
El cliente de ejemplo realiza varias operaciones en el blog proporcionado para demostrar el uso de la API de Blogger Data.
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 instrucciones 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 con la API de datos de Blogger. Los feeds públicos no requieren ninguna autenticación, pero son de solo lectura. Si modificar un blog, entonces tu cliente debe autenticarse antes de solicitar feeds privados. Puede autenticarse con cualquiera de estos tres enfoques:autenticación OAuth, proxy AuthSub autenticación o nombre de usuario y contraseña de ClientLogin la autenticación de varios factores.
Para obtener más información sobre la autenticación con las APIs de datos de Google en general, consulta la documentación de autenticación documentación.
En la mayoría de las muestras de las secciones posteriores de este documento se supone que has
una instancia de GDataService autenticada.
Autenticación de OAuth
Para ver documentación sobre la autenticación de OAuth con la biblioteca Python GData, consulta OAuth en Bibliotecas cliente del protocolo de datos de Google.
Autenticación del proxy de AuthSub
La autenticación del proxy de AuthSub es utilizada por las aplicaciones web que necesitan autenticar a sus usuarios en Cuentas de Google. El operador del sitio web y el cliente no tenga acceso al nombre de usuario ni a la contraseña del usuario de Blogger; en su lugar, el cliente obtiene tokens AuthSub especiales que le permiten 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 ha estado autenticado. En este caso, debes mostrar información y un vínculo dirigir 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 incluye los siguientes parámetros
(correspondiente a los parámetros de consulta que usa el controlador de AuthSubRequest):
- siguiente
- Es la URL de la página a la que Google debe redireccionar al usuario después de la autenticación.
- alcance
- Indica que la aplicación solicita un token para acceder a los feeds de Blogger. La string de alcance que se debe usar es
http://www.blogger.com/feeds/(codificada como URL, por supuesto). - seguro
- Indica si el cliente solicita un token seguro.
- sesión
- Indica si el token que se muestra se puede intercambiar por un token de uso múltiple (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 solicitud resultante podría verse de la siguiente manera:
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 consulta next de la URL de AuthSubRequest. El sistema AuthSub agrega un token de autenticación a esa URL, como el
del parámetro de consulta token. Por ejemplo:
http://www.example.com/welcome.pyc?token=yourAuthToken
Existen varias formas de recuperar el valor del token desde la URL. por ejemplo:
import cgi parameters = cgi.FieldStorage() authsub_token = parameters['token']
Este valor de token representa un token de AuthSub de un solo uso. En este ejemplo,
como se especificó session = True, este token se puede intercambiar por
un token de sesión de AuthSub con el método UpgradeToSessionToken
que llama a AuthSubSessionToken
servicio:
blogger_service = service.GDataService() blogger_service.auth_token = authsub_token blogger_service.UpgradeToSessionToken()
Es decir, se pasa el token de un solo uso al
UpgradeToSessionToken, y la interfaz AuthSub muestra un
token de sesión.
Luego, tu aplicación puede usar el valor del token de sesión en interacciones con Blogger. La biblioteca cliente envía automáticamente el token junto con las solicitudes.
Autenticación de nombre de usuario o contraseña de ClientLogin
Usa la autenticación ClientLogin si tu cliente es un usuario independiente
"instalado" cliente (como una aplicación de escritorio). Simplemente llama al
método ProgrammaticLogin() en tu GDataService
y todas las interacciones posteriores con Blogger se
autenticados:
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 de GDataService. El primero es el nombre de nuestra aplicación en
el formato companyName-applicationName-versionID.
El segundo es el nombre del servicio con el que queremos interactuar; el tercero es la
dirección del servidor.
Ten en cuenta que account_type está configurado explícitamente como
GOOGLE Si no configuras este parámetro, los usuarios de G Suite no podrán usar correctamente la API de Blogger.
Para obtener más información sobre la autenticación de ClientLogin, incluidas las solicitudes y respuestas de muestra, consulta la documentación Autenticación para aplicaciones instaladas.
Nota: Usa el mismo token para todas las solicitudes de un sesión determinada; no adquieren un token nuevo para cada solicitud de Blogger.
Nota: Como se describe en la documentación de ClientLogin, es posible que la solicitud de autenticación falle y solicite un desafío de CAPTCHA. Si deseas que Google emita y se encargue del desafío de CAPTCHA, entonces
enviar al usuario a
https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger
(en lugar de la URL de control de CAPTCHA que se proporciona en el archivo ClientLogin
documentación).
Cómo recuperar una lista de blogs
La API de Blogger Data proporciona un feed que enumera los blogs de un usuario en particular. Ese feed se conoce como “metafeed”.
En el siguiente código de muestra, se usa una instancia 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 opción predeterminada
URL del metafeed; muestra una lista de blogs del usuario autenticado actualmente.
Para acceder al feed de un usuario diferente, puedes colocar el ID del usuario en lugar del ID
default en la URL del metafeed. El ID del usuario es una cadena de dígitos
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 las publicaciones y los comentarios. El siguiente fragmento elige el primer blog recuperados para un usuario.
blog_id = feed.entry[0].GetSelfLink().href.split("/")[-1]
En la muestra de BloggerExample.py, se agrega un elemento BloggerExample
se crea la clase, y el ID del blog se establece en el constructor para facilitar el acceso
más adelante. Para la mayoría de los siguientes ejemplos en este documento,
blog_id se pasa como una variable.
Cómo crear publicaciones
La API de datos de Blogger te permite crear y publicar entradas de blog nuevas, como así como crear borradores de entradas.
Nota: Por el momento, no se admite configurar un autor personalizado para las publicaciones. Todas las publicaciones nuevas aparecerán como si las hubiera creado el usuario autenticado actualmente.
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 de GDataService para insertar la entrada. Aquí tienes
un ejemplo de cómo publicar una nueva entrada de blog:
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!')
Cómo crear un borrador de una entrada de blog
Los borradores de entradas se crean del mismo modo que las publicaciones públicas, pero debes establecer
el elemento de extensión draft en GDataEntry
instancia. La entrada de blog anterior se podría crear como un borrador si se agregan las 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?')
Para convertir un borrador de entrada de blog existente en una entrada publicada, recupera la entrada de borrador, establece el atributo de borrador en no y, luego, actualízala. En las siguientes dos secciones, veremos cómo recuperar y actualizar las publicaciones.
Cómo recuperar 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 publicaciones de un blog público.
Cómo recuperar todas las entradas de blog
Para recuperar las publicaciones del usuario, llama al método GetFeed con el
URL del feed de 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 mediante parámetros de consulta
La API de Blogger Data te permite solicitar un conjunto de entradas que coincidan con criterios especificados, como solicitar publicaciones de blog publicadas o actualizadas en un período determinado. Para ello, crea una instancia de Query y, luego, llama al
Get().
Por ejemplo, para enviar una consulta de período, configura published_min
y las propiedades published_min de la instancia Query.
El siguiente fragmento de código imprime el título y el contenido de cada entrada de blog
publicados entre las horas de inicio y finalización indicadas:
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 del feed de publicaciones que se usa para recuperar las publicaciones.
La API de Blogger Data admite las siguientes propiedades Query:
- categorías
- Especifica 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',]. - max_results
- La cantidad máxima de entradas que se mostrarán.
- published_min, published_max
- Los límites en las fechas de publicación de la entrada.
- start_index
- Es el índice basado en 1 del primer resultado que se recuperará (para paginación).
- updated_min, updated_max
- Los límites en las fechas de actualización de la entrada. Estos parámetros de consulta se ignoran, a menos que el parámetro
orderbyse establezca enupdated.
Para obtener más información sobre los parámetros de consulta, consulta la Guía de referencia de la API de datos de Blogger y la Guía de referencia de las APIs de datos de Google.
Actualiza publicaciones
Para actualizar una entrada de blog existente, primero recupera la entrada que quieres
actualizarlo, lo modificas y, luego, lo envías a Blogger mediante el
Put. El siguiente fragmento de código modifica el título de una entrada de blog, siempre que ya hayas recuperado 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 entrada que se actualizó recientemente. Para actualizar cualquier otra propiedad, simplemente establécelas en el
Instancia GDataEntry antes de llamar a Put.
Nota: Actualmente, no se admite la modificación de los datos del autor asociados con las publicaciones.
Cómo borrar publicaciones
Para borrar una publicación, pasa su URL de edició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 borrar comentarios. No se pueden actualizar los comentarios (ni están disponibles en la interfaz web).
Cómo crear 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: Actualmente, solo puedes publicar comentarios en un blog que pertenezca al usuario autenticado.
Nota: Por el momento, no se admite configurar un autor personalizado para los comentarios. Todos los comentarios nuevos aparecerán como si los hubiera creado el usuario autenticado actualmente.
Cómo recuperar comentarios
Puedes recuperar los comentarios de una publicación en particular desde la URL del feed de comentarios de la publicación:
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
O puedes ver los comentarios de todas las entradas a través de la URL del feed de comentarios del blog:
http://www.blogger.com/feeds/blogID/comments/default
Cómo borrar comentarios
Para borrar un comentario, pasa la URL de edición del comentario al método Delete de 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)