In pubblicazione precedente abbiamo visto come creare un bot e inizializzato un'istanza della classe Bot e ci siamo familiarizzati con i metodi per inviare messaggi tramite il suo utilizzo.

In questo articolo proseguo il tema, quindi raccomando di leggere questo articolo solo dopo aver letto parte uno.

Questa volta esploreremo come rendere il nostro bot attivo e aggiungeremo il supporto per i comandi, oltre a familiarizzare con la classe Updater.

Durante l'articolo scriveremo alcuni semplici bot, l'ultimo dei quali determinerà se un giorno specifico in un determinato paese è festivo o lavorativo secondo il calendario lavorativo. Ma, come sempre, l'obiettivo dell'articolo è farvi conoscere l'interfaccia del pacchetto telegram.bot per risolvere i vostri compiti personali.

Tutti gli articoli della serie "Scriviamo un bot di Telegram in R"

Contenuto

Se siete interessati all'analisi dei dati, potrebbero interessarvi i miei telegram e youtube canali. Gran parte del contenuto è dedicato al linguaggio R.

Classe Updater
Handlers — gestori
Aggiungiamo il primo comando al bot, gestore dei comandi
Gestore dei messaggi di testo e filtri
Aggiunta di comandi con parametri
Avviamo il bot in background
Conclusione

Classe Updater

Updater è una classe che semplifica lo sviluppo del bot di Telegram, utilizzando in backend la classe Dispatcher. Lo scopo della classe Updater è quello di ricevere gli aggiornamenti dal bot (nel precedente articolo abbiamo utilizzato a questo scopo il metodo getUpdates()), e passarli successivamente a Dispatcher.

A sua volta Dispatcher contiene i gestori che hai creato, ovvero oggetti della classe Handler.

Handlers — gestori

Con i gestori, aggiungi a Dispatcher le reazioni del bot a vari eventi. Al momento della scrittura dell'articolo, sono stati aggiunti i seguenti tipi di gestori: telegram.bot MessageHandler — Gestore dei messaggi

CommandHandler — Gestore dei comandi
CallbackQueryHandler — Gestore dei dati inviati dalle tastiere inline
ErrorHandler — Gestore degli errori durante la richiesta di aggiornamenti dal bot
Se non hai mai utilizzato bot prima e non sei a conoscenza di cosa sia un comando, il bot deve ricevere i comandi utilizzando una barra obliqua

Aggiungiamo il primo comando al bot, gestore dei comandi

come prefisso. / Iniziamo con comandi semplici, ovvero insegniamo al nostro bot a salutare su comando

Iniziamo con comandi semplici, ad esempio insegneremo al nostro bot a salutare su comando /hi.

Codice 1: Insegniamo al bot a salutare

library(telegram.bot)

# creiamo un'istanza della classe Updater
updater <- Updater('IL TOKEN DEL VOSTRO BOT')

# Scriviamo un metodo per il saluto
say_hello <- function(bot, update) {

  # Nome dell'utente con cui salutare
  user_name <- update$message$from$first_name

  # Inviando un messaggio di benvenuto
  bot$sendMessage(update$message$chat_id, 
                  text = paste0("Salve, ", user_name, "!"), 
                  parse_mode = "Markdown")

}

# creiamo un gestore
hi_handler <- CommandHandler('hi', say_hello)

# aggiungiamo il gestore al gestore
updater <- updater + hi_handler

# avviamo il bot
updater$start_polling()

Esegui l'esempio di codice fornito sopra, sostituendo ‘IL TOKEN DEL VOSTRO BOT’ con il token reale che hai ricevuto durante la creazione del bot tramite BotFather (ho parlato della creazione del bot in primo articolo).

Metodo start_polling() classe Updater, che viene utilizzato alla fine del codice per avviare un ciclo infinito di richiesta e gestione degli aggiornamenti dal bot.

Ora apriamo Telegram e scriviamo al nostro bot il primo comando /hi.

Ora il nostro bot capisce il comando /hi, e sa come salutarci.

Schematicamente, il processo di creazione di un bot così semplice può essere rappresentato nel seguente modo.

Creiamo un'istanza della classe Updater;
Creiamo metodi, ovvero funzioni che il nostro bot eseguirà. Nell'esempio di codice è la funzione say_hello(). Le funzioni che utilizzerai come metodi del bot devono avere due argomenti obbligatori — bot e update, e uno opzionale — args. L'argomento bot, è il tuo bot, grazie al quale puoi rispondere ai messaggi, inviare messaggi o usare qualsiasi altro metodo disponibile per il bot. L'argomento update è ciò che il bot ha ricevuto dall'utente, in sostanza, ciò che nella prima parte ottenevamo attraverso il metodo getUpdates(). L'argomento args permette di gestire dati aggiuntivi inviati dall'utente insieme al comando, su questo tema torneremo più avanti.
Creiamo gestori, collegando alcune azioni dell'utente con i metodi creati nel passo precedente. In sostanza, un gestore è un trigger, un evento che attiva una funzione del bot. Nel nostro esempio, un tale trigger è l'invio del comando /hi, e viene implementato con il comando hi_hendler <- CommandHandler('hi', say_hello). Il primo argomento della funzione CommandHandler() ti consente di specificare il comando, nel nostro caso hi, a cui risponderà il bot. Il secondo argomento consente di specificare il metodo del bot, chiameremo il metodo say_hello, che verrà eseguito se l'utente ha attivato il comando specificato nel primo argomento;
Successivamente, aggiungiamo il gestore creato al dispatcher della nostra istanza di classe Updater. I gestori possono essere aggiunti in diversi modi, nell'esempio sopra ho utilizzato il modo più semplice, utilizzando il segno +, cioè. updater <- updater + hi_hendler. Lo stesso può essere fatto usando il metodo add_handler(), che appartiene alla classe Dispatcher, trovare questo metodo è possibile in questo modo: updater$dispatcher$add_handler();
Avviamo il bot usando il comando start_polling().

Gestore dei messaggi di testo e filtri

Abbiamo visto come inviare comandi al bot, ma a volte è necessario che il bot risponda non solo ai comandi, ma anche a messaggi di testo normali. Per questo è necessario utilizzare i gestori di messaggi — MessageHandler.

Normale MessageHandler reagirà a tutti i messaggi in ingresso. Pertanto, di solito i gestori di messaggi vengono utilizzati insieme ai filtri. Insegniamo al bot a salutare non solo su comando. /hi, ma anche ogni volta che nel messaggio inviato al bot appare una delle seguenti parole: ciao, saluto, salve, hi, bonjour.

Finché non scriviamo nuovi metodi, poiché abbiamo già un metodo con cui il bot ci saluta. Da parte nostra, è sufficiente creare il filtro necessario e il gestore dei messaggi.

Codice 2: Aggiungiamo il gestore dei messaggi di testo e il filtro

library(telegram.bot)

# creiamo un'istanza della classe Updater
updater <- Updater('IL TOKEN DEL TUO BOT')

# Scriviamo un metodo per il benvenuto
## comando di benvenuto
say_hello <- function(bot, update) {

  # Nome utente con cui salutare
  user_name <- update$message$from$first_name

  # Inviamo il messaggio di saluto
  bot$sendMessage(update$message$chat_id, 
                  text = paste0("Il mio saluto, ", user_name, "!"),
                  parse_mode = "Markdown",
                  reply_to_message_id = update$message$message_id)

}

# creiamo filtri
MessageFilters$hi <- BaseFilter(function(message) {

  # verifichiamo se nel testo del messaggio ci sono le parole: ciao, salve, salute, hi, bonjour
  grepl(x           = message$text, 
        pattern     = 'ciao|salve|salute|hi|bonjour',
        ignore.case = TRUE)
  }
)

# creiamo un gestore 
hi_hendler <- CommandHandler('hi', say_hello) # gestore del comando hi
hi_txt_hnd <- MessageHandler(say_hello, filters = MessageFilters$hi)

# aggiungiamo i gestori al dispatcher
updater <- updater + 
             hi_hendler +
             hi_txt_hnd

# avviamo il bot
updater$start_polling()

Esegui l'esempio di codice fornito sopra, sostituendo ‘IL TOKEN DEL VOSTRO BOT’ con il token reale che hai ricevuto durante la creazione del bot tramite BotFather (ho parlato della creazione del bot in primo articolo).

Ora proviamo a inviare al bot alcuni messaggi contenenti le parole di saluto menzionate in precedenza:

Quindi, prima di tutto, abbiamo insegnato al bot non solo a salutare, ma anche a rispondere al saluto. Lo abbiamo fatto utilizzando l'argomento reply_to_message_id, disponibile nel metodo sendMessage(), a cui deve essere passato l'ID del messaggio a cui si desidera rispondere. È possibile ottenere l'ID del messaggio in questo modo: update$message$message_id.

Ma la cosa principale che abbiamo fatto è stata aggiungere un filtro al bot utilizzando la funzione BaseFilter():

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

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

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

)

Come avrete notato, i filtri devono essere aggiunti all'oggetto MessageFilters, che ha già un piccolo set di filtri pronti all'uso. Nel nostro esempio, nell'oggetto MessageFilters abbiamo aggiunto l'elemento hi, questo è un nuovo filtro.

Nella funzione BaseFilter() È necessario passare una funzione di filtraggio. In sostanza, un filtro è semplicemente una funzione che riceve un'istanza del messaggio e restituisce TRUE o FALSE. Nel nostro esempio, abbiamo scritto una semplice funzione che utilizza la funzione di base grepl() per controllare il testo del messaggio, e se corrisponde all'espressione regolare ciao|salve|saluto|hi|bonjour restituisce TRUE.

Successivamente, creiamo un gestore di messaggi hi_txt_hnd <- MessageHandler(say_hello, filters = MessageFilters$hi). Il primo argomento della funzione MessageHandler() è il metodo che richiamerà il gestore, e il secondo argomento è il filtro in base al quale verrà chiamato. Nel nostro caso, si tratta del filtro che abbiamo creato MessageFilters$hi.

Alla fine, aggiungiamo al gestore il gestore appena creato hi_txt_hnd.

updater <- updater + 
             hi_hendler +
             hi_txt_hnd

Come ho già scritto sopra, nel pacchetto telegram.bot e nell'oggetto MessageFilters c'è già un insieme di filtri incorporati che puoi utilizzare:

all — Tutti i messaggi
text — Messaggi di testo
command — Comandi, cioè messaggi che iniziano con /
reply — Messaggi che sono risposte ad un altro messaggio
audio — Messaggi che contengono un file audio
document — Messaggi con un documento inviato
photo — Messaggi con immagini inviate
sticker — Messaggi con un adesivo inviato
video — Messaggi con video
voice — Messaggi vocali
contact — Messaggi che contengono il contatto di un utente di Telegram
location — Messaggi con geolocalizzazione
venue — Messaggi inoltrati
game — Giochi

Se desideri combinare alcuni filtri in un singolo gestore, usa semplicemente il segno | — come logico OPPURE, e il segno & come logico E. Ad esempio, se si desidera che il bot chiami lo stesso metodo quando riceve un video, un'immagine o un documento, utilizzare il seguente esempio di creazione di un gestore di messaggi:

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

Aggiunta di comandi con parametri

Sappiamo già cos'è un comando, come crearli e come far eseguire al bot il comando desiderato. Tuttavia, in alcuni casi, oltre al nome del comando, è necessario passare alcuni dati per la sua esecuzione.

Di seguito un esempio di bot che restituisce il tipo di giorno dal calendario lavorativo in base alla data e al paese forniti.

Il bot sottostante utilizza l'API del calendario lavorativo isdayoff.ru.

Codice 3: Bot che comunica in base alla data e al paese

library(telegram.bot)

# creiamo un'istanza della classe Updater
updater <- Updater('1165649194:AAFkDqIzQ6Wq5GV0YU7PmEZcv1gmWIFIB_8')

# Scriviamo un metodo per il benvenuto
## comando di benvenuto
check_date <- function(bot, update, args) {

  # dati in entrata
  giorno <- args[1]  # data
  paese <- args[2]  # paese

  # verifica dei parametri inseriti
  if ( !grepl('\d{4}-\d{2}-\d{2}', giorno) ) {

    # Invia una tastiera personalizzata
    bot$sendMessage(update$message$chat_id, 
                    text = paste0(giorno, " - data non valida, inserisci la data nel formato AAAA-MM-GG"),
                    parse_mode = "Markdown")

  } else {
    giorno <- as.Date(giorno)
    # convertiamo in formato POSIXlt
    y <- format(giorno, "%Y")
    m <- format(giorno, "%m")
    d <- format(giorno, "%d")

  }

  # paese da verificare
  ## controlliamo se è stato specificato un paese
  ## se non è specificato impostiamo ru
  if ( ! paese %in% c('ru', 'ua', 'by', 'kz', 'us') ) {

    # Invia una tastiera personalizzata
    bot$sendMessage(update$message$chat_id, 
                    text = paste0(paese, " - codice paese non valido, valori possibili: ru, by, kz, ua, us. Dati richiesti per la Russia."),
                    parse_mode = "Markdown")

    paese <- 'ru'

  }

  # richiesta dei dati dall'API
  # composizione della richiesta HTTP
  url <- paste0("https://isdayoff.ru/api/getdata?",
                "year=",  y, "&",
                "month=", m, "&",
                "day=",   d, "&",
                "cc=",    paese, "&",
                "pre=1&",
                "covid=1")

  # otteniamo la risposta
  res <- readLines(url)

  # interpretazione della risposta
  out <- switch(res, 
                "0"   = "Giorno lavorativo",
                "1"   = "Giorno non lavorativo",
                "2"   = "Giorno lavorativo abbreviato",
                "4"   = "covid-19",
                "100" = "Errore nella data",
                "101" = "Dati non trovati",
                "199" = "Errore del servizio")

  # inviamo il messaggio
  bot$sendMessage(update$message$chat_id, 
                  text = paste0(giorno, " - ", out),
                  parse_mode = "Markdown")

}

# creiamo un gestore 
date_hendler <- CommandHandler('check_date', check_date, pass_args = TRUE)

# aggiungiamo il gestore al dispatcher
updater <- updater + date_hendler

# avviamo il bot
updater$start_polling()

Esegui l'esempio di codice fornito sopra, sostituendo ‘IL TOKEN DEL VOSTRO BOT’ con il token reale che hai ricevuto durante la creazione del bot tramite BotFather (ho parlato della creazione del bot in primo articolo).

Abbiamo creato un bot che ha solo un metodo nel suo arsenale check_date, questo metodo viene richiamato dal comando omonimo.

Tuttavia, oltre al nome del comando, questo metodo richiede l'inserimento di due parametri da parte vostra: il codice del paese e la data. Successivamente, il bot verifica se il giorno specificato nel paese indicato è festivo, abbreviato o lavorativo secondo il calendario ufficiale.

Per far sì che il metodo che stiamo creando accetti parametri aggiuntivi insieme al comando, utilizzate l'argomento pass_args = TRUE nella funzione CommandHandler(), e durante la creazione del metodo, oltre agli argomenti obbligatori bot, update create un opzionale — args. Il metodo creato in questo modo accetterà i parametri che inviate al bot dopo il nome del comando. I parametri devono essere separati da uno spazio e arriveranno al metodo come vettore di testo.

Diamo avvio e testiamo il nostro bot.

Avviamo il bot in background

L'ultimo passo da completare è avviare il bot in modalità background.

Per fare ciò, seguite l'algoritmo descritto di seguito:

Salvate il codice del bot in un file con estensione R. Quando lavorate in RStudio, questo si fa attraverso il menu File, con il comando Salva come....
Aggiungi il percorso della cartella bin, che si trova nella cartella in cui hai installato il linguaggio R, alla variabile Path, istruzioni qui.
Crea un file di testo normale, in cui scrivere la riga: R CMD BATCH C:\Users\Alsey\Documents\my_bot.R. Al posto di C:\Users\Alsey\Documents\my_bot.R inserisci il percorso del tuo script bot. È importante che nel percorso non ci siano caratteri cirillici e spazi, poiché questo potrebbe causare problemi durante l'avviamento del bot. Salvalo e cambia l'estensione da txt con bat.
Apri l'utilità di pianificazione di Windows, ci sono molti modi per farlo, ad esempio apri una qualsiasi cartella e nel percorso inserisci %windir%\system32\taskschd.msc /s. Altri modi per avviare possono essere trovati qui.
Nel menu in alto a destra dell'utilità di pianificazione, clicca su "Crea attività…".
Nella scheda "Generale" assegna un nome a tua scelta all'attività e imposta l'interruttore in modalità "Esegui per tutti gli utenti".
Vai alla scheda "Azioni", clicca su "Crea". Nel campo "Programma o script" clicca su "Sfoglia", trova il file creato al secondo passo bat e clicca su OK.
Clicca su OK, se necessario inserisci la password del tuo account di sistema operativo.
Troviamo il task creato nel planner, lo selezioniamo e nell'angolo in basso a destra premiamo il pulsante "Esegui".

Il nostro bot è in esecuzione in background e continuerà a funzionare finché non fermerai il task o spegnerai il tuo PC o server su cui è stato avviato.

Conclusione

In questo articolo abbiamo visto come scrivere un bot completo, che non solo può inviare messaggi, ma anche rispondere ai messaggi in arrivo e ai comandi. Le conoscenze acquisite sono già sufficienti per risolvere la maggior parte delle tue esigenze.

Nel prossimo articolo parleremo di come aggiungere una tastiera al bot per un utilizzo più comodo.

Iscriviti al mio telegram e youtube canali.

Fonte: habr.com