Questo è il terzo articolo della serie "Scriviamo un bot telegram in R". Negli articoli precedenti abbiamo imparato a creare un bot telegram, inviare messaggi attraverso di esso, aggiungere comandi e filtri ai messaggi. Pertanto, prima di iniziare a leggere questo articolo, consiglio vivamente di consultare , poiché non mi soffermerò qui sulle basi della creazione di bot descritte in precedenza.
In questo articolo miglioriamo l'usabilità del nostro bot aggiungendo una tastiera, che rende l'interfaccia del bot intuitiva e semplice da usare.
Tutti gli articoli della serie "Scriviamo un bot telegram in R"
Contenuto
Se sei interessato all'analisi dei dati, potresti trovare interessanti i miei e canali. Gran parte del contenuto è dedicato al linguaggio R.
3.1.
3.2.
3.3.
Quali tipi di tastiere supporta il bot telegram
Al momento della scrittura di questo articolo telegram.bot ti consente di creare tastiere di due tipi:
- Reply — Tastiera principale, normale, che si trova sotto il campo di immissione del messaggio. Questa tastiera invia semplicemente un messaggio di testo al bot e invia, come testo, il testo scritto sul pulsante stesso.
- Inline — Tastiera associata a un messaggio specifico del bot. Questa tastiera invia al bot dati legati al pulsante premuto; questi dati possono differire dal testo scritto sul pulsante stesso. E questi pulsanti sono elaborati tramite CallbackQueryHandler.
Per aprire la tastiera, il bot deve ricevere il messaggio tramite il metodo sendMessage(), passando la tastiera creata in precedenza come argomento reply_markup.
Di seguito esamineremo alcuni esempi.
Tastiera Reply
Come ho già scritto sopra, questa è la tastiera principale per controllare il bot.
Esempio di creazione di una tastiera Reply dalla documentazione ufficiale
bot <- Bot(token = "TOKEN")
chat_id <- "CHAT_ID"
# Crea una tastiera personalizzata
text <- "Non sono quelle tastiere personalizzate fantastiche?"
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Sì, lo sono sicuramente!")),
list(KeyboardButton("Non ne sono sicuro")),
list(KeyboardButton("No..."))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# Invia la tastiera personalizzata
bot$sendMessage(chat_id, text, reply_markup = RKM)Sopra è fornito un esempio dalla documentazione ufficiale del pacchetto telegram.bot. Per creare una tastiera si utilizza la funzione ReplyKeyboardMarkup(), che a sua volta accetta un elenco di elenchi di pulsanti, che vengono creati dalla funzione KeyboardButton().
Perché in ReplyKeyboardMarkup() è necessario passare non solo un elenco, ma un elenco di elenchi? La questione è che si passa un elenco principale, e in esso si definiscono singolarmente ciascuna riga di pulsanti, poiché in una riga possono essere posizionati più pulsanti.
Argomento resize_keyboard permette di adattare automaticamente le dimensioni ottimali dei pulsanti della tastiera, e l'argomento one_time_keyboard consente di nascondere la tastiera dopo ogni pressione su un pulsante.
Scriviamo un semplice bot che avrà 3 pulsanti:
- Chat ID - Richiedi l'ID chat del dialogo con il bot
- Il mio nome - Richiedi il proprio nome
- Il mio username - Richiedi il proprio nome utente su Telegram
Codice 1: Bot semplice con tastiera Reply
library(telegram.bot)
# creiamo un'istanza della classe Updater
updater <- Updater('IL TOKEN DEL VOSTRO BOT')
# creiamo i metodi
## metodo per avviare la tastiera
start <- function(bot, update) {
# creiamo la tastiera
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Chat ID")),
list(KeyboardButton("Il mio nome")),
list(KeyboardButton("Il mio username"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# inviamo la tastiera
bot$sendMessage(update$message$chat_id,
text = 'Seleziona un comando',
reply_markup = RKM)
}
## metodo che restituisce l'id della chat
chat_id <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("L'id della chat di questo dialogo: ", update$message$chat_id),
parse_mode = "Markdown")
}
## metodo che restituisce il nome
my_name <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Il tuo nome è ", update$message$from$first_name),
parse_mode = "Markdown")
}
## metodo che restituisce lo username
my_username <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Il tuo username è ", update$message$from$username),
parse_mode = "Markdown")
}
# creiamo i filtri
## messaggi con il testo Chat ID
MessageFilters$chat_id <- BaseFilter(function(message) {
# controlliamo il testo del messaggio
message$text == "Chat ID"
}
)
## messaggi con il testo Il mio nome
MessageFilters$name <- BaseFilter(function(message) {
# controlliamo il testo del messaggio
message$text == "Il mio nome"
}
)
## messaggi con il testo Il mio username
MessageFilters$username <- BaseFilter(function(message) {
# controlliamo il testo del messaggio
message$text == "Il mio username"
)
# creiamo i gestori
h_start <- CommandHandler('start', start)
h_chat_id <- MessageHandler(chat_id, filters = MessageFilters$chat_id)
h_name <- MessageHandler(my_name, filters = MessageFilters$name)
h_username <- MessageHandler(my_username, filters = MessageFilters$username)
# aggiungiamo i gestori al dispatcher
updater <- updater +
h_start +
h_chat_id +
h_name +
h_username
# 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 ).
Dopo l'avvio, dai al bot il comando /start, poiché è quello che abbiamo definito per avviare la tastiera.
Se al momento hai difficoltà a comprendere l'esempio di codice sopra, con la creazione di metodi, filtri e gestori, è opportuno tornare all' , in cui ho descritto tutto in dettaglio.
Abbiamo creato 4 metodi:
- start — Avvio della tastiera
- chat_id — Richiesta dell'id della chat
- my_name — Richiesta del proprio nome
- my_username — Richiesta del proprio username
Nell'oggetto MessageFilters abbiamo aggiunto 3 filtri per i messaggi in base al loro testo:
- chat_id — Messaggi con testo
"ID chat" - name — Messaggi con testo
"Il mio nome" - username — Messaggi con testo
"Il mio login"
E sono stati creati 4 gestori che eseguiranno i metodi specificati in base ai comandi e ai filtri forniti.
# создаём обработчики
h_start <- CommandHandler('start', start)
h_chat_id <- MessageHandler(chat_id, filters = MessageFilters$chat_id)
h_name <- MessageHandler(my_name, filters = MessageFilters$name)
h_username <- MessageHandler(my_username, filters = MessageFilters$username)La tastiera stessa viene creata all'interno del metodo start() comando ReplyKeyboardMarkup().
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("ID chat")),
list(KeyboardButton("Il mio nome")),
list(KeyboardButton("Il mio login"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)Nel nostro caso, tutti i pulsanti sono stati disposti uno sotto l'altro, ma possiamo disporli in un'unica fila, modificando la lista di liste dei pulsanti. Poiché una fila all'interno della tastiera viene creata tramite una lista annidata di pulsanti, per visualizzare i nostri pulsanti in un'unica fila dobbiamo riscrivere parte del codice che costruisce la tastiera in questo modo:
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("ID chat"),
KeyboardButton("Il mio nome"),
KeyboardButton("Il mio login")
)
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
La tastiera viene inviata nella chat tramite il metodo sendMessage(), nell'argomento reply_markup.
bot$sendMessage(update$message$chat_id,
text = 'Seleziona un comando',
reply_markup = RKM)Tastiera Inline
Come già detto, la tastiera Inline è legata a un messaggio specifico. Lavorarci è un po' più complicato rispetto alla tastiera principale.
Inizialmente, è necessario aggiungere un metodo al bot per richiamare la tastiera Inline.
Per rispondere alla pressione del pulsante Inline, è possibile utilizzare anche il metodo del bot answerCallbackQuery(), che può visualizzare una notifica nell'interfaccia di telegram, all'utente che ha premuto il pulsante Inline.
I dati inviati tramite il pulsante Inline non sono testo, quindi per elaborarli è necessario creare un gestore speciale con il comando CallbackQueryHandler().
Il codice per costruire la tastiera Inline che viene fornito nella documentazione ufficiale del pacchetto telegram.bot.
Il codice per costruire la tastiera Inline dalla documentazione ufficiale
# Initialize bot
bot <- Bot(token = "TOKEN")
chat_id <- "CHAT_ID"
# Create Inline Keyboard
text <- "Could you type their phone number, please?"
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton(1),
InlineKeyboardButton(2),
InlineKeyboardButton(3)
),
list(
InlineKeyboardButton(4),
InlineKeyboardButton(5),
InlineKeyboardButton(6)
),
list(
InlineKeyboardButton(7),
InlineKeyboardButton(8),
InlineKeyboardButton(9)
),
list(
InlineKeyboardButton("*"),
InlineKeyboardButton(0),
InlineKeyboardButton("#")
)
)
)
# Send Inline Keyboard
bot$sendMessage(chat_id, text, reply_markup = IKM)La tastiera Inline deve essere costruita utilizzando il comando InlineKeyboardMarkup(), seguendo lo stesso principio della tastiera di risposta. In InlineKeyboardMarkup() deve essere passato un elenco, liste di pulsanti Inline, ogni singolo pulsante viene creato dalla funzione InlineKeyboardButton().
Il pulsante Inline può either trasmettere dati al bot utilizzando l'argomento callback_data, oppure aprire una pagina HTML qualsiasi specificata tramite l'argomento url.
Il risultato sarà un elenco, in cui ogni elemento è anch'esso un elenco di pulsanti Inline, che devono essere uniti in un'unica fila.
In seguito, esamineremo alcuni esempi di bot con pulsanti Inline.
Esempio di un semplice bot con supporto per pulsanti InLine
Per iniziare, scriveremo un bot per il test rapido per covid-19. Al comando /test, invierà una tastiera con due pulsanti; a seconda del pulsante premuto, ti invierà un messaggio con i risultati del tuo test.
Codice 2: Bot semplice con tastiera Inline
library(telegram.bot)
# creiamo un'istanza della classe Updater
updater <- Updater('IL TOKEN DEL TUO BOT')
# metodo per inviare una tastiera InLine
test <- function(bot, update) {
# creiamo la tastiera InLine
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton("Sì", callback_data = 'yes'),
InlineKeyboardButton("No", callback_data = 'no')
)
)
)
# Inviamo la tastiera nella chat
bot$sendMessage(update$message$chat_id,
text = "Sei positivo al coronavirus?",
reply_markup = IKM)
}
# metodo per gestire la pressione del pulsante
answer_cb <- function(bot, update) {
# dati ricevuti dal pulsante
data <- update$callback_query$data
# otteniamo il nome utente che ha premuto il pulsante
uname <- update$effective_user()$first_name
# elaborazione del risultato
if ( data == 'no' ) {
msg <- paste0(uname, ", congratulazioni, il tuo test per covid-19 è negativo.")
} else {
msg <- paste0(uname, ", sfortunatamente il tuo test per covid-19 è positivo.")
}
# Invio del messaggio
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# informiamo il bot che la richiesta dal pulsante è stata ricevuta
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# creiamo i gestori
inline_h <- CommandHandler('test', test)
query_handler <- CallbackQueryHandler(answer_cb)
# aggiungiamo i gestori al dispatcher
updater <- updater + inline_h + query_handler
# 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 ).
Risultato:
Abbiamo creato due metodi:
- test — Per inviare la tastiera Inline nella chat
- answer_cb — Per elaborare i dati inviati dalla tastiera.
I dati che verranno inviati con ogni pulsante sono specificati nell'argomento callback_data, durante la creazione del pulsante. I dati inviati dal pulsante possono essere ottenuti tramite la costruzione update$callback_query$data, all'interno del metodo answer_cb.
Affinché il bot risponda alla tastiera Inline, il metodo answer_cb viene gestito da un gestore speciale: CallbackQueryHandler(answer_cb). Che esegue il metodo specificato al tocco del pulsante Inline. Il gestore CallbackQueryHandler accetta due argomenti:
callback— Il metodo che deve essere avviatopattern— Filtro sui dati legati al pulsante tramite l'argomentocallback_data.
Di conseguenza, tramite l'argomento pattern possiamo scrivere un metodo separato per ogni pulsante premuto:
Codice 3: Separiamo i metodi per ogni pulsante Inline
library(telegram.bot)
# creiamo un'istanza della classe Updater
updater <- Updater('IL TOKEN DEL VOSTRO BOT')
# metodo per inviare una tastiera InLine
test <- function(bot, update) {
# creiamo la tastiera InLine
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton("Sì", callback_data = 'yes'),
InlineKeyboardButton("No", callback_data = 'no')
)
)
)
# Inviamo la tastiera nella chat
bot$sendMessage(update$message$chat_id,
text = "Hai il coronavirus?",
reply_markup = IKM)
}
# metodo per gestire la pressione del pulsante Sì
answer_cb_yes <- function(bot, update) {
# otteniamo il nome utente che ha premuto il pulsante
uname <- update$effective_user()$first_name
# elaborazione del risultato
msg <- paste0(uname, ", purtroppo il tuo test per il covid-19 è positivo.")
# Invio del messaggio
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# informiamo il bot che la richiesta dal pulsante è stata accettata
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# metodo per gestire la pressione del pulsante No
answer_cb_no <- function(bot, update) {
# otteniamo il nome utente che ha premuto il pulsante
uname <- update$effective_user()$first_name
msg <- paste0(uname, ", congratulazioni, il tuo test per il covid-19 è negativo.")
# Invio del messaggio
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# informiamo il bot che la richiesta dal pulsante è stata accettata
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# creiamo i gestori
inline_h <- CommandHandler('test', test)
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')
# aggiungiamo i gestori al dispatcher
updater <- updater +
inline_h +
query_handler_yes +
query_handler_no
# 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 ).
Ora abbiamo scritto 2 metodi separati, ovvero uno per ciascun pulsante, e abbiamo utilizzato l'argomento pattern, nella creazione dei loro gestori:
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')Il codice del metodo termina answer_cb comando bot$answerCallbackQuery(callback_query_id = update$callback_query$id), che informa il bot che i dati dalla tastiera inline sono stati ricevuti.
Esempio di un bot che riporta la meteo attuale per la città scelta
Proviamo a scrivere un bot che richiede dati sul tempo.
La logica del suo funzionamento sarà la seguente. Inizialmente, con il comando /start si chiama la tastiera principale, nella quale è presente solo un pulsante "Tempo". Premendo questo pulsante, si riceve un messaggio con una tastiera Inline, per selezionare la città di cui si desidera conoscere il tempo attuale. Si sceglie una delle città e si riceve il tempo attuale.
In questo esempio di codice utilizzeremo diversi pacchetti aggiuntivi:
httr— pacchetto per lavorare con le richieste HTTP, su cui si basa il funzionamento di qualsiasi API. Nel nostro caso utilizzeremo un'API gratuita .stringr— pacchetto per lavorare con il testo, che nel nostro caso useremo per formare un messaggio sul meteo nella città scelta.
Codice 4: Un bot che comunica il meteo attuale nella città selezionata
library(telegram.bot)
library(httr)
library(stringr)
# creiamo un'istanza della classe Updater
updater <- Updater('IL TOKEN DEL TUO BOT')
# creiamo i metodi
## metodo per avviare la tastiera principale
start <- function(bot, update) {
# creiamo la tastiera
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Meteo")
)
),
resize_keyboard = TRUE,
one_time_keyboard = TRUE
)
# inviamo la tastiera
bot$sendMessage(update$message$chat_id,
text = 'Seleziona un comando',
reply_markup = RKM)
}
## Metodo per chiamare la tastiera Inline
weather <- function(bot, update) {
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton(text = 'Mosca', callback_data = 'New York,us'),
InlineKeyboardButton(text = 'San Pietroburgo', callback_data = 'Saint Petersburg'),
InlineKeyboardButton(text = 'New York', callback_data = 'New York')
),
list(
InlineKeyboardButton(text = 'Ekaterinburg', callback_data = 'Yekaterinburg,ru'),
InlineKeyboardButton(text = 'Berlino', callback_data = 'Berlin,de'),
InlineKeyboardButton(text = 'Parigi', callback_data = 'Paris,fr')
),
list(
InlineKeyboardButton(text = 'Roma', callback_data = 'Rome,it'),
InlineKeyboardButton(text = 'Odessa', callback_data = 'Odessa,ua'),
InlineKeyboardButton(text = 'Kiev', callback_data = 'Kyiv,fr')
),
list(
InlineKeyboardButton(text = 'Tokyo', callback_data = 'Tokyo'),
InlineKeyboardButton(text = 'Amsterdam', callback_data = 'Amsterdam,nl'),
InlineKeyboardButton(text = 'Washington', callback_data = 'Washington,us')
)
)
)
# Inviare la tastiera inline
bot$sendMessage(chat_id = update$message$chat_id,
text = "Seleziona una città",
reply_markup = IKM)
}
# metodo per inviare un messaggio sul meteo
answer_cb <- function(bot, update) {
# otteniamo dalla risposta la città
city <- update$callback_query$data
# inviamo la richiesta
ans <- GET('https://api.openweathermap.org/data/2.5/weather',
query = list(q = city,
lang = 'ru',
units = 'metric',
appid = '4776568ccea136ffe4cda9f1969af340'))
# analizziamo la risposta
result <- content(ans)
# formiamo il messaggio
msg <- str_glue("{result$name} meteo:n",
"Temperatura attuale: {result$main$temp}n",
"Velocità del vento: {result$wind$speed}n",
"Descrizione: {result$weather[[1]]$description}")
# inviamo le informazioni sul meteo
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# creiamo i filtri
## messaggi con il testo Meteo
MessageFilters$weather <- BaseFilter(function(message) {
# controlliamo il testo del messaggio
message$text == "Meteo"
}
)
# creiamo i gestori
h_start <- CommandHandler('start', start)
h_weather <- MessageHandler(weather, filters = MessageFilters$weather)
h_query_handler <- CallbackQueryHandler(answer_cb)
# aggiungiamo i gestori al dispatcher
updater <- updater +
h_start +
h_weather +
h_query_handler
# 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 ).
Di conseguenza, il nostro bot funzionerà più o meno così:
Schematizzando, questo bot può essere rappresentato in questo modo:
Abbiamo creato 3 metodi disponibili all'interno del nostro bot del meteo:
- start — Avvio della tastiera principale del bot
- weather — Avvio della tastiera Inline per la selezione della città
- answer_cb — Metodo principale che, data una città specificata, interroga l'API per il meteo e invia i dati nella chat.
Sanitizer.replaceElementWithChildren() start Viene avviato con il comando /start, implementato con il gestore CommandHandler('start', start).
Per avviare il metodo weather abbiamo creato un filtro con lo stesso nome:
# создаём фильтры
## сообщения с текстом Погода
MessageFilters$weather <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Погода"
}
)E chiamiamo questo metodo con il seguente gestore dei messaggi: MessageHandler(weather, filters = MessageFilters$weather).
E infine, il nostro metodo principale answer_cb reagisce alla pressione dei pulsanti Inline, implementato con un gestore speciale: CallbackQueryHandler(answer_cb).
All'interno del metodo answer_cb, leggiamo i dati inviati dalla tastiera e li registriamo in una variabile city: city <- update$callback_query$data. Dopodiché, interroghiamo l'API per ottenere i dati sul meteo, formiamo e inviamo un messaggio e, infine, usiamo il metodo answerCallbackQuery per notificare al bot che abbiamo elaborato la pressione del pulsante Inline.
Un esempio di bot che visualizza un elenco degli articoli più recenti con collegamenti per il Hub specificato da .
Riporto questo bot per mostrarti come visualizzare i pulsanti Inline che rimandano a pagine web.
La logica di questo bot è simile alla precedente, all'inizio avviamo la tastiera principale con il comando /start. Dopo di che, il bot ci offre una selezione di 6 hub, scegliamo l'hub di nostro interesse e otteniamo le 5 pubblicazioni più recenti dall'hub selezionato.
Come puoi capire, in questo caso è necessario ottenere un elenco di articoli e per questo utilizzeremo un pacchetto speciale habR, che consente di richiedere articoli dalla habra e alcune statistiche su di essi in R.
Puoi installare il pacchetto habR solo da github, per questo avrai bisogno di un pacchetto aggiuntivo devtools. Per installarlo, utilizza il codice seguente.
install.packages('devtools')
devtools::install_github('selesnow/habR')Ora esaminiamo il codice per costruire il bot descritto sopra:
Codice 5: Bot che visualizza un elenco degli articoli più freschi per l'hub selezionato
library(telegram.bot)
library(habR)
# creiamo un'istanza della classe Updater
updater <- Updater('IL TOKEN DEL TUO BOT')
# creiamo i metodi
## metodo per avviare la tastiera principale
start <- function(bot, update) {
# creiamo la tastiera
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Elenco articoli")
)
),
resize_keyboard = TRUE,
one_time_keyboard = TRUE
)
# inviamo la tastiera
bot$sendMessage(update$message$chat_id,
text = 'Seleziona un comando',
reply_markup = RKM)
}
## Metodo per la tastiera Inline
habs <- function(bot, update) {
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton(text = 'R', callback_data = 'R'),
InlineKeyboardButton(text = 'Data Mining', callback_data = 'data_mining'),
InlineKeyboardButton(text = 'Data Engineering', callback_data = 'data_engineering')
),
list(
InlineKeyboardButton(text = 'Big Data', callback_data = 'bigdata'),
InlineKeyboardButton(text = 'Python', callback_data = 'python'),
InlineKeyboardButton(text = 'Visualizzazione dati', callback_data = 'data_visualization')
)
)
)
# Invia la Tastiera Inline
bot$sendMessage(chat_id = update$message$chat_id,
text = "Seleziona un Hub",
reply_markup = IKM)
}
# metodo per il messaggio del tempo
answer_cb <- function(bot, update) {
# ricaviamo dalla messaggio la città
hub <- update$callback_query$data
# messaggio che informa che i dati sono stati ricevuti
bot$answerCallbackQuery(callback_query_id = update$callback_query$id,
text = 'Attendere qualche minuto, la richiesta viene elaborata')
# messaggio che informa di attendere mentre il bot recupera i dati
mid <- bot$sendMessage(chat_id = update$from_chat_id(),
text = "Attendere qualche minuto mentre raccoglierò i dati dall'Hub selezionato")
# facciamo il parsing di Habr
posts <- head(habr_hub_posts(hub, 1), 5)
# eliminiamo il messaggio che chiede di attendere
bot$deleteMessage(update$from_chat_id(), mid$message_id)
# formiamo l'elenco dei pulsanti
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# formiamo la tastiera
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)
# inviamo le informazioni sul tempo
bot$sendMessage(chat_id = update$from_chat_id(),
text = paste0("5 articoli più recenti dall'Hub ", hub),
reply_markup = IKM)
}
# creiamo i filtri
## messaggi con il testo Tempo
MessageFilters$hubs <- BaseFilter(function(message) {
# verifichiamo il testo del messaggio
message$text == "Elenco articoli"
}
)
# creiamo i gestori
h_start <- CommandHandler('start', start)
h_hubs <- MessageHandler(habs, filters = MessageFilters$hubs)
h_query_handler <- CallbackQueryHandler(answer_cb)
# aggiungiamo i gestori al dispatcher
updater <- updater +
h_start +
h_hubs +
h_query_handler
# 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 ).
Alla fine, otterremo un risultato simile a questo:
L'elenco degli Hub disponibili per la selezione è stato inserito in modo hardcoded nel metodo habs:
## Метод вызова Inine клавиатуры
habs <- function(bot, update) {
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton(text = 'R', callback_data = 'r'),
InlineKeyboardButton(text = 'Data Mining', callback_data = 'data_mining'),
InlineKeyboardButton(text = 'Data Engineering', callback_data = 'data_engineering')
),
list(
InlineKeyboardButton(text = 'Big Data', callback_data = 'bigdata'),
InlineKeyboardButton(text = 'Python', callback_data = 'python'),
InlineKeyboardButton(text = 'Визуализация данных', callback_data = 'data_visualization')
)
)
)
# Send Inline Keyboard
bot$sendMessage(chat_id = update$message$chat_id,
text = "Выберите Хаб",
reply_markup = IKM)
}L'elenco degli articoli dall'Hub specificato lo otteniamo con il comando habr_hub_posts(), dal pacchetto habR. In questo caso specifichiamo che non ci serve l'elenco degli articoli per tutto il tempo, ma solo la prima pagina in cui sono presenti 20 articoli. Dalla tabella ottenuta, con il comando head() , lasciamo solo i 5 articoli più in alto, che sono anche i più recenti.
# парсим Хабр
posts <- head(habr_hub_posts(hub, 1), 5)La logica è molto simile a quella del bot precedente, ma in questo caso generiamo dinamicamente la tastiera Inline con l'elenco degli articoli tramite la funzione lapply().
# формируем список кнопок
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# формируем клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)Nel testo del pulsante inseriamo il titolo dell'articolo posts$title[x], e nell'argomento url il link all'articolo: url = posts$link[x].
Dopodiché, creiamo un filtro, i gestori e avviamo il nostro bot.
Conclusione
Ora i bot che hai scritto saranno significativamente più facili da gestire, dato che il controllo avverrà tramite la tastiera e non con l'inserimento di comandi. Almeno quando interagisci con il bot tramite uno smartphone, la tastiera semplificherà notevolmente il processo di utilizzo.
Nell'articolo successivo vedremo come costruire un dialogo logico con il bot e lavorare con i database.
Fonte: habr.com
