¡Compártelo!
Share on facebook
Share on google
Share on twitter
Share on linkedin

Automatizando tareas mediante bots en Slack

En el mundo en el que vivimos actualmente, cada vez es más necesario automatizar tareas que resulta tedioso realizarlas de forma manual, desde pruebas funcionales de una aplicación, a envío de emails o casi cualquier tarea que se nos pueda ocurrir. Es por eso que los bots están creciendo exponencialmente en muchas de las aplicaciones que usamos a diario como Facebook, Twitter, Telegram, etc. Hoy veremos cómo realizar bots para Slack de una forma muy sencilla, usando la API RTM (Real Time Message) de Slack y la librería JBot, que permite utilizar Spring Boot facilitando mucho la vida al desarrollador.

Creación de nuestros bots en Slack

En primer lugar, debemos dar de alta nuestro bot en nuestro workspace de Slack, para poder obtener un token con el que realizar la conexión en tiempo real entre nuestro bot y Slack. De esta forma podremos recoger cualquier evento que se produzca. 

Para ello accedemos a la dirección https://nombredetuworkspace.slack.com/apps/search?q=bots y nos aparecerá una pantalla como la siguiente:

Dar de alta nuestro bot en Slack

Entramos en la sección Bots y hacemos click en Añadir a Slack para acceder a la siguiente pantalla:

bots en slack

Aquí damos un nombre a nuestro bot y vamos a Añadir integración robot.

De esta forma, ya tendremos nuestro bot dado de alta en nuestro workspace. En la pantalla que aparece, podemos personalizar distintos parámetros sobre el bot, como nombre de usuario, imagen, funciones, canales donde aparece, etc. Aunque lo más significativo para nuestro caso sería el apartado Token, el cual usaremos en nuestra aplicación para conectarnos:

Creación del bot con JBot

Una vez tenemos nuestro bot dado de alta en nuestro workspace, nos quedaría implementar la funcionalidad que queremos que realice nuestro bot. En este caso, vamos a implementar una sencilla conversación con nuestro bot, que nos permita crear tarjetas en Trello de forma automática a través de Slack. 

Nota aclaratoria: Nos centraremos en la configuración e implementación del bot y no en la configuración y uso de la API de Trello.

Creación del proyecto

En primer lugar, nos creamos un proyecto Spring Boot desde https://start.spring.io/ y añadimos las librerías necesarias para la casuística a realizar. En nuestro caso bastaría con la dependencia de WebFlux para el consumo de la API de Trello y Lombok para facilitar la creación de los modelos.

Una vez tengamos nuestro proyecto descargado y abierto en nuestro IDE, procederemos a añadir la dependencia siguiente de JBot:

  me.ramswaroop.jbot
  jbot
  4.0.0

En el siguiente enlace os dejo la documentación de JBot.

Configuración

En nuestro fichero application.yml debemos poner las siguientes propiedades para conectarnos a la API de RTM:

rtmUrl: 
  ‘https://slack.com/api/rtm.start?token={token}&simple_latest&no_unreads‘

api.slack.token = vuestro token obtenido en la creación del bot en slack

La propiedad rtmUrl indica la dirección donde tiene que conectarse para realizar la comunicación en tiempo real, mientras que api.slack.token se refiere al token propio de nuestro bot.

Creación de la lógica del bot

En primer lugar, debemos escanear el paquete de la librería JBot para que Spring reconozca sus beans:

@SpringBootApplication(scanBasePackages = {“me.ramswaroop.jbot”, “es.profile.slackbot”})
  public class FridaysTechApplication {
  
     public static void main(String[] args) {
         SpringApplication.run(FridaysTechApplication.class, args);
     }
  }

Una vez tenemos los beans de JBot en el contexto de Spring, nuestra aplicación está lista para funcionar.

Nuestra clase principal del bot será SlackBot y esta deberá extender de la clase Bot, la cual ya nos provee de varios métodos y utilidades como enviar un mensaje al destinatario, empezar una conversación, terminar una conversación, etc, y además deberá ser anotada con @JBot.

  @Value(“${api.slack.token}”)
  private String token;

  @Override
  public String getSlackToken() {
      return this.token;
  }

  @Override
  public Bot getSlackBot() {
      return this;
  }

Ya solo nos quedaría recoger los eventos que se produzcan con nuestro bot y realizar la lógica deseada. Para ello, JBot nos provee de la anotación @Controller, la cual tiene un atributo events donde podemos indicarle todos los eventos que queremos escuchar (en la clase EventType tenemos todos los disponibles).

Además, esta anotación nos permite añadir cuál será el controller siguiente en caso de que queramos empezar una conversación mediante el atributo next.

  @Controller(events = {EventType.DIRECT_MESSAGE, EventType.DIRECT_MENTION}, next = Steps.PROCESS_URL)
  public void welcome(WebSocketSession session, Event event) {
      SessionUtils.registerStep(session, Steps.INITIAL_STEP);
      SessionUtils.registerUser(session, slackService.getUsers(), event.getUserId());
      startConversation(event, Steps.PROCESS_URL);
      reply(session, event, ReplyMessages.WELCOME);
  }

Como vemos en la imagen anterior, estamos escuchando los eventos de mensaje directo al bot o una mención directa para poder reaccionar ante ellos. De igual forma, estamos indicando cuál sería nuestro próximo “paso” en la conversación, apoyándonos en una clase propia llamada Steps donde indicamos todos los pasos posibles.

JBot nos ofrece una sesión con la que poder jugar con los parámetros que nos van llegando en los distintos eventos que escuchemos, de forma que podamos ir recopilando todos los datos de esta conversación para interactuar con ellos en el último paso. Para ello, nos apoyamos en una clase propia llamada SessionUtils, encargada de leer o escribir en la sesión. De esta forma, registramos el paso de la conversación en que estamos y el usuario que ha realizado el evento.

Mediante startConversation indicamos a JBot que vamos a empezar una conversación y que el siguiente evento que escuche deberá ir al controller indicado y utilizamos reply para devolver mensajes a nuestra conversación de slack, en este caso, apoyándonos de nuevo en una clase auxiliar donde pondremos todos los mensajes:

  @Controller(events = EventType.DIRECT_MESSAGE)
  public void processUrl(WebSocketSession session, Event event) {
      if (continueConversation(session, event)) {
          SessionUtils.registerStep(session, Steps.CREATE_CARD);
          fridaysTechService.sendCard(session, event.getText()).subscribe(response -> validateResponse(session, event, response));
          stopConversation(event);
          SessionUtils.cleanSession(session);
      }
  }

Por último, definimos el siguiente paso, que se encargaría de recoger el valor que nos manden y enviarlo a Trello para crear la tarjeta correspondiente.

De igual forma que en el primer paso, escuchamos el evento de mensaje directo, pero esta vez no indicamos el siguiente paso puesto que será nuestro último paso de la conversación.

En primer lugar comprobamos que la palabra que ha escrito el usuario no es “salir” (u otra palabra para terminar la conversación). Registramos el paso y llamamos al servicio correspondiente para enviar a Trello nuestro mensaje.

El método validate response comprueba si la petición ha ido correctamente y envía un mensaje u otro a Slack:

  private void validateResponse(WebSocketSession session, Event event, TrelloResponse response) {
  if (response.isSuccess()) {
      reply(session, event, ReplyMessages.FridaysTech.SEND_TRELLO_OK);
  } else {
      reply(session, event, ReplyMessages.ERROR_SEND_TRELLO);
  }
}

Por último, le indicamos a JBot que cerramos la conversación y limpiamos la sesión.

En la siguiente imagen podemos ver una ejecución del bot en el que le añadimos un paso más para incluir una descripción en la tarjeta:

Conclusión

Con estos breves pasos, hemos conseguido crear nuestro primer bot en menos de una hora, dando así la posibilidad de implementar cualquier funcionalidad que necesitemos en poco tiempo.

¡Dad rienda suelta a vuestra imaginación y animaros a contarnos qué funcionalidad realizaríais para vuestro workspace de Slack!

Artículos relacionados

QA en el desarrollo de software

La importancia del QA en el desarrollo de software

¿Entregarías un proyecto al cliente sin asegurarte de que funciona todo tal y como se especificó en la toma de requerimientos? ¿Es necesario hacer pruebas durante todo el desarrollo de un proyecto o solo en la fase final? En un proyecto con metodología scrum, ¿dónde

Qué es Ionic

Qué es Ionic y por qué utilizarlo para desarrollar aplicaciones móviles híbridas

Ionic es un SDK de front-end de código abierto basado en tecnologías web (HTML, CSS y JS) que es utilizado para desarrollar aplicaciones móviles híbridas. Ionic proporciona una librería de componentes híbridos optimizada para dispositivos móviles. Su compatibilidad y, gracias a la implementación de Cordova

Ejecutar aplicaciones Spring Boot como imágenes nativas de GraalVM

Ejecutar aplicaciones Spring Boot como imágenes nativas de GraalVM

En este post te mostramos paso a paso cómo ejecutar aplicaciones Spring Boot como imágenes nativas de GraalVM, para conseguir que nuestras aplicaciones arranquen más rápido y tengan un menor consumo de memoria. Uso de memoria en Java Como todos sabemos, Java es uno de