Nuevo plugin TwitterChecker para Grails.

TwitterChecker se encargará de comprobar periodicamente esta información y lanzar eventos programados. En estos eventos se pueden enviar mensajes directos al nuevo usuario que te sigue, publicar en tu timeline o simplemente guardar la información en base de datos o enviar emails (en caso de unfollows por ejemplo).

Además, el plugin accede periodicamente a tu timeline, menciones y RTs realizados a ti y los guarda en una caché para que los puedas mostrar con una taglib en tus gsp.

TwitterChecker accede a tu cuenta de Twitter (usando Twitter4J y OAuth) y comprueba si hay:

• Nuevos followers y nuevos unfollows (gente que te deja de seguir).
• Nuevos RTs de tus twits realizados por otros usuarios.
• Nuevas menciones realizadas por otros usuarios.

Requisitos:

• Quartz plugin 0.4.1 o superior.
• Grails 1.2.0 o superior.
• Tomcat Julli 6.0.16 o superior.

Y una cuenta de Twitter, claro.

El plugin incluye la librería twitter4j-core-2.1.7.jar (la última versión estable)

Instalación

grails install-plugin twitter-checker

Si no estas desplegando el War en un Tomcat, es posible que necesites el jar tomcat-juli-6.0.16. Si estás usando Grails 1.3+ puedes añadirlo en el fichero BuildConfig.groovy:

dependencies { 
 runtime 'org.apache.tomcat:juli:6.0.16' 
}

La instalación del plugin creará los siguientes archivos dentro de tu proyecto:

1. controllers/twitterChecker/TwitterCheckerController.groovy
2. views/twitterChecker/demo.gsp
3. views/twitterChecker/index.gsp
4. views/twitterChecker/_twitFromMe.gsp
5. views/twitterChecker/_twitFromOther.gsp
6. src/groovy/twitterChecker/DefaultTwitterCheckerListener.groovy

Configuración

1 Primero necesitas crear una aplicación en Twitter en esta dirección: http://dev.twitter.com/apps/new con estas opciones: "Default access type" a "read&write" y "Application type" a "client". Una vez creada la aplicación, deberás apuntar el consumer key y el consumer secret.

2. Añade el siguiente fragmento en el archivo Config.groovy de tu aplicación Grails.

grails.spring.bean.packages = ["twitterChecker"] 
twitterChecker { 
    oauth.consumerKey = "AQUI VA EL CONSUMER KEY DE LA APLICACION QUE HAS CREADO EN TWITTER" 
    oauth.consumerSecret = "Y AQUI VAL EL CONSUMER SECRET" 
    storageFolder = "/ruta/al/directorio/donde/twitter/checker/guardara/sus/archivos" 
}

• grails.spring.bean.package contiene el paquete donde está la clase DefaultTwitterCheckerListener.groovy. No modifiques este valor incluso si renombras la clase, solo es necesario modificarlo si mueves la clase de sitio.
• outh.consumerKey and oauth.consumerSecret: pon aquí los valores consumer key y consumer secret de tu aplicación de Twitter.
• storageFolder: el plugin necesita una ruta donde guardar 4 archivos binarios que se corresponden con los followers, menciones y RT.

3. Autoriza tu cuenta de Twitter con la aplicación de Twitter que acabas de crear.

• Arranca ahora la aplicación Grails (ignora los errores de OAuth que verás en los logs) y visita la dirección del controlador TwitterCheckerController en tu navegador: http://localhost:8080/yourAppName/twitterChecker
• Sigue las instrucciones, que son: obtener el nuevo pin (logarte en twitter, hacer click en "allow acces"), introducirlo en el formulario y hacer click en submit.
• Si todo ha ido bien, la aplicación te mostrará un fragmento de código con los valores accountId, token y tokenSecret que deberás añadir en tu Congig.groovy

4. Reinicia tu aplicación y visita de nuevo TwitterCheckerController en tu navegador: http://localhost:8080/yourAppName/twitterChecker. Verás una página con tu timeline, menciones y RTs (si estás intrigado, puedes ver el contenido de esta página en views/twitterChecker/demo.gsp)

5. Una vez configurada tu aplicación con tu token y tokenSecret, puedes borrar el controlador TwitterCheckerController.groovy y las vistas twitterChecker/demo.gsp y twitterChecker/index.gsp. Pero no borres las vistas _twitFromMe.gsp y _twitFromOther.gsp, ya que son utilizadas por los taglibs (puedes modificarlas, pero no borrarlas)

Mostrar timeline, menciones y RTs

Para mostrar tu timeline, menciones y RTs en tu aplicación puedes usar estas tags (como puedes ver en la vista demo.gsp):

<twitterChecker:timeline max="10"/> 
<twitterChecker:mentions max="200"/> 
<twitterChecker:rts/>

(El parámetro max es opcional y puedes usarlo en cualquiera de las tres tags)

El plugin refrescará esta información cada 15 minutos y el taglib mostrará siempre una versión cacheada de estos datos, de esta manera se pueden utilizar tantas veces como se deseen estos taglib en tu aplicación. Se usarán las vistas _twitFromMe.gsp y _twitFromOther.gsp que están en tu propio proyecto, por lo que puedes modificarlas si lo necesitas.

Eventos

Cada 15 minutos, el plugin chequeará tu cuenta de Twitter en busca de nuevos followers, unfollows, menciones y RT. Puedes abrir la clase src/groovy/twitterChecker/DefaultTwitterCheckerListener.groovy que está copiada en tu propio proyecto y modificar los closures onNewFollowers, onUnfollows, onMentions y onRetweets que serán los que se ejecutarán cada vez que el plugin detecte un cambio en tu cuenta.

Puedes modificar cada cuanto tiempo el plugin chequeará tu cuenta de Twitter añadiendo estos valores en tu Config.groovy:

twitterChecker { 
 checkTimelineEvery = 5  // 5 minutes 
 checkMentionsEvery = 30 // 30 minutes 
 checkRetweetsEvery = 30 // 30 minutes 
 checkFollowersEvery = 120 // 2 hours 
}

ATENCIÓN: Recuerda que Twitter limita el acceso a su Api a 350 peticiones por hora y aplicación. Cada vez que el plugin chequea tu timeline, menciones, rts y followers es una request, por lo que un valor de 15 minutos implica 16 peticiones en una hora. Bajar este tiempo puede incrementar drasticamente el número de peticiones a la hora.

Usando la api the Twitter4J

El plugin proporciona el servicio TwitterCheckerService que actua igual que una clase twitter4j.Twitter ya preconfigurada gracias a la anotación @Delegate de Groovy. Es decir, este servicio tiene los mismos métodos que la clase twitter4j.Twitter (aunque si abrimos la clase no los veamos). Para ampliar información sobre los métodos de esta clase con los que enviar mensajes directos, publicar en el timeline, etc: http://twitter4j.org/en/javadoc-latest/core/twitter4j/Twitter.html

Además, el servicio TwitterCheckerService tienes estas nuevas propiedades: cachedMentions, cachedTimeline y cachedRts que serán usadas por las taglibs para renderizar las vistas.

Puedes usar este servicio desde cualquier controlador, por ejemplo:

class MyController { 
 
    def twitterCheckerService 
 
    def updateStatus = { 
        // use the http://twitter4j.org/en/javadoc-latest/core/twitter4j/Twitter.html#updateStatus(java.lang.String) method 
        def status = twitterCheckerService.updateStatus("Test from grails TwitterChecker plugin") 
        ... 
    } 
 
    def readTimeline = { 
        // use the cached version of the user timeline 
        println twitterChecerService.cachedTimeline 
        // get a new fresh version of the user timeline http://twitter4j.org/en/javadoc-latest/core/twitter4j/Twitter.html#getUserTimeline() 
        def timeline = twitterCheckerService.userTimeline 
        ... 
    } 
}

Crear un nuevo checker que consulte y cachee información de Twitter

Por ejemplo, si quieres mostrar en tu aplicación los resultados de buscar el tag #grailsx en Twitter, puedes crearte un nuevo job en Quartz que consulte esta información y la cachee para después mostrarla.

class CheckSearchQueryJob  { 
 
    def yourOwnService // Servicio donde se desea guardar la información cacheada 
 
    static triggers = { 
        simple(name: 'CheckSearchQueryJob', 
        repeatInterval: 15*60*1000) // Every 15 minutes 
    } 
 
    TwitterCheckerService twitterCheckerService 
    def execute() { 
        def resultQuery = twitterCheckerService.search(new twitter4j.Query("#grailsx")) 
        yourOwnService.cachedQuery = resultQuery // Guardar la información en un servicio 
    } 
}

Después solo tienes que acceder al atributo yourOwnService.cachedQuery desde tus vistas.

Resolución de problemas

Si obtienes esta exepción:

Caused by: 401:Authentication credentials were missing or incorrect. 
{"error":"Read-only application cannot POST","request":"\/1\/statuses\/update.json"}

Es porque tu aplicación es solo de lectura y no te permite actualizar tu estado ni enviar mensajes.

1. Ve a http://dev.twitter.com, edit your app details y asegúrate de que se ha elegido "read-write" en access type.
2. Visita tu cuenta de Twitter y revoca los permisos a tu aplicación en in .
3. En tu aplicación Grails, quita el token y tokenSecret actuales de tu Config.groovy, reinicia y vuelve a solicitar un pin para dar permisos a tu aplicación (es decir, repite todo el proceso de autorización).