Aceasta este a treia articol din seria "Scriem un bot Telegram în limbajul R". În publicațiile anterioare am învățat cum să creăm un bot Telegram, să trimitem mesaje prin el, am adăugat comenzi și filtre pentru mesaje. De aceea, înainte de a începe să citiți acest articol, vă recomand cu căldură să consultați , deoarece aici nu voi mai detalia fundamentele discutate anterior despre construirea boturilor.
În acest articol vom îmbunătăți utilizarea botului nostru prin adăugarea unei tastaturi, care va face interfața botului intuitivă și ușor de utilizat.
Toate articolele din seria "Scriem un bot Telegram în limbajul R"
Cuprins
Dacă sunteți interesat de analiza datelor, s-ar putea să vă intereseze canalele mele. și Marea parte a conținutului lor este dedicată limbajului R.
3.1.
3.2.
3.3.
Ce tipuri de tastaturi suportă botul Telegram
La momentul redactării articolului telegram.bot permite să creați tastaturi de două tipuri:
- Reply — Tastatura principală, obișnuită, care se află sub panoul de introducere a textului mesajului. Această tastatură pur și simplu trimite botului un mesaj text, iar ca text va trimite textul scris pe butonul însuși.
- Inline — Tastatura legată de un mesaj specific al botului. Această tastatură trimite botului datele legate de butonul apăsat, aceste date pot fi diferite de textul scris pe butonul propriu-zis. Și butoanele sunt procesate prin CallbackQueryHandler.
Pentru ca botul să deschidă tastatura, este necesar să trimiteți mesaj prin metoda sendMessage(), trecând tastatura creată anterior ca argument reply_markup.
Mai jos vom analiza câteva exemple.
Tastatura Reply
Așa cum am menționat mai sus, aceasta este tastatura principală de control a botului.
Exemplu de creare a unei tastaturi Reply din documentația oficială
bot <- Bot(token = "TOKEN")
chat_id <- "CHAT_ID"
# Creați Tastatura Personalizată
text <- "Nu sunt acestea tastaturile personalizate cool?"
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Da, cu siguranță sunt!")),
list(KeyboardButton("Nu sunt chiar sigur")),
list(KeyboardButton("Nu..."))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# Trimiteți Tastatura Personalizată
bot$sendMessage(chat_id, text, reply_markup = RKM)Mai sus este un exemplu din documentația oficială a pachetului telegram.bot. Pentru a crea tastatura este utilizată funcția ReplyKeyboardMarkup(), care la rândul său acceptă o listă de liste de butoane, care sunt create prin funcție. KeyboardButton().
De ce în ReplyKeyboardMarkup() este necesar să trimitem nu doar o listă, ci o listă de liste? Motivele sunt că trimiteți lista principală, iar în aceasta, lista separată definește fiecare rând de butoane, deoarece într-un rând pot fi dispuse mai multe butoane.
Argumentul resize_keyboard permite ajustarea automată a dimensiunii optime a butoanelor tastaturii, iar argumentul one_time_keyboard permite ascunderea tastaturii după fiecare apăsare a unui buton.
Să scriem un bot simplu, care va avea 3 butoane:
- ID chat - Solicită ID-ul dialogului cu botul
- Numele meu - Solicită numele tău
- Numele meu de utilizator - Solicită numele de utilizator din Telegram
Cod 1: Bot simplu cu tastatură Reply
library(telegram.bot)
# creăm o instanță a clasei Updater
updater <- Updater('TOKENUL BOTULUI TĂU')
# creăm metode
## metoda pentru a porni tastatura
start <- function(bot, update) {
# creăm tastatura
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("ID chat")),
list(KeyboardButton("Numele meu")),
list(KeyboardButton("Numele meu de utilizator"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# trimitem tastatura
bot$sendMessage(update$message$chat_id,
text = 'Alegeți o comandă',
reply_markup = RKM)
}
## metoda pentru a returna id-ul chat-ului
chat_id <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("ID chat al acestui dialog: ", update$message$chat_id),
parse_mode = "Markdown")
}
## metoda pentru a returna numele
my_name <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Te cheamă ", update$message$from$first_name),
parse_mode = "Markdown")
}
## metoda pentru a returna numele de utilizator
my_username <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Numele tău de utilizator este ", update$message$from$username),
parse_mode = "Markdown")
}
# creăm filtre
## mesaje cu textul ID chat
MessageFilters$chat_id <- BaseFilter(function(message) {
# verificăm textul mesajului
message$text == "ID chat"
}
)
## mesaje cu textul Numele meu
MessageFilters$name <- BaseFilter(function(message) {
# verificăm textul mesajului
message$text == "Numele meu"
}
)
## mesaje cu textul Numele meu de utilizator
MessageFilters$username <- BaseFilter(function(message) {
# verificăm textul mesajului
message$text == "Numele meu de utilizator"
)
# creăm handleri
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)
# adăugăm handlerii în dispatcher
updater <- updater +
h_start +
h_chat_id +
h_name +
h_username
# pornim botul
updater$start_polling()Rulați exemplul de cod de mai sus, înlocuind 'TOKENUL BOTULUI DUMNEAVOASTRĂ' cu token-ul real pe care l-ați primit când ați creat botul prin BotFather (despre crearea botului am vorbit în ).
După ce ați lansat, dați o comandă botului /start, deoarece aceasta este comanda pe care am definit-o pentru a activa tastatura.
Dacă în acest moment vă este dificil să înțelegeți exemplul de cod furnizat, cu metoda, filtrele și handler-urile, ar trebui să reveniți la anteriora , în care am explicat toate acestea în detaliu.
Am creat 4 metode:
- start — Activarea tastaturii
- chat_id — Solicitarea identificatorului de chat
- my_name — Solicitarea numelui dumneavoastră
- my_username — Solicitarea numelui dumneavoastră de utilizator
În obiectul MessageFilters am adăugat 3 filtre de mesaje, după textul acestora:
- chat_id — Mesaje cu textul
"Chat ID" - name — Mesaje cu textul
"Numele meu" - username — Mesaje cu textul
"Numele meu de utilizator"
Și am creat 4 handler-e, care, în funcție de comenzile și filtrele date, vor executa metodele specificate.
# создаём обработчики
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)Tastatura însăși este creată în cadrul metodei start() comanda ReplyKeyboardMarkup().
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Chat ID")),
list(KeyboardButton("Numele meu")),
list(KeyboardButton("Numele meu de utilizator"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)În cazul nostru, toate butoanele au fost așezate unele sub altele, dar le putem aranja într-un singur rând, modificând lista de liste de butoane. Deoarece un rând în interiorul tastaturii este creat printr-o listă înrădăcinată de butoane, pentru a afișa butoanele noastre într-un singur rând trebuie să rescriem o parte din codul pentru construirea tastaturii astfel:
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Chat ID"),
KeyboardButton("Numele meu"),
KeyboardButton("Numele meu de utilizator")
)
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
Tastatura este trimisă în chat prin metoda sendMessage(), în argumentul reply_markup.
bot$sendMessage(update$message$chat_id,
text = 'Alegeți o comandă',
reply_markup = RKM)Tastatura Inline
Așa cum am menționat mai sus, tastatura Inline este legată de un mesaj specific. Lucrul cu ea este puțin mai complicat decât cu tastatura principală.
În primul rând, trebuie să adăugați botului o metodă pentru a apela tastatura Inline.
Pentru a răspunde la apăsarea unui buton Inline, puteți folosi de asemenea metoda botului answerCallbackQuery(), care poate afișa o notificare în interfața telegramă, utilizatorului care a apăsat butonul Inline.
Datele trimise de la butonul Inline nu sunt text, așa că pentru a le prelucra trebuie să creați un handler special folosind comanda CallbackQueryHandler().
Codul pentru construirea tastaturii Inline care este prezentat în documentația oficială a pachetului telegram.bot.
Codul pentru construirea tastaturii Inline din documentația oficială
# 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)Pentru a construi tastatura Inline, este necesară comanda InlineKeyboardMarkup(), pe un principiu similar cu cel al tastaturii Reply. În InlineKeyboardMarkup() trebuie să transmitem o listă, liste de butoane Inline, fiecare buton fiind creat prin funcția InlineKeyboardButton().
Butonul Inline poate fie să transmită date către bot folosind argumentul callback_data, fie să deschidă o pagină HTML, specificată prin argumentul url.
În rezultat, va fi o listă, în care fiecare element este de asemenea o listă de butoane Inline, care trebuie unite într-o singură linie.
În continuare, vom analiza câteva exemple de boți cu butoane Inline.
Exemplu de bot simplu cu suport pentru butoane InLine
Mai întâi, vom scrie un bot pentru testarea rapidă a covid-19. La comanda /test, acesta va trimite o tastatură cu două butoane, iar în funcție de butonul apăsat, va trimite un mesaj cu rezultatele testului dumneavoastră.
Cod 2: Cel mai simplu bot cu tastatură Inline
library(telegram.bot)
# creăm o instanță a clasei Updater
updater <- Updater('TOKENUL BOTULUI DUMNEAVOASTRĂ')
# metodă pentru a trimite tastatura InLine
test <- function(bot, update) {
# creăm tastatura InLine
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton("Da", callback_data = 'yes'),
InlineKeyboardButton("Nu", callback_data = 'no')
)
)
)
# Trimitem tastatura în chat
bot$sendMessage(update$message$chat_id,
text = "Sunteți bolnav de coronavirus?",
reply_markup = IKM)
}
# metodă pentru a procesa apăsarea butonului
answer_cb <- function(bot, update) {
# datele primite de la buton
data <- update$callback_query$data
# obținem numele utilizatorului care a apăsat butonul
uname <- update$effective_user()$first_name
# procesarea rezultatului
if ( data == 'no' ) {
msg <- paste0(uname, ", felicitări, testul dumneavoastră pentru covid-19 este negativ.")
} else {
msg <- paste0(uname, ", din păcate, testul dumneavoastră pentru covid-19 este pozitiv.")
}
# Trimiterea mesajului
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# informăm botul că solicitarea de la buton a fost acceptată
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# creăm handleri
inline_h <- CommandHandler('test', test)
query_handler <- CallbackQueryHandler(answer_cb)
# adăugăm handlerii în dispatcher
updater <- updater + inline_h + query_handler
# lansăm botul
updater$start_polling()Rulați exemplul de cod de mai sus, înlocuind 'TOKENUL BOTULUI DUMNEAVOASTRĂ' cu token-ul real pe care l-ați primit când ați creat botul prin BotFather (despre crearea botului am vorbit în ).
Rezultatul:
Am creat două metode:
- test — Pentru a trimite tastatura Inline în chat
- answer_cb — Pentru a procesa datele trimise de la tastatură.
Datele care vor fi trimise cu fiecare buton sunt specificate în argument. callback_datala crearea butonului. Datele trimise de buton pot fi obținute folosind construcția update$callback_query$data, în interiorul metodei answer_cb.
Pentru ca botul să reacționeze la tastatura Inline, metoda answer_cb este gestionată de un handler special: CallbackQueryHandler(answer_cb). Acesta lansează metoda specificată la apăsarea butonului Inline. Handlerul CallbackQueryHandler primește două argumente:
callback— Metoda care trebuie să fie lansatăpattern— Filtrul pe datele care sunt atașate butonului prin argumentcallback_data.
Prin urmare, folosind argumentul pattern putem scrie o metodă separată pentru fiecare buton apăsat:
Cod 3: Separăm metodele pentru fiecare buton Inline
library(telegram.bot)
# creăm o instanță a clasei Updater
updater <- Updater('TOKENUL BOTULUI TĂU')
# metoda pentru trimiterea tastaturii InLine
test <- function(bot, update) {
# creăm tastatura InLine
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton("Da", callback_data = 'yes'),
InlineKeyboardButton("Nu", callback_data = 'no')
)
)
)
# Trimitem tastatura în chat
bot$sendMessage(update$message$chat_id,
text = "Îți dă coronavirusul?",
reply_markup = IKM)
}
# metoda pentru gestionarea apăsării butonului Da
answer_cb_yes <- function(bot, update) {
# obținem numele utilizatorului care a apăsat butonul
uname <- update$effective_user()$first_name
# gestionarea rezultatului
msg <- paste0(uname, ", din păcate, testul tău pentru covid-19 este pozitiv.")
# Trimiterea mesajului
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# informăm botul că cererea de la buton a fost acceptată
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# metoda pentru gestionarea apăsării butonului Nu
answer_cb_no <- function(bot, update) {
# obținem numele utilizatorului care a apăsat butonul
uname <- update$effective_user()$first_name
msg <- paste0(uname, ", felicitări, testul tău pentru covid-19 este negativ.")
# Trimiterea mesajului
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# informăm botul că cererea de la buton a fost acceptată
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# creăm handleri
inline_h <- CommandHandler('test', test)
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')
# adăugăm handlerii în dispatcher
updater <- updater +
inline_h +
query_handler_yes +
query_handler_no
# lansăm botul
updater$start_polling()Rulați exemplul de cod de mai sus, înlocuind 'TOKENUL BOTULUI DUMNEAVOASTRĂ' cu token-ul real pe care l-ați primit când ați creat botul prin BotFather (despre crearea botului am vorbit în ).
Acum am scris 2 metode separate, adică câte o metodă pentru fiecare buton apăsat, și am folosit argumentul patternla crearea handlerelor lor:
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')Se termină codul metodei answer_cb comanda bot$answerCallbackQuery(callback_query_id = update$callback_query$id), care îi comunică botului că datele de la tastatura inline au fost primite.
Exemplu de bot care anunță vremea curentă pentru orașul selectat
Hai să încercăm să scriem un bot care solicită informații despre vreme.
Logica sa de funcționare va fi următoarea. Inițial, comanda /start invocă tastatura principală, care conține un singur buton "Vreme". Când apeși pe acest buton, primești un mesaj cu o tastatură inline pentru a alege orașul pentru care dorești să afli vremea actuală. Alegi unul dintre orașe și primești informațiile despre vremea curentă.
În acest exemplu de cod, vom folosi câteva pachete suplimentare:
httr— un pachet pentru a lucra cu cererile HTTP, pe baza căruia se construiește interacțiunea cu orice API. În cazul nostru, vom folosi un API gratuit .stringr— un pachet pentru a lucra cu textul, iar în cazul nostru, îl vom folosi pentru a forma mesajul despre vreme în orașul selectat.
Cod 4: Bot care comunică vremea curentă pentru orașul ales
library(telegram.bot)
library(httr)
library(stringr)
# Creamos un ejemplar de la clase Updater
updater <- Updater('TOKENUL BOTULUI TĂU')
# Creamos metode
## Metodă pentru lansarea tastaturii principale
start <- function(bot, update) {
# Cream tastatura
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Vremea")
)
),
resize_keyboard = TRUE,
one_time_keyboard = TRUE
)
# Trimitem tastatura
bot$sendMessage(update$message$chat_id,
text = 'Seleccionează o comandă',
reply_markup = RKM)
}
## Metodă pentru apelarea tastaturii Inline
weather <- function(bot, update) {
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton(text = 'Moscova', callback_data = 'New York,us'),
InlineKeyboardButton(text = 'Sankt Petersburg', callback_data = 'Saint Petersburg'),
InlineKeyboardButton(text = 'New York', callback_data = 'New York')
),
list(
InlineKeyboardButton(text = 'Ekaterinburg', callback_data = 'Yekaterinburg,ru'),
InlineKeyboardButton(text = 'Berlin', callback_data = 'Berlin,de'),
InlineKeyboardButton(text = 'Paris', callback_data = 'Paris,fr')
),
list(
InlineKeyboardButton(text = 'Roma', callback_data = 'Rome,it'),
InlineKeyboardButton(text = 'Odesa', 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')
)
)
)
# Trimitem tastatura Inline
bot$sendMessage(chat_id = update$message$chat_id,
text = "Seleccionează un oraș",
reply_markup = IKM)
}
# Metodă pentru mesajul vremii
answer_cb <- function(bot, update) {
# Obținem orașul din mesaj
city <- update$callback_query$data
# Trimitem cererea
ans <- GET('https://api.openweathermap.org/data/2.5/weather',
query = list(q = city,
lang = 'ro',
units = 'metric',
appid = '4776568ccea136ffe4cda9f1969af340'))
# Parsăm răspunsul
result <- content(ans)
# Formăm mesajul
msg <- str_glue("{result$name} vreme:n",
"Temperatura curentă: {result$main$temp}n",
"Viteza vântului: {result$wind$speed}n",
"Descriere: {result$weather[[1]]$description}")
# Trimitem informațiile despre vreme
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# Cream filtre
## Mesaje cu textul Vremea
MessageFilters$weather <- BaseFilter(function(message) {
# Verificăm textul mesajului
message$text == "Vremea"
}
)
# Cream manejatori
h_start <- CommandHandler('start', start)
h_weather <- MessageHandler(weather, filters = MessageFilters$weather)
h_query_handler <- CallbackQueryHandler(answer_cb)
# Adăugăm manejatorii în dispatcher
updater <- updater +
h_start +
h_weather +
h_query_handler
# Lansăm botul
updater$start_polling()Rulați exemplul de cod de mai sus, înlocuind 'TOKENUL BOTULUI DUMNEAVOASTRĂ' cu token-ul real pe care l-ați primit când ați creat botul prin BotFather (despre crearea botului am vorbit în ).
În rezultat, robotul nostru va funcționa cam așa:
Schema robotului poate fi reprezentată astfel:
Am creat 3 metode disponibile în robotul nostru meteo:
- start — Activarea tastaturii principale a robotului
- weather — Activarea tastaturii Inline pentru selectarea orașului
- answer_cb — Metoda principală, care la orașul specificat solicită vremea din API și o trimite în chat.
Metoda start se activează cu comanda /start, ceea ce este implementat de handler CommandHandler('start', start).
Pentru a activa metoda weather am creat un filtru cu același nume:
# создаём фильтры
## сообщения с текстом Погода
MessageFilters$weather <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Погода"
}
)Și apelăm această metodă cu următorul handler de mesaje: MessageHandler(weather, filters = MessageFilters$weather).
Și, în cele din urmă, metoda noastră principală answer_cb reacționează la apăsarea butoanelor Inline, ceea ce este implementat de un handler special: CallbackQueryHandler(answer_cb).
În interiorul metodei answer_cb, citim datele trimise de pe tastatură și le stocăm într-o variabilă city: city <- update$callback_query$data. După care solicităm datele despre vreme din API, formăm și trimitem un mesaj, și în cele din urmă folosim metoda answerCallbackQuery pentru a informa robotul că am procesat apăsarea butonului Inline.
Exemplu de robot care afișează lista celor mai recente articole cu linkuri din Hub-ul specificat din .
Acest robot îl ofer pentru a vă arăta cum să generați butoane Inline care duc către pagini web.
Logica acestui robot este similară cu precedentul, inițial activăm tastatura principală cu comanda /start. Apoi, robotul ne oferă o listă de 6 hub-uri, alegem hub-ul de interes, și primim cele mai recente 5 publicații din hub-ul selectat.
După cum înțelegeți, în acest caz trebuie să obținem lista articolelor, iar pentru aceasta vom folosi pachetul special habR, care permite solicitarea articolelor din Habr și a unor statistici despre acestea în R.
Pachetul habR poate fi instalat doar din github, pentru care veți avea nevoie de un pachet suplimentar devtools. Pentru instalare, utilizați codul de mai jos.
install.packages('devtools')
devtools::install_github('selesnow/habR')Acum să examinăm codul pentru construirea robotului descris mai sus:
Cod 5: Robot care afișează lista celor mai recente articole pentru Hub-ul selectat
library(telegram.bot)
library(habR)
# Creăm o instanță a clasei Updater
updater <- Updater('TOKENUL BOTULUI DUMNEAVOASTRĂ')
# Creăm metode
## Metoda pentru a lansa tastatura principală
start <- function(bot, update) {
# Creăm tastatura
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Lista articolelor")
)
),
resize_keyboard = TRUE,
one_time_keyboard = TRUE
)
# Trimitem tastatura
bot$sendMessage(update$message$chat_id,
text = 'Alegeți o comandă',
reply_markup = RKM)
}
## Metoda pentru a apela tastatura 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 = 'Vizualizarea datelor', callback_data = 'data_visualization')
)
)
)
# Trimite Tastatura Inline
bot$sendMessage(chat_id = update$message$chat_id,
text = "Alegeți Hub-ul",
reply_markup = IKM)
}
# Metoda pentru a raporta vremea
answer_cb <- function(bot, update) {
# Obținem din mesaj orașul
hub <- update$callback_query$data
# Mesaj că datele de pe buton au fost primite
bot$answerCallbackQuery(callback_query_id = update$callback_query$id,
text = 'Așteptați câteva minute, cererea se procesează')
# Mesaj că trebuie să așteptăm până când botul primește datele
mid <- bot$sendMessage(chat_id = update$from_chat_id(),
text = "Așteptați câteva minute până când, voi aduna datele despre Hub-ul ales")
# Parsăm Habr
posts <- head(habr_hub_posts(hub, 1), 5)
# Ștergem mesajul că trebuie să așteptăm
bot$deleteMessage(update$from_chat_id(), mid$message_id)
# Formăm lista de butoane
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# Formăm tastatura
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)
# Trimitem informațiile despre vreme
bot$sendMessage(chat_id = update$from_chat_id(),
text = paste0("Cele mai recente 5 articole din Habr ", hub),
reply_markup = IKM)
}
# Creăm filtre
## Mesaje cu textul Vremea
MessageFilters$hubs <- BaseFilter(function(message) {
# Verificăm textul mesajului
message$text == "Lista articolelor"
}
)
# Creăm обработчици
h_start <- CommandHandler('start', start)
h_hubs <- MessageHandler(habs, filters = MessageFilters$hubs)
h_query_handler <- CallbackQueryHandler(answer_cb)
# Adăugăm обработчици в диспетчер
updater <- updater +
h_start +
h_hubs +
h_query_handler
# Lansăm botul
updater$start_polling()Rulați exemplul de cod de mai sus, înlocuind 'TOKENUL BOTULUI DUMNEAVOASTRĂ' cu token-ul real pe care l-ați primit când ați creat botul prin BotFather (despre crearea botului am vorbit în ).
În cele din urmă, vom obține următorul rezultat:
Lista Hub-urilor disponibile pentru selecție a fost codificată în metodă 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)
}Lista articolelor din Hub-ul specificat o obținem cu comanda habr_hub_posts(), din pachet habR. Menționăm că nu avem nevoie de lista articolelor de-a lungul timpului, ci doar de prima pagină care conține 20 de articole. Din tabela obținută folosind comanda head() lăsăm doar cele mai recente 5, care sunt cele mai proaspete articole.
# парсим Хабр
posts <- head(habr_hub_posts(hub, 1), 5)Logica este foarte asemănătoare cu botul anterior, dar în acest caz generăm dinamic tastatura inline cu lista articolelor folosind funcția lapply().
# формируем список кнопок
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# формируем клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)În textul butonului introducem titlul articolului posts$title[x], iar în argument url linkul către articol: url = posts$link[x].
Apoi, creăm un filtru, handleri și lansăm botul nostru.
Concluzie
Acum, boturile scrise de voi vor fi mult mai ușor de utilizat, deoarece gestionarea lor se va face de pe tastatură și nu prin introducerea comenzilor. Cel puțin interacționând cu botul de pe smartphone, tastatura va simplifica semnificativ procesul de utilizare.
În articolul următor ne vom ocupa de cum să construim un dialog logic cu botul și să lucrăm cu bazele de date.
Sursa: habr.com
