Como criar e implantar um bot do Telegram?

Neste artigo, você criará um bot do Telegram com o Node.js e o backend-as-a-service do Back4app. Em seguida, você o implantará usando contêineres do Back4app.

Bots são softwares que podem executar tarefas repetitivas automatizadas em uma rede ou em uma plataforma. Os bots do Telegram são criados usando a API de bots do Telegram e são projetados especificamente para funcionar no Telegram.

Você pode criar bots do Telegram para executar várias tarefas no Telegram, como recuperar informações como atualizações meteorológicas ou manchetes de notícias e hospedar questionários para entretenimento.

Eles também podem automatizar tarefas como agendamento de lembretes e realizar autenticação simples de usuários, entre outras coisas.

Configuração de seu ambiente de desenvolvimento

Este artigo apresenta um bot do Telegram que permite que os usuários configurem atualizações automáticas do clima para sua cidade favorita a cada 6 horas ou obtenham informações instantâneas do clima para qualquer cidade que escolherem.

Para configurar o diretório do projeto, execute os comandos abaixo:

# crie seu diretório de projeto
mkdir telegram-weather-bot

# cd no diretório do seu projeto
cd telegram-weather-bot

# Inicializar npm
npm init -y

Os comandos acima criam um diretório telegram-weather-bot, movem-se para ele e inicializam o npm nele.

Em seu arquivo package.json, adicione o seguinte script de inicialização para executar seu bot:

"start": "node server.js"

Em seguida, execute o comando abaixo para instalar os pacotes necessários para esse projeto:

npm install axios node-telegram-bot-api dotenv node-schedule parse

O comando acima instalou os seguintes pacotes:

• axios: Você usará essa biblioteca para fazer solicitações HTTP a uma API meteorológica.

• node-telegram-bot-api: Essa biblioteca simplifica a interação com a API do Telegram Bot.

• dotenv: esse pacote o ajudará a carregar variáveis de ambiente de um arquivo .env.

• node-schedule: Você precisará desse pacote para agendar tarefas e automatizar suas atualizações meteorológicas.

• parse: Você precisará desse pacote para interagir com o Backend do Back4app Parse.

Agora, você já configurou seu ambiente de desenvolvimento. Em seguida, você precisa criar uma conta de bot no Telegram.

Criando sua conta de bot do Telegram

Uma conta de bot do Telegram servirá como a identidade do seu bot na plataforma do Telegram. Os usuários poderão interagir com o bot por meio dessa conta.

Para criar seu bot do Telegram, inicie o aplicativo Telegram, digite “BotFather” na barra de pesquisa e clique no resultado superior verificado.

O BotFather é um bot do Telegram que permite que você desenvolva outros bots rapidamente. Digite o comando /newbot para iniciar o processo de criação do seu bot. Você fornecerá um nome e um nome de usuário exclusivo para seu bot.

Depois de fornecer o nome e o nome de usuário do seu bot, o BotFather fornecerá um token exclusivo que permitirá que você interaja e gerencie a conta do bot.

Armazene seu token de bot em seu projeto criando um arquivo .env no diretório raiz e colando o token de bot no arquivo. Assim:

TELEGRAM_BOT_TOKEN = <YOUR_BOT_TOKEN>

Agora que você tem seu token de bot e o armazenou em seu projeto, pode criar seu bot do Telegram.

Criando o bot do Telegram

Esta seção o guiará na criação do seu bot meteorológico do Telegram e na integração das bibliotecas que você instalou para executar funções como lidar com os comandos, gerenciar o estado do usuário e recuperar dados da API meteorológica.

Estruture o diretório do seu bot de forma semelhante à que está abaixo para iniciar o processo de compilação:

telegram-weather-bot/
├── node_modules/          
├── src/                        
|   ├── bot.js                    # arquivo para manipular a interação do bot  
|   ├── weather.js                # Módulo para busca de dados meteorológicos
|   ├── stateManager.js           # Módulo para gerenciar o estado do usuário com Back4App
|   └── cityManager.js            # Gerencia as configurações da cidade do usuário e envia informações meteorológicas
updates
├── .env                        
├── package.json                  
├── server.js                     # Ponto de entrada para sua aplicação
└── package-lock.json            

Obtendo informações meteorológicas

Para obter informações meteorológicas, você usará a API do OpenWeatherMap.

Para fazer solicitações a essa API, é necessário ter uma chave de API. Para obter essa chave de API, faça login em sua conta (ou crie uma, se ainda não tiver uma).

Em seguida, navegue até a seção “My API Keys” (Minhas chaves de API) em seu perfil e copie sua chave de API.

Armazene a chave de API do OpenWeatherMap em seu arquivo .env:

OPENWEATHERMAP_TOKEN = <YOUR_OPEN_WEATHER_MAP_APIKEY>

Como a funcionalidade do bot gira em torno da obtenção de informações meteorológicas, defina uma função que fará uma solicitação GET à API do OpenWeatherMap para recuperar informações meteorológicas com o método axios.get.

Adicione o bloco de código abaixo ao seu arquivo weather.js para fazer uma solicitação GET de informações meteorológicas da API do OpenWeatherMap:

const axios = require('axios');
const apiKey = process.env.OPENWEATHERMAP_TOKEN;

async function getWeather(city) {
  try {
    const url = `https://api.openweathermap.org/data/2.5/weather?q=${city}&appid=${apiKey}&units=metric`;
    const response = await axios.get(url);
    const temp = response.data.main.temp;  
    const description = response.data.weather[0].description;  
    return `The weather in ${city} is ${temp}°C with ${description}.`;
  } catch (error) {
    console.error('Error fetching weather:', error);
    throw error;
  }
}

module.exports = { getWeather } 

O bloco de código acima define uma função getWeather que recebe o nome de uma cidade como argumento e retorna a temperatura e a descrição do clima da resposta da API.

Para fornecer aos usuários atualizações meteorológicas regulares a cada 6 horas, será necessário implementar uma função de agendamento que executará a função getWeather para retornar atualizações meteorológicas para uma cidade preferida.

Agendamento de atualizações meteorológicas

Para agendar a tarefa de retornar as atualizações meteorológicas de uma cidade preferida, adicione o bloco de código abaixo em seu cityManager.js:

const schedule = require('node-schedule');
const weather = require('./weather');

let userCities = {};

function setCity(chatId, city) {
  userCities[chatId] = city;
}

function init(bot) {
  schedule.scheduleJob('0 */6 * * *', function() {
    for (let chatId in userCities) {
      const city = userCities[chatId];
      weather.getWeather(city).then(response => {
        bot.sendMessage(chatId, response);
      }).catch(error => {
        bot.sendMessage(chatId, "Failed to retrieve weather.");
      });
    }
  });
}

module.exports = { setCity, init };

O bloco de código acima cria duas funções: setCity e init.

O bloco de código declara um objeto userCities para rastrear as cidades nas quais os usuários do bot estão interessados, mapeando seus IDs de bate-papo do Telegram para nomes de cidades usando a função setCity.

Essa função permite que seu bot mantenha a preferência do usuário sobre a cidade para a qual ele deseja receber atualizações meteorológicas.

A função init no bloco de código configura uma tarefa agendada a cada 6 horas que itera sobre todos os IDs de bate-papo armazenados em userCities. A função init usa o módulo de clima para buscar o clima atual para essa cidade.

Seu bot precisa manter o estado do usuário para acompanhar seus diferentes usuários e suas cidades preferidas. Você pode conseguir isso usando o backend do Back4app como um serviço.

Para que seu bot acompanhe diferentes usuários e suas cidades preferidas, armazene a cidade preferida de um usuário do bot usando o backend do Back4app como um serviço.

Criação de um backend do Back4app

Para usar o backend do Back4app como um serviço, você precisa de uma conta do Back4app. Se ainda não tiver uma, você pode se inscrever gratuitamente.

Faça login na sua conta e clique no botão “NEW APP” (novo aplicativo) no canto superior direito. Dê um nome ao seu aplicativo e clique no botão “CREATE” (Criar).

Depois de clicar no botão “CREATE”, o Back4app gerará seu aplicativo e o direcionará para o painel do aplicativo.

Para se conectar à instância do seu aplicativo no Back4App a partir do seu projeto Node.js, é necessário inicializar o SDK de análise que você instalou com as credenciais do aplicativo Back4app: ID do aplicativo e Javascript KEY.

Obtenha o ID do aplicativo e a chave JavaScript do Back4app navegando até a seção “Security & Keys”, clicando em “App Settings” (Configurações do aplicativo) na barra lateral.

Armazene-os em seu arquivo .env. Seu arquivo .env atual deve ser semelhante ao arquivo abaixo:

TELEGRAM_BOT_TOKEN= "<YOUR_TELEGRAM_BOT_TOKEN_HERE>"
OPENWEATHERMAP_TOKEN= "<YOUR_OPENWEATHERMAP_TOKEN_HERE>"
BACK4APP_APP_ID= "<YOUR_BACK4APP_APP_ID_HERE>"
BACK4APP_JAVASCRIPT_KEY= "<YOUR_BACK4APP_JAVASCRIPT_KEY_HERE>"

Em seguida, você precisa criar uma nova classe “UserState” com dois campos: userId (string) e state (objeto). Você usará o agente de IA do Back4app para realizar essa tarefa.

Para criar essa classe com os respectivos campos, navegue até a guia “AI Agent” em sua tela e forneça ao agente o prompt abaixo:

Create a new class, "UserState," in my Back4app application with the APP ID “<YOUR_BACK4APP_APP_ID_HERE>”. The "UserState" class will have two fields: userId (string) and state (object).

Você deve receber uma resposta semelhante à imagem abaixo:

Se você verificar o painel do Back4app, verá que a classe UserState foi criada com êxito.

Gerenciando o estado do usuário em seu bot do Telegram

Para gerenciar o fluxo de interação entre o usuário do bot e o bot, é necessário definir um estado de usuário que indique qual comando o bot espera do usuário.

Além do comando /start, o bot entende dois comandos principais. Cada interação do usuário (inclusive comandos) aciona uma atualização do estado do usuário, armazenado junto com a ID do chat na classe UserState.

Esse gerenciamento de estado permite que o bot se lembre de detalhes específicos de cada usuário em uma conversa, como sua cidade preferida para atualizações meteorológicas.

Para começar a rastrear os estados do usuário com a classe UserState que você criou no banco de dados do Back4App, é necessário inicializar o Parse SDK com suas credenciais.

Adicione o bloco de código abaixo ao stateManager.js para inicializar o SDK do Parse com as credenciais necessárias para se conectar ao Back4app Parse Backend:

// stateManager.js
const Parse = require('parse/node');

Parse.initialize(
  process.env.BACK4APP_APP_ID,
  process.env.BACK4APP_JAVASCRIPT_KEY
);

Parse.serverURL = '<https://parseapi.back4app.com/>';

Em seguida, defina um objeto Parse em seu arquivo stateManager.js para representar o esquema da classe UserState no backend do Back4app Parse, permitindo que seu bot interaja com o estado do usuário armazenado no banco de dados.

Assim:

// stateManager.js
const UserState = Parse.Object.extend('UserState');

Em seguida, você precisará habilitar seu bot para recuperar o estado atual da conversa de um determinado usuário com base no ID de usuário armazenado no banco de dados.

Para recuperar o estado de um usuário, será necessário executar uma consulta na classe UserState com o ID do usuário para encontrar o estado salvo no banco de dados.

Assim:

// stateManager.js
async function getUserState(userId) {
  const query = new Parse.Query(UserState);
  query.equalTo('userId', userId.toString());
  const userState = await query.first();
  return userState ? userState.get('state') : null;
}

O bloco de código acima define uma função getUserState que obtém de forma assíncrona os dados de estado do usuário.

A função constrói uma consulta para encontrar o objeto de estado do usuário com base no argumento(userId) e recupera o estado do usuário, se encontrado.

Depois de recuperar o estado de um usuário, você precisará habilitar seu bot para atualizar o estado da conversa associado a esse usuário com base em seu ID de usuário e nas informações de estado fornecidas.

Por exemplo, a atualização do estado da conversa permitirá que o bot atualize a cidade preferida para obter atualizações meteorológicas regulares.

Assim:

// stateManager.js
async function setUserState(userId, state) {
  const query = new Parse.Query(UserState);
  query.equalTo('userId', userId.toString());
  let userState = await query.first();

  if (!userState) {
    userState = new UserState();
    userState.set('userId', userId.toString());
  }

  userState.set('state', state);
  await userState.save();
}

A função no bloco de código acima constrói uma consulta para encontrar o objeto de estado do usuário com base no userId, cria um novo objeto UserState se não houver nenhum, define o atributo state e salva o objeto no banco de dados.

Em seguida, defina uma função para redefinir o estado de um usuário adicionando o seguinte bloco de código ao seu arquivo stateManager.js:

// stateManager.js
async function resetUserState(userId) {
  await setUserState(userId, {});
}

A função resetUserState define de forma assíncrona o estado de um usuário como um objeto vazio {} para redefinir o estado do usuário no banco de dados.

Certifique-se de que um objeto de estado esteja sempre presente para acompanhar as ações do usuário antigo e do novo bot. Adicione o seguinte bloco de código abaixo ao arquivo stateManager.js:

// stateManager.js
async function ensureUserState(userId) {
  let state = await getUserState(userId);
  if (!state) {
    await setUserState(userId, {});
  }
}

O bloco de código define uma função ensureUserState que recupera o objeto de estado com base no ID do usuário, certificando-se de que os dados de estado do usuário existam para o userId fornecido na classe UserState no backend do Back4app Parse.

Ele obtém o estado do usuário com a função getUserState e, se não houver estado, define o estado como um objeto vazio {} usando a função setUserState.

Exporte todas as funções para que você possa usá-las em outros arquivos de origem Javascript:

// stateManager.js
module.exports = {
  getUserState,
  setUserState,
  resetUserState,
  ensureUserState,
};

Como lidar com a interação do usuário com o bot

Para permitir que seu bot ouça os comandos start, getWeather e setCity, você definirá ouvintes de eventos para fazer a correspondência entre o texto e os três comandos para executar funções de retorno de chamada.

Isso permitirá que o bot execute tarefas relacionadas aos comandos.

Para interagir com a API do Telegram Bot para permitir que você defina o comportamento do seu bot, importe a classe TelegramBot da biblioteca node-telegram-bot-api e crie uma nova instância da classe:

// bot.js
const TelegramBot = require('node-telegram-bot-api');
const token = process.env.TELEGRAM_BOT_TOKEN;
const bot = new TelegramBot(token, { polling: true });

O bloco de código acima cria uma nova instância da classe TelegramBot com dois argumentos: o token do bot e um objeto.

O objeto define o valor de sondagem como true para permitir que o bot verifique continuamente se há mensagens e atualizações dos servidores do Telegram.

Em seguida, importe os módulos que você criou neste projeto. Você usará esses módulos para implementar as funções do bot, como obter atualizações meteorológicas, definir uma cidade preferida e gerenciar o estado de um usuário.

Adicione o código a seguir para importar os módulos necessários:

// bot.js
const weather = require('./weather');
const cityManager = require('./cityManager');
const stateManager = require('./stateManager');

O bloco de código acima importa as funções que você criou em todos os arquivos de origem, permitindo que você chame essas funções no seu arquivo bot.js.

Para configurar um comando, você usa o método onText disponível para a classe TelegramBot. Esse método configura um ouvinte para implementar uma função de retorno de chamada para executar alguma lógica.

Adicione o bloco de código abaixo ao seu arquivo bot.js para configurar um manipulador de comando /start que o bot ouvirá ativamente com o método onText:

// bot.js

bot.onText(/\\/start/, async (msg) => {
    const welcomeMessage = "Welcome to the Weather Bot! Use the commands below to interact:\\n" +
    "/setCity - Set your preferred city for weather updates.\\n" +
    "/getWeather - Get instant weather information for any city.\\n";
    await bot.sendMessage(msg.chat.id, welcomeMessage);
    stateManager.ensureUserState(msg.chat.id);
});

O bloco de código acima permitirá que o bot execute uma função de retorno de chamada, enviando uma mensagem de boas-vindas ao usuário que detalha como o bot funciona.

O bot define o estado inicial do usuário com a função ensureUserState, garantindo um estado limpo para cada interação do usuário.

Em seguida, adicione o bloco de código abaixo ao seu arquivo bot.js para configurar um manipulador de comando /setCity que o bot ouvirá ativamente com o método onText:

// bot.js

bot.onText(/\\/setCity$/, async (msg) => {
    stateManager.setUserState(msg.chat.id, { expect: 'SET_CITY' });
    bot.sendMessage(msg.chat.id, "Which city do you want to set as your preferred city for weather updates?");
});

O bloco de código acima permite que os usuários especifiquem sua cidade preferida para atualizações meteorológicas com o comando"/setCity“.

Ao receber esse comando, o bot atualiza o estado do usuário para “SET_CITY” usando a função setUserState e solicita que o usuário digite a cidade desejada.

Adicione o bloco de código abaixo ao seu arquivo bot.js para configurar um manipulador de comando /getWeather que o bot ouvirá ativamente com o método onText:

// bot.js
bot.onText(/\\/getWeather$/, async (msg) => {
    stateManager.setUserState(msg.chat.id, { expect: 'GET_WEATHER' });
    bot.sendMessage(msg.chat.id, "Which city do you want to get weather information for?");
});

O comando “/getWeather” aciona o bot para atualizar o estado do usuário para “GET_WEATHER” e solicita que ele forneça uma cidade para a qual deseja obter informações meteorológicas instantaneamente.

Tratamento de mensagens recebidas

Para lidar com as mensagens recebidas pelo seu bot do Telegram, você precisará configurar um ouvinte de eventos que aciona uma função de retorno de chamada sempre que o bot recebe uma nova mensagem.

Adicione o bloco de código abaixo ao seu arquivo bot.js para configurar um manipulador de mensagens para ouvir os comandos e as respostas do usuário:

// bot.js

// Handle incoming messages
bot.on('message', async (msg) => {
    if (msg.text.startsWith('/')) {
        // If the message is a command, reset the user state
        stateManager.resetUserState(msg.chat.id);
    } else {
        // If it's not a command, check user state
        const state = await stateManager.getUserState(msg.chat.id);
        if (state && state.expect === 'SET_CITY') {
            // If expecting SET_CITY, set city and reset state
            const city = msg.text;
            cityManager.setCity(msg.chat.id, city);
            bot.sendMessage(msg.chat.id, `City set to ${city}. You will receive weather updates every 2 minutes.`);
            stateManager.resetUserState(msg.chat.id);
        } else if (state && state.expect === 'GET_WEATHER') {
            // If expecting GET_WEATHER, get weather and reset state
            const city = msg.text;
            weather.getWeather(city).then(response => {
                bot.sendMessage(msg.chat.id, response);
            }).catch(error => {
                bot.sendMessage(msg.chat.id, "Failed to retrieve weather.");
            });
            stateManager.resetUserState(msg.chat.id);
        }
    }
});

// Initialize the init function from cityManager.js for regular weather updates
cityManager.init(bot);

O bloco de código configura um manipulador de mensagens geral que ouve as mensagens de texto enviadas a ele e atua como o núcleo da lógica de interação.

Se uma mensagem começar com uma barra (“/”), ela será considerada um comando. Nesse caso, o manipulador redefine o estado do usuário para garantir um novo começo para o novo comando.

Caso contrário, o manipulador verifica o estado atual do usuário(stateManager.getUserState) para entender sua intenção.

Se o usuário passar o comando “/setCity”, o manipulador do bot usará cityManager.setCity para armazenar a cidade escolhida e confirmará a atualização.

Se o usuário passar o comando “/getWeather“, o manipulador recupera as informações meteorológicas da cidade fornecida usando a função weather.getWeather e envia a resposta de volta ao usuário.

O bloco de código acima executa então o cityManager.init(bot) para executar a tarefa programada de recuperar atualizações meteorológicas para uma cidade preferida.

Agora que você concluiu a manipulação da lógica do seu bot, configure um servidor para permitir que ele seja executado quando for implantado em um contêiner do Back4app.

Criação de um arquivo de entrada

Você criará um arquivo de entrada que inicializará todo o aplicativo bot. Esse arquivo terá duas funções.

• O arquivo de entrada executará a lógica do bot, exigindo o arquivo JavaScript que lida com a forma como seu bot interage com a API do Telegram e responde às mensagens do usuário.

• O arquivo de entrada também configurará um servidor para permitir que seu bot seja executado em um contêiner do Back4app. Os contêineres do Back4app exigem portas expostas para que a implantação do seu aplicativo seja bem-sucedida.

Navegue até o arquivo server.js no diretório do seu projeto. Esse arquivo tratará da criação do servidor. Adicione o bloco de código abaixo ao arquivo server.js:

const http = require('http');
require('./src/bot'); // Import bot logic
const port = 3000;

http
  .createServer((req, res) => {
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end('My Telegram bot is running\\n');
  })
  .listen(port, () => {
    console.log(`Server running on port ${port}`);
  });

O bloco de código acima configura um bot do Telegram para ser executado, criando um servidor HTTP simples. Esse servidor atua como um ponto de entrada, permitindo que o bot funcione no ambiente do contêiner.

O script importa a lógica central do seu bot e especifica uma porta do Back4app para permitir que seu bot seja implantado em um contêiner do Back4app.

Depois de criar o arquivo de entrada, você pode testar o bot do Telegram localmente antes de implantá-lo em um contêiner do Back4app.

Testando o bot do Telegram

Inicie seu bot do Telegram executando o comando abaixo:

node server.js

Para interagir com seu bot, abra o aplicativo Telegram e procure o nome do seu bot na barra de pesquisa. Entre no bate-papo com seu bot e envie o comando /start.

O bot deve responder com uma mensagem de boas-vindas e uma lista de comandos. Envie um comando para o bot.

O bot permite que você defina sua cidade preferida e receba atualizações meteorológicas regulares com o comando /setCity.

O comando /getWeather, conforme mostrado na imagem acima, pode obter instantaneamente informações sobre o clima de uma determinada cidade.

O bot deve se comportar de forma semelhante à mostrada na imagem acima, respondendo aos seus comandos e interagindo com você conforme pretendido.

Implantação do bot do Telegram em contêineres do Back4App

Depois de testar seu bot e garantir que ele funcione corretamente, você pode implantá-lo nos contêineres do Back4app. Para isso, primeiro, você precisará criar um Dockerfile para seu projeto.

No diretório raiz do seu projeto, crie um arquivo Dockerfile e adicione o bloco de código abaixo a ele:

# Specify base image
FROM node:18-alpine

# Specify the working directory
WORKDIR /app

# Copy package.json and package-lock.json
COPY package*.json ./

RUN npm install

COPY . .

EXPOSE 3000

# Run the app
CMD ["npm", "start"]

Depois de criar o Dockerfile, envie seu repositório local para o GitHub para torná-lo acessível para implantação em contêineres do Back4app.

Em seguida, instale o aplicativo Back4App Containers GitHub em sua conta do GitHub e conceda ao aplicativo as permissões necessárias para acessar o repositório de código do seu aplicativo.

Depois de concluir a configuração do GitHub, navegue até a página inicial do Back4app e clique no botão “New App” (Novo aplicativo) no canto superior direito da tela.

Isso o levará a uma tela de inicialização, na qual você precisará escolher o tipo de aplicativo que deseja criar. Selecione a opção Back4app agent, conforme mostrado na imagem abaixo.

Ao selecionar a opção Back4app Agent, você será redirecionado para a página do agente do Back4app AI.

Digite o prompt abaixo para implementar seu aplicativo nos contêineres do Back4app:

Deploy my "YOUR_REPOSITORY_URL" repository on GitHub to Back4App Containers.
Here are the required environmental variables:
TELEGRAM_BOT_TOKEN = "TELEGRAM_BOT_TOKEN"
OPENWEATHERMAP_TOKEN = "WEATHER_API_TOKEN"
BACK4APP_APP_ID = "BACK4APP_APP_ID"
BACK4APP_JAVASCRIPT_KEY = "BACK4APP_JAVASCRIPT_KEY"

Substitua os espaços reservados por seus valores reais. O prompt acima iniciará seu processo de implementação. Quando concluído, o agente de IA responderá, indicando sucesso ou uma implantação pendente.

Você deve receber uma resposta semelhante à que está abaixo:

Se você receber uma implantação pendente, poderá monitorar o status da implantação do aplicativo no painel do contêiner do Back4app. Como alternativa, você pode implantar seu aplicativo manualmente nos contêineres do Back4app.

Conclusão

Neste artigo, você aprendeu a criar um bot do Telegram com o Node.js. Você explorou como criar uma conta de bot do Telegram, lidar com comandos de bot e lidar com interações do usuário.

Você também criou um backend para seu bot com a ajuda do agente de IA Back4app, que permitiu gerenciar o estado do usuário de forma eficaz e armazenar informações em conversas, como a cidade preferida do usuário para receber atualizações meteorológicas regularmente.

Você pode encontrar o código completo neste repositório do GitHub.