Crea un bot para Messenger (2 parte)

¿Qué necesitamos para empezar a desarrollar nuestro bot?

Para desarrollar nuestro bot, tenemos primero que configurar un par de cosas en Facebook.

En resumen, vamos a necesitar:

• Una página en Facebook — cada bot necesita una página diferente.
• Una cuenta de desarrollador, que nos permitirá registrar nuestra app en Facebook.
• Una app en Facebook para obtener acceso a un secret access token (lo necesitaremos posteriormente).

Los bots para Facebook funcionan a través de webhooks, que son URLs que nosotros definimos y que Facebook Messenger usará para interactuar con nuestro bot.

Para publicar nuestro webhook usaremos Google App Engine. La ventaja de esto es que resulta gratuito para bajos volúmenes de tráfico, y escala automáticamente si necesitamos más. Así mismo usaremos Python como lenguaje de programación, pero en realidad se puede lograr también con cualquier otro lenguaje.

Vamos a necesitar descargar el Python SDK y crear un proyecto de Google Cloud si aún no tenemos uno.

Creando nuestro Webhook

La primera misión de nuestro webhook es permitirle a Facebook verificar que realmente se trata de un webhook auténtico. Para ello simplemente tenemos que gestionar una petición GET, que contiene un token de verificación (es una cadena secreta y aleatoria, que debemos definir en Facebook).

La verificación es posible usando el siguiente código:

class MainPage(webapp2.RequestHandler):
    def get(self):
        self.response.headers['Content-Type'] = 'text/plain'
        mode = self.request.get("hub.mode")
        if mode == "subscribe":
            challenge = self.request.get("hub.challenge")
            verify_token = self.request.get("hub.verify_token")
            if verify_token == VERIFY_TOKEN:
                self.response.write(challenge)
        else:
            self.response.write("Ok")

Es así como definimos una clase para gestionar peticiones (usando el framework webapp2).

Aunque no se muestra en el fragmento anterior, esta clase presenta también un constructor que se encarga de inicializar nuestra clase bot.

Gestionando mensajes de usuarios

Necesitamos interpretar los mensajes que escriben los usuarios. Para ello primero necesitamos capturar estos mensajes.

Estos son enviados por Facebook a nuestro webhook, a través de peticiones POST.

def post(self):
    logging.info("Data obtenida desde Messenger: %s", self.request.body)
    data = json.loads(self.request.body)

    if data["object"] == "page":
        for entry in data["entry"]:

            for messaging_event in entry["messaging"]:
                sender_id = messaging_event["sender"]["id"]
                recipient_id = messaging_event["recipient"]["id"]

                if messaging_event.get("message"):
                    # Eventos de tipo message

                if messaging_event.get("postback"):
                    # Eventos de tipo postback

Aquí «parseamos» la información que recibimos en formato JSON desde Facebook, para que posteriormense se pueda analizar y procesar.

Básicamente Facebook Messenger nos permite suscribirnos a eventos de 2 tipos: eventos message (cuando el usuario escribe) y eventos postback (que son enviados cuando un usuario hace clic en un botón de respuesta).

Entonces iteramos sobre los messaging events en general, y dependiendo el tipo decidimos cómo actuar.

Luego de recibir la información que nos envía Facebook e identificar los mensajes, invocamos al método handle para que nuestra clase Bot se encargue de su procesamiento.

El fragmento anterior sólo muestra la estructura general.

Enviando mensajes a los usuarios

Cuando instanciamos nuestra clase Bot, enviamos la función send_message al constructor.

Esta función permite a nuestro bot devolver mensajes de respuesta a los usuarios. Y su definición es la siguiente:

def send_message(recipient_id, message_text, possible_answers):
    headers = {
        "Content-Type": "application/json"
    }

    message = get_postback_buttons_message(message_text, possible_answers)
    if message is None:
        message = {"text": message_text}

    raw_data = {
        "recipient": {
            "id": recipient_id
        },
        "message": message
    }
    data = json.dumps(raw_data)

    logging.info("Enviando mensaje a %r: %s", recipient_id, message_text)

    r = urlfetch.fetch("https://graph.facebook.com/v2.6/me/messages?access_token=%s" % ACCESS_TOKEN,
                       method=urlfetch.POST, headers=headers, payload=data)
    if r.status_code != 200:
        logging.error("Error %r enviando mensaje: %s", r.status_code, r.content)

La variable recipient_id que esta función recibe se corresponde con el identificador del usuario al que vamos a responder. Junto a esta variable tenemos como parámetros: el texto a enviar, y algunos botones de respuesta rápida (que el usuario podrá presionar).

Primero nos aseguramos que las cabeceras de nuestra petición especifiquen el formato a usar (JSON), y entonces agregamos nuestros botones postback como parte del mensaje.

Estos botones no estarán presentes siempres, sólo en algunos casos, dependiendo de lo que se defina en nuestro árbol. De todas formas, para los casos en que están presentes, la función get_postback_buttons_message es la encargada de dar a estos botones el formato adecuado (según lo exige Facebook).

Finalmente hacemos nuestra petición al Facebook Graph API, enviando el access token que Facebook nos dio cuando registramos nuestra app.

Ejecutando nuestro bot

El código final de nuestro archivo principal, contiene lo siguiente, que es necesario para construir la clase principal y ejecutar el webhook que va a representar a nuestro bot:

app = webapp2.WSGIApplication([
    ('/', MainPage),
], debug=True)

Te esperamos en la tercera y ultima parte del  artículo en donde hablaremos mas acerca de estos temas que hoy en día son de importancia e interés en el mundo de la tecnología.