63,546 lecturas

Envío de mensajes secretos con Courier API y Node.js

por Courier16m2022/09/06

Demasiado Largo; Para Leer

En este tutorial, crearemos una aplicación Node.js que envía notificaciones multicanal en código morse. Los primeros cinco agentes secretos que completen con éxito este tutorial y esta tarea recibirán un regalo de Courier.

Companies Mentioned

featured image - Envío de mensajes secretos con Courier API y Node.js

Siga junto con el video tutorial:

¡Lanzaremos nuestro primer hackathon la próxima semana y obsequiaremos más de $ 1K en premios! Únase a nosotros para construir un proyecto genial y ganar cualquiera de los siguientes premios 🏆

Courier Hacks 1er lugar: la mejor presentación para uso de notificaciones y demostración de notificaciones adecuadas de aplicación a usuario con la API de Courier recibirá $ 1000 a través de Zelle o PayPal.
Courier Hacks 2do lugar: la presentación del 2do lugar para su uso en notificaciones y demostración de notificaciones adecuadas de aplicación a usuario con la API de Courier recibirá el Apple AirPods Pro.
Favorito del público: el ganador del favorito del público recibirá un teclado Keychron.
Finalistas: las presentaciones de los finalistas recibirán un Hydro Flask.

¡Además, todos los que envíen un proyecto que integre con éxito la API de Courier recibirán una tarjeta de regalo de Amazon de $20!

¿No estás seguro por dónde empezar? En este tutorial, crearemos una aplicación Node.js que envía notificaciones multicanal en código morse.

¿Que esta pasando?

Hoy somos agentes secretos y nuestro objetivo es enviar mensajes codificados a nuestra red de espionaje. Algunos espías prefieren leer correos electrónicos y otros prefieren leer textos, por lo que debemos asegurarnos de que nuestra aplicación pueda adaptarse a todas las preferencias de los espías.

Nota: Los primeros cinco agentes secretos que completen con éxito este tutorial y esta tarea recibirán un regalo de Courier.

En el Capítulo 1, primero integraremos las API de Gmail y Twilio, que Courier usará para enviar correos electrónicos y mensajes de texto. En el Capítulo 2, demostraremos cómo enviar mensajes individuales y configurar el enrutamiento para enviar notificaciones multicanal. En el Capítulo 3, integraremos una API de traducción para convertir nuestros mensajes en código Morse.

Vamos a organizar nuestro primer hackatón el próximo mes, del 5 al 30 de septiembre. Regístrese ahora para enviar este proyecto y tener la oportunidad de ganar algunos premios geniales.

Regístrese para el Hackathon: https://courier-hacks.devpost.com/

Instrucciones

Capítulo 1: Autorizar a Courier para enviar mensajes usando las API de Gmail y Twilio

En este primer Capítulo, necesitaremos autorizar nuestra API para enviar los mensajes secretos. Comencemos integrando las API de Gmail y Twilio, lo que permite a Courier enviar correos electrónicos y mensajes desde una sola llamada a la API.

Inicie sesión en su cuenta de CourierInicie sesión en su cuenta de Courier
Inicie sesión en su cuenta de Courier y cree un nuevo espacio de trabajo secreto.
Para la incorporación, seleccione el canal de correo electrónico y deje que Courier cree con Node.js. Comience con la API de Gmail, ya que solo toma unos segundos configurarla. Todo lo que tenemos que hacer para autorizar es iniciar sesión a través de Gmail. Ahora la API está lista para enviar mensajes.
Copie el código de inicio, una llamada API básica usando cURL, y péguelo en una nueva terminal. Ya ha guardado su clave API y sabe a qué dirección de correo electrónico desea enviar, y ya tiene un mensaje integrado.

Una vez que pueda ver la paloma que baila, estará listo para usar Courier para enviar más notificaciones. Antes de desarrollar nuestra aplicación, debemos configurar el proveedor de Twilio para habilitar los mensajes de texto.

Diríjase a "Canales" en el menú de la izquierda y busque Twilio. Necesitará un SID de cuenta, un token de autenticación y un SID de servicio de mensajería para autorizar a Twilio.
Abra twilio.com , inicie sesión y abra la Consola, y busque los dos primeros tokens en esa página. Guarde el SID de la cuenta y el token de autenticación en Courier.

Por último, debe ubicar el SID del servicio de mensajería, que crea en la pestaña Mensajería en el menú de la izquierda. Consulte los documentos de Twilio sobre cómo crear un SID de servicio de mensajería , vinculado en la descripción.

Una vez que tengamos las tres piezas de información, instale el proveedor. Ahora su cuenta de Courier está autorizada para enviar cualquier correo electrónico o SMS dentro de una llamada API.

Capítulo 2: Enviar notificaciones monocanal y multicanal

En este próximo Capítulo, comenzará a enviar mensajes. Para enviar los mensajes secretos, diríjase a la documentación de la API de envío . Aquí puedes encontrar todo lo relacionado con el envío de mensajes.

A la derecha, verá un código de inicio y podrá seleccionar un idioma de su elección entre cURL, Node.js, Ruby, Python, Go o PHP.

Selección Node.js para empezar

 // Dependencies to install: // $ npm install node-fetch --save const fetch = require('node-fetch'); const options = { method: 'POST', headers: { Accept: 'application/json', 'Content-Type': 'application/json' }, body: JSON.stringify({ "message": { "template": "NOTIFICATION_TEMPLATE" } }) }; fetch('https://api.courier.com/send', options) .then(response => response.json()) .then(response => console.log(response)) .catch(err => console.error(err));

Esta solicitud POST básica se puede editar para incluir los datos de los espías, como cómo contactarlos y el mensaje que debe enviar. La "Plantilla de notificación" se puede reemplazar con su propia plantilla.

Agregue una dirección de correo electrónico en el campo de correo electrónico a la izquierda, que verá que aparece automáticamente en el fragmento de código a la derecha.

 // Dependencies to install: // $ npm install node-fetch --save const fetch = require('node-fetch'); const options = { method: 'POST', headers: { Accept: 'application/json', 'Content-Type': 'application/json' }, body: JSON.stringify({ "message": { "template": "NOTIFICATION_TEMPLATE", "to": { "email": "[email protected]" } } }) }; fetch('https://api.courier.com/send', options) .then(response => response.json()) .then(response => console.log(response)) .catch(err => console.error(err));

A continuación, debe agregar el mensaje real que está enviando. Estos mensajes son bastante simples, por lo que puede escribirlos directamente en la llamada a la API en lugar de crear una plantilla.

Escriba un asunto en el objeto del título (esto se puede cambiar en cualquier momento).
En el cuerpo del correo electrónico, escriba su mensaje.

 // Dependencies to install: // $ npm install node-fetch --save const fetch = require('node-fetch'); const options = { method: 'POST', headers: { Accept: 'application/json', 'Content-Type': 'application/json' }, body: JSON.stringify({ "message": { "to": { "email": "[email protected]" }, "content": { "title": "new subject", "body": "message" } } }) }; fetch('https://api.courier.com/send', options) .then(response => response.json()) .then(response => console.log(response)) .catch(err => console.error(err));

Como antes, los datos de la izquierda aparecen automáticamente en el fragmento de código de la derecha. Hay un objeto de contenido que abarca el título y los parámetros del cuerpo.

Ahora solo necesita asegurarse de que esta llamada a la API tenga acceso a su cuenta de Courier, que se vincula a las API de Gmail y Twilio.

Reemplace el token de autenticación con la clave API de Courier (almacenada en la configuración de la cuenta de Courier en Claves API)[ https://www.courier.com/docs/guides/getting-started/nodejs/#getting-your-api-keys ].

 // Dependencies to install: // $ npm install node-fetch --save const fetch = require('node-fetch'); const options = { method: 'POST', headers: { Accept: 'application/json', 'Content-Type': 'application/json', Authorization: 'Bearer apikey' }, body: JSON.stringify({ "message": { "to": { "email": "[email protected]" }, "content": { "title": "new subject", "body": "message" } } }) }; fetch('https://api.courier.com/send', options) .then(response => response.json()) .then(response => console.log(response)) .catch(err => console.error(err));

Envíe este código desde aquí para probar que la llamada a la API funciona (haga clic en "Pruébelo" arriba del fragmento de código).
Ir a tu Registros de mensajería y haga clic en el registro más reciente para obtener más información. Debería poder ver cómo se representa para el usuario que recibe el mensaje. Si hubo un error, también debería poder acceder a un código de error allí.

Ahora puede integrar este código en nuestra propia aplicación Node.js.

Abra VS Code y abra un nuevo proyecto con un archivo llamado index.js .
Pegue el código en el archivo index.js .
Instale el paquete node-fetch npm, que le permite realizar llamadas a la API.
Abra una terminal y pegue el comando para instalar el paquete.

 $ npm install node-fetch --save

Ejecuta el programa en la terminal.

 $ node index.js

Aquí, puede encontrarse con un error de búsqueda de nodos, causado por la instrucción require en la línea 4. Para solucionar esto, instale una versión diferente del paquete que se encuentra en la documentación de búsqueda de nodos: https://www.npmjs.com/package/node-fetch#class-response .

 npm install node-fetch@2

Ahora, cuando ejecute este programa, debería recibir una respuesta de Courier que incluya el requestID de solicitud en la consola de VS Code. Esto indica que la llamada a la API se realizó correctamente y puede dirigirse al registro de datos de Courier para determinar si el mensaje también se envió correctamente.

Como eres un agente secreto, probablemente deberías proteger la clave API en caso de que nuestro código caiga en las manos equivocadas.

Cree un nuevo archivo llamado .env .
Almacene la clave API como una variable en el archivo .env.

 APIKEY="fksdjfgjsdkfgndfsmn"

Instale el paquete dotenv npm, lo que le permitirá acceder a la variable en el archivo index.js .
Una vez que el paquete esté instalado, acceda a la clave refiriéndose a ella como process.env.APIKEY .
Agregue require('dotenv').config() en la parte superior del archivo index.js .
Ejecute este programa para confirmar que todavía funciona igual.

En este punto, puede enviar un solo mensaje a los espías por correo electrónico. Sin embargo, sabe que algunos espías prefieren usar mensajes de texto, por lo que deberá habilitar las notificaciones multicanal. Volvamos a los documentos de Courier y desplacémonos hacia abajo hasta el objeto de routing , que contiene el method y los channels . Hay dos tipos de métodos disponibles: all y single . 'Todos' significa que Courier intentará enviar el mensaje a todos los canales enumerados. "Único" significa que Courier intentará enviarlo al primer canal que funcione. Vamos a integrar esto en nuestro programa.

Agregue el objeto de routing en cualquier lugar dentro del objeto de message , al mismo nivel que to y content .
Defina los canales dentro del mismo objeto de routing : puede elegir SMS o correo electrónico, en este caso, dado que ya tiene una dirección de correo electrónico definida.

 "message": { "to": { "email": process.env.EMAIL }, "content": { "title": "new subject", "body": "message" }, "routing": { "method": "single", "channels": "email" }, }

Convierta la propiedad de los channels en una matriz para definir varios canales y enumere tanto el correo electrónico como los SMS.

 "channels": ["email", "sms"]

Ahora tiene dos canales diferentes a los que se puede enviar este mensaje. All métodos enviarían este mensaje tanto por correo electrónico como por SMS. El método Single intentaría enviar esto al primero que funcione. Dado que tiene la dirección de correo electrónico del usuario pero no su número de teléfono, este programa solo puede enviarlo por correo electrónico.

Si los dos canales se invirtieran, Courier intentaría enviar un SMS, no lo haría y luego enviaría un correo electrónico de forma predeterminada.

 "channels": ["sms", "email"]

Agregue el número de teléfono del usuario para que el canal de SMS funcione. Ahora este programa debería poder enviar mensajes de texto a través de Twilio.

 "message": { "to": { "email": process.env.EMAIL, "phone_number": process.env.PHONENUMBER }, "content": { "title": "new subject", "body": "message" }, "routing": { "method": "single", "channels": ["sms", "email"] }, }

Cambie el método único a all y vuelva a ejecutar el programa.

 "message": { "to": { "email": process.env.EMAIL, "phone_number": process.env.PHONENUMBER }, "content": { "title": "new subject", "body": "message" }, "routing": { "method": "all", "channels": ["sms", "email"] }, }

Courier ahora puede enviar a través de Twilio y Gmail dentro de la misma llamada a la API.

Capítulo 3: Integrar una API de traducción para convertir mensajes a código Morse

NOTA: La API de Morse tiene un límite de velocidad, lo que puede generar un error si la ejecuta demasiadas veces en una hora. En este caso, deberá esperar un tiempo antes de continuar.

En este último capítulo, integrará la API Morse de Fun Translations para codificar los mensajes secretos y enviarlos a los espías. Puede buscar documentación sobre la API de Morse en el sitio web de Fun Translations. Aquí tiene acceso a toda la información que necesita para realizar la llamada: tiene un punto final y un ejemplo que demuestra que el mensaje original es un parámetro para el punto final.

🔗 Traducciones divertidas: https://funtranslations.com/api/#morse

🔗 API de traducciones divertidas: https://api.funtranslations.com/

Comience encerrando la llamada a la API de Courier en una función.
Agregue una llamada a esa función debajo de la definición de la función asíncrona.
Refactorice options a courier_options .

 // Dependencies to install: // $ npm install node-fetch --save const fetch = require('node-fetch'); require('dotenv').config() async function send_secret_message() { const courier_options = { method: 'POST', headers: { Accept: 'application/json', 'Content-Type': 'application/json', Authorization: 'Bearer ' + process.env.APIKEY }, body: JSON.stringify({ "message": { "to": { "email": process.env.EMAIL, "phone_number": process.env.PHONENUMBER }, "content": { "title": "new subject", "body": "message" }, "routing": { "method": "all", "channels": ["sms", "email"] }, } }) }; fetch('https://api.courier.com/send', courier_options) .then(response => response.json()) .then(response => console.log(response)) .catch(err => console.error(err)); } send_secret_message()

Antes de enviar el mensaje, primero debe realizar una llamada a la API de Morse para traducir el mensaje. Puede usar node-fetch de la misma manera que lo hizo con Courier para realizar esta llamada.

Copie el código dentro de la función asíncrona para realizar la nueva llamada a la API.
Pegue el código sobre la llamada a la API de Courier.
Actualice el punto final al punto final de la API de Morse.
Refactorice options a morse_options para la primera llamada.
Elimine el token de autorización en la llamada a la API de Morse, ya que no requiere una clave de API.
Retire el objeto del body .
Agregue el mensaje - "Hola agente secreto x este es su mensaje" - como un parámetro dentro del punto final y reemplace todos los espacios en el mensaje con su url-encode (% 20).

 // Dependencies to install: // $ npm install node-fetch --save const fetch = require('node-fetch'); require('dotenv').config() async function send_secret_message() { const morse_options = { method: 'GET', headers: { Accept: 'application/json', 'Content-Type': 'application/json' } }; const original_message = "hey%20secret%20agent%20x%20this%20is%20your%20message" const morse_endpoint = "https://api.funtranslations.com/translate/morse.json?text="+original_message fetch(morse_endpoint, morse_options) .then(response => response.json()) .then(response => console.log(response)) .catch(err => console.error(err)); const courier_options = { method: 'POST', headers: { Accept: 'application/json', 'Content-Type': 'application/json', Authorization: 'Bearer ' + process.env.APIKEY }, body: JSON.stringify({ "message": { "to": { "email": process.env.EMAIL, "phone_number": process.env.PHONENUMBER }, "content": { "title": "new subject", "body": "message" }, "routing": { "method": "all", "channels": ["sms", "email"] }, } }) }; fetch('https://api.courier.com/send', courier_options) .then(response => response.json()) .then(response => console.log(response)) .catch(err => console.error(err)); } send_secret_message()

Comente la llamada a la API de Courier, ya que solo necesita probar el código que acaba de agregar.

Cuando ejecuta este programa, podemos recibir un error que indica que hay un error al analizar el JSON. Este problema se debe a un error en la documentación, que aquí establece que debe ser una solicitud POST . Sin embargo, en una documentación API separada, se escribe como una solicitud GET . Actualice el tipo de llamada a GET, y debería ver el mensaje traducido dentro de la respuesta.

Obviamente, claramente, no quieres enviar toda esta información a los espías, y. Solo necesitas el mensaje secreto.

Aísle el mensaje registrando response.contents.translated .

 fetch(morse_endpoint, morse_options) .then(response => response.json()) .then(response => console.log(response.contents.translated)) .catch(err => console.error(err));

Debe poder acceder a la traducción desde esta llamada a la API en el cuerpo de la llamada a la API de Courier.

Cree una variable llamada morse_response , que contendrá la respuesta completa de esta llamada.
Convierta el objeto JSON en un objeto JavaScript para que pueda leerlo dentro de su código.
Obtenga el mensaje traducido de ese objeto y guárdelo en una nueva variable llamada message .
Registre esta variable para confirmar que funciona.

 const morse_response = await fetch(morse_endpoint, morse_options) // .then(response => response.json()) // .then(response => console.log(response.contents.translated)) // .catch(err => console.error(err)); const translation = await morse_response.json(); const message = translation.contents.translated console.log(message)

Reemplace el mensaje dentro del cuerpo de la llamada API de Courier con el mensaje codificado que acaba de guardar en la variable de message .

 "message": { "to": { "email": process.env.EMAIL, "phone_number": process.env.PHONENUMBER }, "content": { "title": "new secret message", "body": message }, "routing": { "method": "all", "channels": ["sms", "email"] }, }

El registro de datos de Courier debe mostrar que los mensajes fueron codificados y enviados correctamente por SMS y correo electrónico. Así es como se ve el correo electrónico:

Conclusión

Nuestros espías ahora están listos para recibir sus mensajes codificados secretos. Intente cambiar el cuerpo del contenido a su propio mensaje secreto y envíelo a [email protected] , ¡y le enviaremos un regalo a los primeros cinco agentes secretos que completen esta tarea! No olvide enviar su proyecto a nuestro Hackatón ¡para tener la oportunidad de ganar más de $1000 en efectivo y premios!XYZ.