In pubblicazione precedente abbiamo capito come creare un bot, inizializzato un'istanza della classe Bot e ci siamo familiarizzati con i metodi per inviare messaggi tramite di esso.

In questo articolo continuo questo tema, quindi consiglio di iniziare a leggere questo articolo solo dopo aver letto prima parte.

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

Nel corso dell'articolo scriveremo diversi bot semplici, l'ultimo determinerà se il giorno in un determinato paese è festivo o lavorativo in base al calendario aziendale, a una data e a un codice di paese specificati. Ma, come prima, lo scopo dell'articolo è introdurvi all'interfaccia del pacchetto telegram.bot per risolvere i vostri problemi.

Tutti gli articoli della serie "Scriviamo un bot telegram in R"

Contenuto

Se sei interessato all'analisi dei dati, potresti trovare interessanti i miei telegram e youtube canali. Gran parte del contenuto è dedicato al linguaggio R.

La 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 modalità background
Conclusione

La classe Updater

Updater — è una classe che semplifica lo sviluppo del bot Telegram e utilizza sotto il cofano la classe Dispetcher. Lo scopo della classe Updater è quello di ricevere aggiornamenti dal bot (nell'articolo precedente abbiamo utilizzato a questo scopo il metodo getUpdates()), e passarli successivamente a Dispetcher.

A sua volta Dispetcher contiene i gestori che avete creato, cioè oggetti della classe Handler.

Handlers — gestori

Con l'aiuto dei gestori aggiungete a Dispetcher 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 avete mai utilizzato bot prima d'ora e non sapete cosa sia un comando, dovete inviare i comandi al bot utilizzando una barra inclinata

Aggiungiamo il primo comando al bot, gestore dei comandi

come prefisso. / Cominceremo con comandi semplici, cioè insegneremo al nostro bot a salutare su comando

Codice 1: Insegniamo al bot a salutare /hi.

Codice 1: Insegniamo al bot a salutare

library(telegram.bot)

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

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

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

  # Invia il messaggio di benvenuto
  bot$sendMessage(update$message$chat_id, 
                  text = paste0("I miei saluti, ", user_name, "!"), 
                  parse_mode = "Markdown")

}

# creiamo un gestore di comandi
hi_hendler <- CommandHandler('hi', say_hello)

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

# avviamo il bot
updater$start_polling()

Esegui l'esempio di codice qui sopra, sostituendo 'IL TOKEN DEL VOSTRO BOT' con il token reale che hai ricevuto durante la creazione del bot tramite BotFather (di cui ho parlato nella articolo precedente).

Sanitizer.replaceElementWithChildren() start_polling() classe Updater, che alla fine del codice avvia un ciclo infinito di richiesta e elaborazione degli aggiornamenti dal bot.

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

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

Il processo di creazione di un bot così semplice può essere schematicamente rappresentato nel seguente modo.

Creiamo un'istanza della classe Updater;
Creiamo i metodi, ovvero le funzioni che il nostro bot eseguirà. Nel codice di esempio, questa funzione è say_hello(). Le funzioni che utilizzerai come metodi del bot devono avere due argomenti obbligatori — bot e aggiornamento, e uno facoltativo — args. L'argomento bot, è il tuo bot, con il quale puoi rispondere ai messaggi, inviare messaggi o utilizzare qualsiasi altro metodo disponibile per il bot. L'argomento aggiornamento è ciò che il bot ha ricevuto dall'utente, in sostanza, ciò che ottenevamo nel primo articolo tramite il metodo getUpdates(). L'argomento args ti consente di elaborare dati aggiuntivi inviati dall'utente insieme al comando, torneremo su questo argomento un po' più tardi;
Creiamo gestori, cioè colleghiamo determinate azioni dell'utente con i metodi creati nel passaggio precedente. Essenzialmente, un gestore è un trigger, un evento che chiama una determinata funzione del bot. Nel nostro esempio, 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 il bot risponderà. Il secondo argomento permette di indicare il metodo del bot, chiameremo il metodo say_hello, che verrà eseguito se l'utente invoca il comando specificato nel primo argomento;
Successivamente, aggiungiamo il gestore creato al dispatcher della nostra istanza della classe Updater. È possibile aggiungere gestori in diversi modi, nel esempio sopra ho utilizzato il modo più semplice, tramite il segno +, cioè. updater <- updater + hi_hendler. Lo stesso può essere fatto utilizzando il metodo add_handler(), che appartiene alla classe Dispatcher, questo metodo può essere trovato così: updater$dispatcher$add_handler();
Avviamo il bot con il comando start_polling().

Gestore dei messaggi di testo e filtri

Abbiamo capito come inviare comandi al bot, ma a volte abbiamo bisogno che il bot reagisca non solo ai comandi, ma anche a messaggi di testo normali. Per fare ciò, è necessario utilizzare gestori di messaggi — MessageHandler.

Normale MessageHandler reagirà a tutti i messaggi in entrata. Pertanto, spesso 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, salve, saluto, hi, bonjour.

Per ora non scriveremo nuovi metodi, poiché abbiamo già un metodo con il quale il bot ci saluta. Dobbiamo solo creare il filtro necessario e il gestore di messaggi.

Codice 2: Aggiungiamo un gestore di messaggi di testo e un filtro

library(telegram.bot)

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

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

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

  # Inviamo un messaggio di saluto
  bot$sendMessage(update$message$chat_id, 
                  text = paste0("Il mio rispetto, ", 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 appaiono le parole: ciao, salve, saluto, hi, bonjour
  grepl(x = message$text, 
        pattern = 'ciao|salve|saluto|hi|bonjour',
        ignore.case = TRUE)
  }
)

# creiamo il 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 qui sopra, sostituendo 'IL TOKEN DEL VOSTRO BOT' con il token reale che hai ricevuto durante la creazione del bot tramite BotFather (di cui ho parlato nella articolo precedente).

Adesso proviamo a inviare al bot alcuni messaggi in cui compaiono le parole di saluto elencate in precedenza:

Quindi, innanzitutto abbiamo insegnato al bot non solo a salutare, ma a rispondere al saluto. Lo abbiamo fatto utilizzando l'argomento reply_to_message_id, disponibile nel metodo sendMessage(), nel quale è necessario passare 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 inizialmente ha già un piccolo insieme di filtri pronti. Nel nostro esempio, nell'oggetto MessageFilters abbiamo aggiunto un elemento hi, questo è un nuovo filtro.

Nella funzione BaseFilter() è necessario passare la funzione di filtro. Fondamentalmente, un filtro è semplicemente una funzione che riceve un'istanza del messaggio e restituisce TRUE o FALSE. Nel nostro esempio, abbiamo scritto la funzione più semplice, che utilizza la funzione di base grepl() per verificare il testo del messaggio e, se corrisponde all'espressione regolare ciao|salve|saluti|hey|bonjour false, se l'elemento da sostituire è TRUE.

In seguito, creiamo un gestore di messaggi hi_txt_hnd <- MessageHandler(say_hello, filters = MessageFilters$hi). Il primo argomento della funzione MessageHandler() è il metodo che invocherà il gestore, mentre il secondo argomento è il filtro in base al quale sarà richiamato. Nel nostro caso, è il filtro che abbiamo creato MessageFilters$hi.

E quindi, alla fine, aggiungiamo al dispatcher 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 testuali
command — Comandi, cioè messaggi che iniziano con /
reply — Messaggi che sono risposte a 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 Telegram
location — Messaggi con geolocalizzazione
venue — Messaggi inoltrati
game — Giochi

Se desideri combinare alcuni filtri in un unico gestore, usa semplicemente il segno | — come logico O, e il segno & come logico E. Ad esempio, se desideri che il bot invochi lo stesso metodo quando riceve un video, un'immagine o un documento, utilizza il seguente esempio per creare un gestore di messaggi:

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

Aggiunta di comandi con parametri

Sappiamo già cosa sono i comandi, come crearli e come far eseguire al bot il comando desiderato. Tuttavia, in alcuni casi, oltre al nome del comando, è necessario fornire 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 riportato qui sotto utilizza l'API del calendario lavorativo isdayoff.ru.

Codice 3: Bot che informa sulla data e sul paese

library(telegram.bot)

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

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

  # dati in ingresso
  day <- args[1]  # data
  country <- args[2]  # paese

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

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

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

  }

  # paese per la verifica
  ## controlliamo se è stato fornito il paese
  ## se non è fornito impostiamo ru
  if ( ! country %in% c('ru', 'ua', 'by', 'kz', 'us') ) {

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

    country <- 'ru'

  }

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

  # otteniamo la risposta
  res <- readLines(url)

  # interpretazione della risposta
  out <- switch(res, 
                "0" = "Giorno lavorativo",
                "1" = "Giorno non lavorativo",
                "2" = "Giornata lavorativa ridotta",
                "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(day, " - ", 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 qui sopra, sostituendo 'IL TOKEN DEL VOSTRO BOT' con il token reale che hai ricevuto durante la creazione del bot tramite BotFather (di cui ho parlato nella articolo precedente).

Abbiamo creato un bot che ha solo un metodo nel suo arsenale check_date, questo metodo viene chiamato con il comando omonimo.

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

Affinché il metodo che stiamo creando accetti parametri aggiuntivi insieme al comando, utilizza l'argomento pass_args = TRUE nella funzione CommandHandler(), e quando crei il metodo, oltre agli argomenti obbligatori bot, aggiornamento crea un opzionale — args. Il metodo creato in questo modo accetterà i parametri che invii al bot dopo il nome del comando. I parametri devono essere separati da uno spazio, e nel metodo arriveranno come un vettore di testo.

Avviamo e testiamo il nostro bot.

Avviamo il bot in modalità background

L'ultimo passo che dobbiamo compiere è avviare il bot in modalità background.

Per farlo, segui l'algoritmo descritto di seguito:

Salva il codice del bot in un file con estensione R. Quando lavori in RStudio, questo si fa tramite il menu File, con il comando Salva con nome….
Aggiungi il percorso della cartella bin, che a sua volta si trova nella cartella in cui hai installato il linguaggio R alla variabile Path, istruzioni qui.
Crea un normale file di testo, in cui scrivere una riga: R CMD BATCH C:UsersAlseyDocumentsmy_bot.R. Invece di C:UsersAlseyDocumentsmy_bot.R scrivi il percorso del tuo script del bot. È importante che nel percorso non ci siano caratteri cirillici e spazi, poiché ciò potrebbe causare problemi all'avvio del bot. Salvalo, e cambia l'estensione da txt in bat.
Apri il pianificatore delle attività di Windows, ci sono molti modi per farlo, ad esempio apri qualsiasi cartella e inserisci nell'indirizzo %windir%system32taskschd.msc /s. Altri modi per avviarlo possono essere trovati qui.
Nel menu in alto a destra del pianificatore, fai clic su "Crea attività…".
Nella scheda "Generale", assegna un nome arbitrario alla tua attività, e sposta l'interruttore in stato "Eseguire per tutti gli utenti".
Vai alla scheda "Azioni", fai clic su "Crea". Nel campo "Programma o script" fai clic su "Sfoglia", trova il file creato al secondo passaggio bat , e fai clic su OK.
Fai clic su OK, e se necessario, inserisci la password del tuo account di sistema operativo.
Trova nel pianificatore l'attività creata, selezionala e nell'angolo in basso a destra fai clic sul pulsante "Esegui".

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

Conclusione

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

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

Iscriviti al mio telegram e youtube canali.

Fonte: habr.com