DEV Community: Jaime

Get the rain alerts in Telegram

Jaime — Sat, 27 May 2023 11:36:00 +0000

(English version bellow...)

La semana pasada estaba mirando el tiempo en la página de la Aemet y me di cuenta hay disponible un API REST publica para consultar información meteorológica.

Este API es Open Data y tiene varios recursos interesantes, como el siguiente:

Este endpoint devuelve la predicción de lluvia, tormentas y nieve en un municipio en concreto, el cual le pasamos por parámetro. Este recurso es muy útil ya que la Aemet lo actualiza varias veces al día.

Teniendo esto en cuenta he desarrollado un proyecto en Node, escrito en TypeScript, que consulta este recurso y en función de los datos, te envía un mensaje usando un bot Telegram diciéndote la probabilidad que hay de lluvia, tormentas o nieve en las próximas horas. La lógica es la siguiente:

El proyecto usa el paquete cron para establecer la frecuencia con la que se consulta el API de la Aemet, por ejemplo, cada hora.

Cada vez que obtenemos los datos de la Aemet, comprobamos si los datos han sido actualizados desde la última ejecución.

Si los datos han sido actualizados, obtenemos los datos diarios y elaboramos el mensaje que se enviara a través de un bot Telegram. Puedes crear tu bot de Telegram siguiendo este tutorial. Para enviar mensajes a través del bot se usa este paquete.

Instalación y ejecución

Este es el repositorio del proyecto y estos son los pasos para ejecutarlo en tu local:

Clonamos el proyecto:

 git clone https://github.com/jaime2196/alertaLluvia.git

Después hay que configurar una serie de variables en un fichero '.env' en la raiz del proyecto:

#Api Aemet
location=28013 #Madrid, por ejemplo
apiKey=???
#Umbral de avisos (%)
avisoTormenta=5
avisoPrecipitacion=5
avisoNieve=5
#Api telegram
token=???
usuarios=???
#Config cron
configCron=*/10 * * * * #Cada 10 minutos
#Node Time Zone
TZ=Europe/Madrid

location: código de la localidad sobre la que quieres recibir los avisos. Puedes encontrarlo aquí.
apiKey: necesitas una API key para usar los servicios de Aemet. Puede solicitarla aquí.
avisoTormenta: es el % mínimo de probabilidad con el que quieres recibir los avisos de tormenta. Por ejemplo, si estableces el 5, serás notificado si hay un 5% o más de probabilidad de tormenta.
avisoPrecipitacion: igual que el anterior, pero para la lluvia.
avisoNieve: igual que el anterior, pero para la nieve.
token: es el token de Telegram que has generado al crear tu bot.
usuarios: ID de usuarios de Telegram (separados por ",") a los que quieres enviar notificaciones. Para conocer tu ID de usuario puedes usar el bot '@userinfobot'
configCron: frecuencia con la que se consulta el API de Aemet para obtener los datos. Solo te llegara una notificación cada vez que Aemet actualiza sus datos, por lo que es probable que el API de Aemet se consulte varias veces, pero no te lleguen notificaciones, ya que los datos no han cambiado.

Puede obtener más información sobre programar tareas con cron aquí.

TZ: si lo ejecutamos desde Docker, es mejor especificar la zona horaria para que los valores de las fechas sean correctos.

Después instalamos las dependencias de Node y ejecutamos:

npm install 
npm run start

Ejecución con Docker

He construido una imagen para varias arquitecturas para que sea más fácil de ejecutar.
Las arquitecturas disponibles son:

amd64
arm/v7
arm64/v8

Para ejecutarlo con Docker simplemente creamos el archivo '.env' con las variables y ejecutamos:

 docker run -d --env-file ./.env jaime2196/node-alertalluvia

Ejemplo

Este es un aviso recibido en Telegram:

Contacto

English version

Last week I was looking at the weather on the page of Aemet (the Spanish meteorological agency) and I realized there is a public REST API available to consult meteorological information.

This API is Open Data and has several interesting resources, such as the following:

This endpoint returns the rain forecast, storms and snow in a specific town, which we pass as a parameter. This resource is very useful since Aemet updates it several times a day.

With this in mind I have developed a project in Node, written in TypeScript, which queries this resource and based on the data, sends you a message using a Telegram bot telling you the probability of rain, storms or snow in the next few hours. This project only works with cities in Spain, since the meteorological data is provided by the Spanish meteorological agency.
The logic is the following:

The project uses the cron package to set the frequency with which the Aemet API is queried, for example, every hour.

Every time we get the data from Aemet, we check if the data has been updated since the last run.

If the data has been updated, we obtain the daily data and prepare the message that will be sent through a Telegram bot. You can create your Telegram bot by following this tutorial. To send messages through the bot use this package.

Installation and execution

This is the repository of the project and these are the steps to run it:

Clone the project:

 git clone https://github.com/jaime2196/alertaLluvia.git

Then you have to configure a series of variables in an '.env' file in the root of the project:

#Api Aemet
location=28013 #Madrid, for example
apiKey=???
#Threshold of warnings (%)
avisoTormenta=5
avisoPrecipitacion=5
avisoNieve=5
#Api telegram
token=???
usuarios=???
#Config cron
configCron=*/10 * * * * #Cada 10 minutos
#Node Time Zone
TZ=Europe/Madrid

location: code of the town about which you want to receive notifications. You can find it here.
apiKey: you need an API key to use Aemet services. You can request it here.
avisoTormenta: it is the minimum % probability with which you want to receive storm warnings. For example, if you set 5, you will be notified if there is a 5% or greater chance of a storm.
avisoPrecipitation: the same as the previous one, but for the rain.
avisoNieve: same as above, but for snow.
token: it is the Telegram token that you have generated when creating your bot.
usuarios: Telegram user ID (separated by ",") to whom you want to send notifications. To know your user ID you can use the bot '@userinfobot'.
configCron: frequency with which the Aemet API is consulted to obtain the data. You will only receive a notification each time Aemet updates its data, so it is likely that the Aemet API is queried several times, but you do not receive notifications, since the data has not changed.

You can get more information about scheduling tasks with cron here.

TZ: if we run it from Docker, it is better to specify the time zone so that the date values are correct.

Then install the Node dependencies and execute:

npm install
npm run start

Running with Docker

I've built a multi-arch image to make it easier to run.
The available architectures are:

amd64 *arm/v7 *arm64/v8

To run it with Docker simply create the '.env' file with the variables and execute:

  docker run -d --env-file ./.env jaime2196/node-rainalert

Example

This is a notification received on Telegram:

What it means:
❗ From 14:00 to 20:00, there is a 35% chance of rain 🌧 and a 35% chance of thunderstorm ⛈
❗ From 20:00 to 02:00, there is a 5% chance of rain 🌧 and a 5% chance of thunderstorm ⛈

Stay in touch

Wordle guesser with NodeJS

Jaime — Wed, 16 Mar 2022 18:50:37 +0000

(English version bellow...)

Últimamente se ha puesto de moda jugar a Wordle y como no soy una excepción, yo también me puse jugar. Me di cuenta que al refrescar la página no se pierden las jugadas y además guarda las estadísticas de días anteriores. Entonces me entro curiosidad como estaba desarrollado:

Me puse a investigar y desde la consola de Google Chrome descubrí cosas interesantes en el 'local storage', vamos a ver:

Hay varias keys interesantes:

Statistics: contiene un objeto 'guesses', el cual es un array que indica el número de jugadas que hemos necesitado para adivinar la palabra en días anteriores.
Solution: parece la solución pasada por una función hash
Board: aquí guarda las palabras que hemos usado para intentar adivinar la palabra de hoy. Esto es lo más interesante, ya que puedo editarlo, poner las palabras que yo quiera y Wordle lo valida, incluso si la palabra no existe:

Aprovechando este error de validación, se me ocurrió usar la librería Puppeteer de NodeJS para automatizar el proceso y probar todas las letras del abecedario de una en una hasta encontrar la solución. Vamos a verlo:

async function tryCombinations(page){
    let lengthWord= getLengthWord();
    //let alphabet = 'abcdefghijklmnñopqrstuvwxyz'.split('');
    let alphabet = 'eaosrnidlctumpbgvyqhfzjñxkw'.split('');
    let word='';
    let correctWords=[];
    let isWordComplete=false;
    for(let i=0;i!=alphabet.length && !isWordComplete;i++){
        for(let j=0;j!=lengthWord;j++){
            word=word+alphabet[i];
        }
        await tryWord(page, word);
        correctWords=await getHits(page,correctWords);
        if(correctWords.length==lengthWord){
            isWordComplete=true;
        }
        word='';
    }
    return correctWords;
}

Esta función recorre cada una de las letras del alfabeto generando una 'palabra' de 5 letras (AAAAA, BBBBB, ...). Para optimizar la búsqueda, puse las letras del alfabeto ordenadas por su frecuencia de uso, según este artículo de Wikipedia y de además deja buscar una vez tenemos las 5 letras de la palabra. Una vez generada la 'palabra', la guardo en el local storage de la página mediante la función tryWord:

async function tryWord(page, word){
    await page.evaluate((word) => {
        window.localStorage.setItem('board', `[\"${word}\"]`);
    }, word);
    await page.reload({ waitUntil: ["networkidle0", "domcontentloaded"] });
}

Una vez ha sido validada por Wordle, ejecuto la función getHits para analizar el HTML y obtener los aciertos (si los hay)

async function getHits(page, correctWords){
    await page.waitForSelector('.grid-cols-5');
    let bodyHTML = await page.evaluate(() => document.body.innerHTML);
    bodyHTML=bodyHTML.substring(bodyHTML.indexOf('<main'), bodyHTML.indexOf('</main'));
    let firstRow= bodyHTML.split('<div class="grid grid-cols-5 gap-[5px] w-full">')[1];
    let words = firstRow.split('<div class="w-full h-full max-w-[62px] max-h-[62px] inline-flex justify-center items-center text-lg uppercase font-bold select-none text-white');
    let count=0;
    let numStr=getNumStr(getLengthWord());
    for(let i=0;i!=words.length;i++){

        if(words[i].indexOf('bg-correct')!=-1){ //Contains bg-correct
            correctWords.push(getCorrectWord(words[i],count));
            printCorrectWords(correctWords,numStr);
            count++;
        }else if(words[i].indexOf('bg-absent')!=-1 ||
            words[i].indexOf('bg-present')!=-1){
                count++;
        }

    }
    return correctWords;
}

A medida que va encontrando letras correctas en la palabra, las imprime por consola y cuando la palabra esta completa, imprime el resultado final y el tiempo que ha tardado en la búsqueda. En el peor de los casos (la palabra contenga la letra 'W'), tarda alrededor de un minuto en encontrar la palabra.

Por último, escribe la palabra encontrada como solución en Wordle y toma una captura de pantalla del resultado:

English version:

Lately everyone is playing Wordle (the spanish version) and since I'm not an exception, I started playing too. Then, I realized that by refreshing the page the plays are not lost and it also saves the statistics of previous days. Then I got curious how it was developed:

I began to investigate and from the Google Chrome console I discovered interesting things in the 'local storage', let's see:

There are several interesting keys:

Statistics: contains a 'guesses' object, which is an array that indicates the number of attempts we have needed to guess the word in previous days.
Solution: looks like the solution passed through a hash function
Board: here it saves the words that we have used to try to guess today's word. This is the most interesting, since I can edit it, put the words I want and Wordle validates it, even if the word does not exist:

Taking advantage of this validation error, I had the idea of using the Puppeteer library from NodeJS to automate the process and try all the letters of the alphabet one at a time until the solution is found. Let's see it:

async function tryCombinations(page){
    let lengthWord= getLengthWord();
    //let alphabet = 'abcdefghijklmnñopqrstuvwxyz'.split('');
    let alphabet = 'eaosrnidlctumpbgvyqhfzjñxkw'.split('');
    let word='';
    let correctWords=[];
    let isWordComplete=false;
    for(let i=0;i!=alphabet.length && !isWordComplete;i++){
        for(let j=0;j!=lengthWord;j++){
            word=word+alphabet[i];
        }
        await tryWord(page, word);
        correctWords=await getHits(page,correctWords);
        if(correctWords.length==lengthWord){
            isWordComplete=true;
        }
        word='';
    }
    return correctWords;
}

This function iterates through each of the letters of the alphabet generating a 5-letter 'word' (AAAAA, BBBBB, ...). To optimize the search, I put the letters of the Spanish alphabet ordered by their frequency of use, according to this article from Wikipedia and also lets search once we have the 5 letters of the word. Once the 'word' is generated, I store it in the page's local storage using the tryWord function:

async function tryWord(page, word){
    await page.evaluate((word) => {
        window.localStorage.setItem('board', `[\"${word}\"]`);
    }, word);
    await page.reload({ waitUntil: ["networkidle0", "domcontentloaded"] });
}

Once it has been validated by Wordle, I run the getHits function to parse the HTML and get the hits (if any)

async function getHits(page, correctWords){
    await page.waitForSelector('.grid-cols-5');
    let bodyHTML = await page.evaluate(() => document.body.innerHTML);
    bodyHTML=bodyHTML.substring(bodyHTML.indexOf('<main'), bodyHTML.indexOf('</main'));
    let firstRow= bodyHTML.split('<div class="grid grid-cols-5 gap-[5px] w-full">')[1];
    let words = firstRow.split('<div class="w-full h-full max-w-[62px] max-h-[62px] inline-flex justify-center items-center text-lg uppercase font-bold select-none text-white');
    let count=0;
    let numStr=getNumStr(getLengthWord());
    for(let i=0;i!=words.length;i++){

        if(words[i].indexOf('bg-correct')!=-1){ //Contains bg-correct
            correctWords.push(getCorrectWord(words[i],count));
            printCorrectWords(correctWords,numStr);
            count++;
        }else if(words[i].indexOf('bg-absent')!=-1 ||
            words[i].indexOf('bg-present')!=-1){
                count++;
        }

    }
    return correctWords;
}

As it finds correct letters in the word, it prints them on the console and when the word is complete, it prints the final result and the time it took to search. In the worst case (the word contains the letter 'W'), it takes about a minute to find the word.

Finally, write the found word as a solution in Wordle and take a screenshot of the result: