Em publicação anterior Nós descobrimos como criar um bot e inicializamos uma instância da classe Bot e nos familiarizamos com os métodos de envio de mensagens através dele.

Neste artigo, dou continuidade a este tema, portanto, recomendo que você comece a ler este artigo apenas após ler primeira parte.

Desta vez, vamos entender como dar vida ao nosso bot e adicionar suporte a comandos, além de nos familiarizarmos com a classe Updater.

Ao longo do artigo, vamos escrever alguns bots simples; o último determinará, com base em uma data e código de país, se o dia é um feriado ou um dia útil de acordo com o calendário de trabalho. Mas, como antes, o objetivo do artigo é familiarizá-lo com a interface do pacote telegram.bot para resolver suas próprias tarefas.

Criando um bot e enviando mensagens através dele no telegram

Conteúdo

youtube telegram e canais. A maior parte do conteúdo é dedicada à linguagem R. O processo de construção do bot

Classe Updater
Handlers — manipuladores
Adicionando o primeiro comando ao bot, o manipulador de comandos
Manipulador de mensagens de texto e filtros
Adicionando comandos com parâmetros
Executando o bot em segundo plano
Conclusão

Classe Updater

Updater — é uma classe que simplifica o desenvolvimento de bots do Telegram e utiliza em seu backend a classe Dispatcher. A finalidade da classe Updater é obter atualizações do bot (no artigo anterior, usamos para esse fim o método getUpdates()), e passar elas adiante para Dispatcher.

Por sua vez Dispatcher contém os manipuladores que você criou, ou seja, objetos da classe Handler.

Handlers — manipuladores

Com os manipuladores, você adiciona em Dispatcher reações do bot a vários eventos. No momento da redação deste artigo, foram adicionados os seguintes tipos de manipuladores: telegram.bot MessageHandler — Manipulador de mensagens

CommandHandler — Manipulador de comandos
CallbackQueryHandler — Manipulador de dados enviados de teclados inline
ErrorHandler — Manipulador de erros ao solicitar atualizações do bot
Se você nunca usou bots antes e não sabe o que é um comando, os comandos precisam ser enviados ao bot com uma barra invertida

Adicionando o primeiro comando ao bot, o manipulador de comandos

como prefixo. / Começaremos com comandos simples, ou seja, ensinaremos nosso bot a cumprimentar com o comando

Código 1: Ensinando o bot a cumprimentar /hi.

Código 1: Estamos ensinando o bot a cumprimentar

library(telegram.bot)

# Criando uma instância da classe Updater
updater <- Updater('SEU TOKEN DO BOT')

# Escrevendo um método para saudar
say_hello <- function(bot, update) {

  # Nome do usuário a ser cumprimentado
  user_name <- update$message$from$first_name

  # Enviando uma mensagem de boas-vindas
  bot$sendMessage(update$message$chat_id, 
                  text = paste0("Saudações, ", user_name, "!"), 
                  parse_mode = "Markdown")

}

# Criando o manipulador
hi_handler <- CommandHandler('hi', say_hello)

# Adicionando o manipulador ao despachante
updater <- updater + hi_handler

# Iniciando o bot
updater$start_polling()

Execute the example code above, replacing 'SEU TOKEN DE BOT' with the real token you received when creating your bot via BotFather (I explained how to create a bot in primeiro artigo).

Método start_polling() classe Updater, que é utilizado no final do código, inicia um loop infinito de solicitações e processamento de atualizações do bot.

Agora vamos abrir o Telegram e enviar o nosso primeiro comando para o bot /hi.

Agora nosso bot entende o comando /hi, e é capaz de nos cumprimentar.

Esquematicamente, o processo de construção de um bot tão simples pode ser representado da seguinte forma.

Criamos uma instância da classe Updater;
Criamos métodos, ou seja, funções que o nosso bot irá executar. No exemplo de código, essa função é say_hello(). As funções que você usará como métodos do bot devem ter dois argumentos obrigatórios — bot e atualizar, e um opcional — args. O argumento bot, é o seu bot, com o qual você pode responder a mensagens, enviar mensagens ou usar quaisquer outros métodos disponíveis para o bot. O argumento atualizar é o que o bot recebeu do usuário, basicamente, o que na primeira parte recebemos pelo método getUpdates(). O argumento args permite que você processe dados adicionais enviados pelo usuário junto com o comando, voltaremos a este tema um pouco mais tarde;
Criamos manipuladores, ou seja, vinculamos algumas ações do usuário aos métodos criados na etapa anterior. Essencialmente, um manipulador é um gatilho, um evento que chama uma função do bot. No nosso exemplo, tal gatilho é o envio do comando /hi, implementado com o comando hi_handler <- CommandHandler('hi', say_hello). O primeiro argumento da função CommandHandler() permite que você defina o comando, no nosso caso hi, ao qual o bot irá reagir. O segundo argumento permite especificar o método do bot, vamos chamar o método say_hello, que será executado se o usuário chamar o comando especificado no primeiro argumento;
Em seguida, adicionamos o manipulador criado ao despachante da nossa instância da classe Updater. Os manipuladores podem ser adicionados de várias formas, no exemplo acima eu usei o mais simples, com o sinal +, ou seja, updater <- updater + hi_hendler. O mesmo pode ser feito usando o método add_handler(), que pertence à classe Dispatcher, esse método pode ser encontrado da seguinte forma: updater$dispatcher$add_handler();
Iniciamos o bot com o comando start_polling().

Manipulador de mensagens de texto e filtros

Como já entendemos como enviar comandos para o bot, às vezes precisamos que o bot reaja não apenas a comandos, mas também a mensagens comuns de texto. Para isso, é necessário usar manipuladores de mensagens — MessageHandler.

Comum MessageHandler vai reagir a todas as mensagens recebidas. Por isso, muitas vezes os manipuladores de mensagens são usados junto com filtros. Vamos ensinar o bot a cumprimentar não apenas por comando /hi, mas também sempre que uma das seguintes palavras apareça na mensagem enviada ao bot: olá, saúde, saudação, hi, bonjour.

Por enquanto, não vamos escrever novos métodos, já que temos um método que faz o bot nos cumprimentar. O que precisamos fazer é criar o filtro e o manipulador de mensagens apropriado.

Código 2: Adicionando manipulador de mensagens de texto e filtro

library(telegram.bot)

# Criamos uma instância da classe Updater
updater <- Updater('TOKEN DO SEU BOT')

# Escrevemos o método para cumprimento
## comando de cumprimento
say_hello <- function(bot, update) {

  # Nome de usuário com quem precisamos cumprimentar
  user_name <- update$message$from$first_name

  # Enviamos a mensagem de saudação
  bot$sendMessage(update$message$chat_id, 
                  text = paste0("Minha saudação, ", user_name, "!"),
                  parse_mode = "Markdown",
                  reply_to_message_id = update$message$message_id)

}

# Criamos filtros
MessageFilters$hi <- BaseFilter(function(message) {

  # verificamos se aparecem nas mensagens as palavras: olá, saúde, saudação, hi, bonjour
  grepl(x = message$text, 
        pattern = 'olá|saúde|saudação|hi|bonjour',
        ignore.case = TRUE)
  }
)

# Criamos o manipulador 
hi_hendler <- CommandHandler('hi', say_hello) # manipulador do comando hi
hi_txt_hnd <- MessageHandler(say_hello, filters = MessageFilters$hi)

# adicionamos os manipuladores ao despachante
updater <- updater + 
             hi_hendler +
             hi_txt_hnd

# iniciamos o bot
updater$start_polling()

Execute the example code above, replacing 'SEU TOKEN DE BOT' with the real token you received when creating your bot via BotFather (I explained how to create a bot in primeiro artigo).

Agora tentaremos enviar algumas mensagens ao bot, que conterão as palavras de saudação mencionadas anteriormente:

Portanto, em primeiro lugar, ensinamos o bot a não apenas cumprimentar, mas a responder a saudações. Fizemos isso usando o argumento reply_to_message_id, que está disponível no método sendMessage(), no qual é necessário passar o id da mensagem à qual se deseja responder. O id da mensagem pode ser obtido assim: update$message$message_id.

Mas o mais importante que fizemos foi adicionar um filtro ao bot usando a função BaseFilter():

# создаём фильтры
MessageFilters$hi <- BaseFilter( 

  # анонимная фильтрующая функция
  function(message) {

    # проверяем, встречается ли в тексте сообщения слова приветствия
    grepl(x           = message$text, 
          pattern     = 'привет|здравствуй|салют|хай|бонжур',
          ignore.case = TRUE)
  }

)

Como você pode ter notado, os filtros precisam ser adicionados ao objeto MessageFilters, no qual já existe um pequeno conjunto de filtros prontos. No nosso exemplo, ao objeto MessageFilters adicionamos o elemento hi, que é o novo filtro.

Na função BaseFilter() é necessário passar a função de filtragem. Essencialmente, um filtro é apenas uma função que recebe uma instância de mensagem e retorna TRUE ou FALSE. No nosso exemplo, escrevemos a função mais simples, que usa a função básica grepl() para verificar o texto da mensagem, e se ele corresponder à expressão regular olá|saudações|salve|oi|bonjour fundos! E ainda recebe elogios de 75-90% dos participantes, embora o desenvolvimento do projeto claramente tenha desacelerado. O mais surpreendente é que todos foram TRUE.

Em seguida, criamos um manipulador de mensagens hi_txt_hnd <- MessageHandler(say_hello, filters = MessageFilters$hi). O primeiro argumento da função MessageHandler() — método que chamará o manipulador, e o segundo argumento — é o filtro pelo qual ele será chamado. No nosso caso, este é o filtro que criamos MessageFilters$hi.

E assim, adicionamos ao despachar o manipulador que acabamos de criar hi_txt_hnd.

updater <- updater + 
             hi_hendler +
             hi_txt_hnd

Como já mencionei acima, o pacote telegram.bot e o objeto MessageFilters já têm um conjunto de filtros embutidos que você pode usar:

all — Todas as mensagens
text — Mensagens de texto
command — Comandos, ou seja, mensagens que começam com /
reply — Mensagens que são respostas a outra mensagem
audio — Mensagens que contêm arquivos de áudio
document — Mensagens com documentos enviados
photo — Mensagens com imagens enviadas
sticker — Mensagens com stickers enviados
video — Mensagens com vídeos
voice — Mensagens de voz
contact — Mensagens que contêm contato do usuário do telegram
location — Mensagens com geolocalização
venue — Mensagens encaminhadas
game — Jogos

Se você deseja combinar alguns filtros em um único manipulador, basta usar o sinal | — como o lógico OU, e o sinal & como o lógico eu posso usar. Por exemplo, se você quer que o bot chame o mesmo método quando recebe um vídeo, uma imagem ou um documento, use o seguinte exemplo de criação de um manipulador de mensagens:

handler <- MessageHandler(callback, 
  MessageFilters$video | MessageFilters$photo | MessageFilters$document
)

Adicionando comandos com parâmetros

Já sabemos o que são comandos, como criá-los e como fazer o bot executar um comando necessário. Mas em alguns casos, além do nome do comando, é necessário passar alguns dados para sua execução.

Abaixo está um exemplo de bot que, a partir de uma data e um país fornecidos, retorna o tipo de dia do calendário de trabalho.

O bot abaixo utiliza a API do calendário de trabalho isdayoff.ru.

Código 3: Bot que informa sobre a data e o país

library(telegram.bot)

# cria uma instância da classe Updater
updater <- Updater('1165649194:AAFkDqIzQ6Wq5GV0YU7PmEZcv1gmWIFIB_8')

# Escreve o método de saudação
## comando de saudação
check_date <- function(bot, update, args) {

  # dados de entrada
  day     <- args[1]  # data
  country <- args[2]  # país

  # verificação dos parâmetros fornecidos
  if ( !grepl('\d{4}-\d{2}-\d{2}', day) ) {

    # Envia Teclado Personalizado
    bot$sendMessage(update$message$chat_id, 
                    text = paste0(day, " - data incorreta, insira a data no formato AAAA-MM-DD"),
                    parse_mode = "Markdown")

  } else {
    day <- as.Date(day)
    # converte para formato POSIXtl
    y <- format(day, "%Y")
    m <- format(day, "%m")
    d <- format(day, "%d")

  }

  # país para verificação
  ## verifica se o país foi definido
  ## se não foi definido, estabelece como ru
  if ( ! country %in% c('ru', 'ua', 'by', 'kz', 'us') ) {

    # Envia Teclado Personalizado
    bot$sendMessage(update$message$chat_id, 
                    text = paste0(country, " - código de país incorreto, os valores possíveis são: ru, by, kz, ua, us. Dados solicitados para a Rússia."),
                    parse_mode = "Markdown")

    country <- 'ru'

  }

  # solicita dados da API
  # montagem da solicitação HTTP
  url <- paste0("https://isdayoff.ru/api/getdata?",
                "year=",  y, "&",
                "month=", m, "&",
                "day=",   d, "&",
                "cc=",    country, "&",
                "pre=1&",
                "covid=1")

  # recebendo a resposta
  res <- readLines(url)

  # interpretação da resposta
  out <- switch(res, 
                "0"   = "Dia de Trabalho",
                "1"   = "Dia Não Útil",
                "2"   = "Dia de Trabalho Reduzido",
                "4"   = "covid-19",
                "100" = "Erro na data",
                "101" = "Dados não encontrados",
                "199" = "Erro do serviço")

  # envia mensagem
  bot$sendMessage(update$message$chat_id, 
                  text = paste0(day, " - ", out),
                  parse_mode = "Markdown")

}

# cria o manipulador 
date_hendler <- CommandHandler('check_date', check_date, pass_args = TRUE)

# adiciona o manipulador no dispatcher
updater <- updater + date_hendler

# inicia o bot
updater$start_polling()

Execute the example code above, replacing 'SEU TOKEN DE BOT' with the real token you received when creating your bot via BotFather (I explained how to create a bot in primeiro artigo).

Criamos um bot que possui apenas um método em seu arsenal check_date, este método é chamado pelo comando homônimo.

No entanto, além do nome do comando, este método espera que você insira dois parâmetros, o código do país e a data. Em seguida, o bot verifica se o dia especificado no país indicado é um feriado, um dia reduzido ou um dia de trabalho, de acordo com o calendário oficial de produção.

Para que o método que estamos criando aceite parâmetros adicionais junto com o comando, use o argumento pass_args = TRUE na função CommandHandler(), e ao criar o método, além dos argumentos obrigatórios, bot, atualizar crie um opcional — args. O método criado dessa forma aceitará os parâmetros que você enviar ao bot após o nome do comando. Os parâmetros devem ser separados por um espaço, e eles entrarão no método como um vetor de texto.

Vamos executar e testar nosso bot.

Executando o bot em segundo plano

A última etapa que nos resta é executar o bot em segundo plano.

Para isso, siga o algoritmo descrito abaixo:

Salve o código do bot em um arquivo com a extensão R. Ao trabalhar no RStudio, isso é feito através do menu Novo projeto, com o comando Salvar Como….
Adicione o caminho para a pasta bin, que por sua vez está na pasta onde você instalou a linguagem R, na variável Path, instrução aqui.
Crie um arquivo de texto simples, onde você escreverá 1 linha: R CMD BATCH C:UsersAlseyDocumentsmy_bot.R. Em vez de C:UsersAlseyDocumentsmy_bot.R escreva o caminho para o seu script do bot. É importante que o caminho não contenha caracteres cirílicos e espaços, pois isso pode causar problemas ao executar o bot. Salve-o e altere sua extensão de txt para bat.
Abra o Agendador de Tarefas do Windows, há várias maneiras de fazer isso, por exemplo, abra qualquer pasta e digite no endereço %windir%system32taskschd.msc /s. Outras maneiras de iniciá-lo podem ser encontradas aqui.
No menu superior direito do agendador, clique em "Criar Tarefa…".
Na aba "Geral", forneça um nome arbitrário para sua tarefa e mude o seletor para o estado "Executar para todos os usuários".
Vá até a aba "Ações", clique em "Criar". No campo "Programa ou Script", clique em "Procurar", localize o arquivo criado na segunda etapa bat , e clique em OK.
Clique em OK, e se necessário, digite a senha da sua conta do sistema operacional.
Encontre a tarefa criada no agendador, selecione-a e no canto inferior direito clique no botão "Executar".

Nosso bot está rodando em segundo plano e continuará funcionando até que você pare a tarefa ou desligue seu PC ou servidor onde ele foi iniciado.

Conclusão

Neste artigo, abordamos como escrever um bot completo que não só pode enviar mensagens, mas também reagir a mensagens e comandos recebidos. O conhecimento adquirido já é suficiente para resolver a maioria de suas tarefas.

No próximo artigo, falaremos sobre como adicionar um teclado ao bot para facilitar seu uso.

Inscreva-se no meu telegram e canais. A maior parte do conteúdo é dedicada à linguagem R. canais.

Fonte: habr.com