See on kolmas artikkel seeriast "Kirjutame telegrammi boti R keeles". Eelmistes publikatsioonides õpime looma telegrammiboti, saatma selle kaudu sõnumeid, lisasime botile käsud ja sõnumifilterid. Seetõttu soovitan tungivalt tutvuda , sest siin ei peatu ma varem kirjeldatud botide loomise aluste juures.
Selles artiklis parandame meie boti kasutatavust, lisades klaviatuuri, mis muudab boti liidese intuitiivseks ja lihtsaks kasutada.
Kõik artiklid seeriast "Kirjutame telegrammi boti R keeles"
Sisukord
Kui teid huvitab andmeanalüüs, võivad teid huvitada minu ja kanalid, millel on suur osa sisu R keelele.
3.1.
3.2.
3.3.
Milliseid klaviatuure telegrammi bot toetab
Artikli kirjutamise hetkeks telegram.bot võimaldab teil luua kaht tüüpi klaviatuure:
- Reply — Peamine, tavaline klaviatuur, mis asub sõnumi sisestamise paneeli all. Selline klaviatuur saadab botile tekstisõnumi, ja tekstina saadab selle teksti, mis on kirjutatud nupu peale.
- Inline — Klaviatuur, mis on seotud konkreetse boti sõnumiga. See klaviatuur saadab botile andmed, mis on seotud vajutatava nupuga, need andmed võivad erineda nupul kirjutatud tekstist. Selliseid nuppe töödeldakse läbi CallbackQueryHandler.
Selleks, et bot avaks klaviatuuri, tuleb sõnumit saates kasutada meetodit sendMessage(), edastades varem loodud klaviatuuri argumendina reply_markup.
Allpool vaatame mõningaid näiteid.
Reply klaviatuur
Nagu juba varem ütlesin, on see boti põhijuhtimisklaviatuur.
Reply klaviatuuri loomise näide ametlikust dokumentatsioonist
bot <- Bot(token = "TOKEN")
chat_id <- "CHAT_ID"
# Looge kohandatud klaviatuur
text <- "Kas need kohandatud klaviatuurid pole mitte ägedad?"
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Jah, need on tõeliselt ägedad!")),
list(KeyboardButton("Ma ei ole päris kindel")),
list(KeyboardButton("Ei..."))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# Saada kohandatud klaviatuur
bot$sendMessage(chat_id, text, reply_markup = RKM)Ülaltoodud näide on pärit paketi ametlikust dokumentatsioonist telegram.bot. Klaviatuuri loomiseks kasutatakse funktsiooni ReplyKeyboardMarkup(), mis omakorda võtab vastu nuppude listide loendi, mis on loodud funktsiooni KeyboardButton().
Miks on ReplyKeyboardMarkup() vaja edastada mitte lihtsalt loendit, vaid loendite loendit? Asi on selles, et edastate põhilise loendi ja selles määratlete eraldi loenditega iga nupu rea, kuna ühes reas saab paigutada mitu nuppu.
Argumendiks resize_keyboard on automaatselt kohandatava klaviatuuri nuppude optimaalne suurus, ja argument one_time_keyboard peidab klaviatuuri pärast iga nupu vajutamist.
Kirjutame lihtsa boti, millel on 3 nuppu:
- Chat ID — Palu botiga vestluse chat ID
- Minu nimi — Palu oma nime määratlemine
- Minu kasutajanimi — Palu oma Telegrami kasutajanime määratlemine
Kood 1: Lihtne bot Reply klaviatuuriga
library(telegram.bot)
# loome Updater klassi eksemplar
updater <- Updater('TEIE BOTA TOKEN')
# loome meetodid
## meetod klaviatuuri käivitamiseks
start <- function(bot, update) {
# loome klaviatuuri
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Vestluse ID")),
list(KeyboardButton("Minu nimi")),
list(KeyboardButton("Minu kasutajanimi"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# saadame klaviatuuri
bot$sendMessage(update$message$chat_id,
text = 'Valige käsk',
reply_markup = RKM)
}
## meetod, mis tagastab vestluse id
chat_id <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Vestluse id selle dialooge: ", update$message$chat_id),
parse_mode = "Markdown")
}
## meetod, mis tagastab nime
my_name <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Teid kutsutakse ", update$message$from$first_name),
parse_mode = "Markdown")
}
## meetod, mis tagastab kasutajanime
my_username <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Teie kasutajanimi ", update$message$from$username),
parse_mode = "Markdown")
}
# loome filtrid
## sõnumid tekstiga Vestluse ID
MessageFilters$chat_id <- BaseFilter(function(message) {
# kontrollime sõnumi teksti
message$text == "Vestluse ID"
}
)
## sõnumid tekstiga Minu nimi
MessageFilters$name <- BaseFilter(function(message) {
# kontrollime sõnumi teksti
message$text == "Minu nimi"
}
)
## sõnumid tekstiga Minu kasutajanimi
MessageFilters$username <- BaseFilter(function(message) {
# kontrollime sõnumi teksti
message$text == "Minu kasutajanimi"
)
# loome käitlejad
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)
# lisame käitlejad haldurisse
updater <- updater +
h_start +
h_chat_id +
h_name +
h_username
# käivitame boti
updater$start_polling()Käivitage ülaltoodud koodinäide, asendades 'TEIE BOTA TOKEN' reaalse tokeniga, mille saate boti loomisel BotFather (boti loomise kohta rääkisin ma ).
Käivitage botile käsk /start, kuna see on see, mille määrasime klaviatuuri käivitamiseks.
Kui teile näib, et antud koodinäide meetodite, filtrite ja käitlejate loomisega on keeruline, siis tuleks tagasi minna eelnevale , kus ma seda kõike üksikasjalikult selgitasin.
Olemegi loonud 4 meetodit:
- start — Klaviatuuri käivitamine
- chat_id — Vestluse id pärimine
- my_name — Oma nime pärimine
- my_username — Oma kasutajanime pärimine
Objekti MessageFilters oleme lisanud 3 sõnumifiltrit, vastavalt nende tekstile:
- chat_id — Sõnumid tekstiga
"Chat ID" - name — Sõnumid tekstiga
"Minu nimi" - username — Sõnumid tekstiga
"Minu kasutajanimi"
Ja loodi 4 töötlejat, mis täidavad määratud käsklusi ja filtreid, tehes näidatud meetodeid.
# создаём обработчики
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)Põhiklahvitud luuakse meetodi sees start() käsklusega ReplyKeyboardMarkup().
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Chat ID")),
list(KeyboardButton("Minu nimi")),
list(KeyboardButton("Minu kasutajanimi"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)Meie puhul on kõik nupud paigutatud üksteise alla, kuid saame need paigutada ühte ritta, muutes nuppude nimekirja. Kuna üks rida klaviatuuril luuakse nuppude sisemise loendi kaudu, tuleb meie nuppude esitlemiseks ühes reas ümber kirjutada osa klaviatuuri loomise koodist nii:
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Chat ID"),
KeyboardButton("Minu nimi"),
KeyboardButton("Minu kasutajanimi")
)
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
Klaviatuur saadetakse vestlusesse meetodi kaudu sendMessage(), argumendis reply_markup.
bot$sendMessage(update$message$chat_id,
text = 'Vali käsk',
reply_markup = RKM)Inline klaviatuur
Nagu ma juba varem mainisin, on Inline klaviatuur seotud konkreetse sõnumiga. Selle kasutamine on keerulisem kui põhiklahvitud.
Alguses peate lisama botile meetodi Inline klaviatuuri väljakutsumiseks.
Inline nupu vajutamisele vastamiseks saab samuti kasutada boti meetodit answerCallbackQuery(), mis võib näidata teate Telegrami liideses, kasutajale, kes vajutas Inline nuppu.
Inline nupu kaudu saadetud andmed ei ole tekst, seega peab nende töötlemiseks looma spetsiaalse töötleja käsu abil CallbackQueryHandler().
Inline klaviatuuri koostamise kood, mis on esitatud paketi ametlikus dokumentatsioonis telegram.bot.
Inline klaviatuuri koostamise kood ametlikust dokumentatsioonist
# 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)Inline klaviatuuri tuleb koostada käsu abil InlineKeyboardMarkup(), samal põhimõttel nagu Reply klaviatuur. V InlineKeyboardMarkup() aja tuleb edastada loend, loendite Inline nuppudest, iga eraldi nupp luuakse funktsiooni InlineKeyboardButton().
Inline nupp võib kas edastada botile mõned andmed argumendi kaudu callback_data, või avada mõne HTML lehe, mis on määratletud argumendi kaudu url.
Tulemusena saab nimekirja, kus iga element on samuti Inline nuppude loend, mis tuleb kombineerida ühte ritta.
Jätkame nüüd paaride näidiste vaatamist botidest, millel on Inline-nupud.
Lihtsaim boti näide, mis toetab InLine nuppe
Esmalt kirjutame boti kiireks covid-19 testi tegemiseks. Käskluse korral /test, saadab see teile klaviatuuri kahe nupuga; sõltuvalt vajutatud nupust saadab see teile sõnumi teie testi tulemustega.
Kood 2: Lihtsaim bot Inline klaviatuuriga
library(telegram.bot)
# loome Updater klassi eksemplari
updater <- Updater('TEIE BOTE TOKEN')
# meetod Inline klaviatuuri saatmiseks
test <- function(bot, update) {
# loome Inline klaviatuuri
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton("Jah", callback_data = 'yes'),
InlineKeyboardButton("Ei", callback_data = 'no')
)
)
)
# Saadame klaviatuuri vestlusesse
bot$sendMessage(update$message$chat_id,
text = "Kas te olete nakatunud koroonaviirusesse?",
reply_markup = IKM)
}
# meetod nupuvajutuse töötlemiseks
answer_cb <- function(bot, update) {
# nupult saadud andmed
data <- update$callback_query$data
# saame nupule vajutanud kasutaja nime
uname <- update$effective_user()$first_name
# tulemuse töötlemine
if (data == 'no') {
msg <- paste0(uname, ", õnnitlen, teie covid-19 test on negatiivne.")
} else {
msg <- paste0(uname, ", kahjuks on teie covid-19 test positiivne.")
}
# Sõnumi saatmine
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# teatame botile, et nupu päring on vastu võetud
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# loome töötlejad
inline_h <- CommandHandler('test', test)
query_handler <- CallbackQueryHandler(answer_cb)
# lisame töötlejad haldurisse
updater <- updater + inline_h + query_handler
# käivitame boti
updater$start_polling()Käivitage ülaltoodud koodinäide, asendades 'TEIE BOTA TOKEN' reaalse tokeniga, mille saate boti loomisel BotFather (boti loomise kohta rääkisin ma ).
Tulemus:
Oleme loonud kaks meetodit:
- test — Inline klaviatuuri saatmiseks vestlusse
- answer_cb — Klaviatuurilt saadud andmete töötlemiseks.
Andmed, mis saadetakse igast nupust, määratakse nupu loomisel argumendis callback_data, nupu loomise käigus. Nupult saadud andmeid saab kätte konstruktsiooni abil update$callback_query$data, meetodi sees answer_cb.
Et bot reageeriks Inline klaviatuurile, töödeldakse meetodit answer_cb erilise töödeldijaga: CallbackQueryHandler(answer_cb). Mis käivitab määratud meetodi Inline nupu vajutamisel. Töödeldija CallbackQueryHandler võtab kaks argumenti:
callback— meetod, mida tuleb käivitadapattern— filter andmete alusel, mis on seotud nupuga argumendi kauducallback_data.
Kohaselt, argumendi abil pattern saame iga nupu vajutamiseks kirjutada eraldi meetodi:
Kood 3: Jagame meetodid iga Inline nupu jaoks
library(telegram.bot)
# Loome klassi Updater eksemplari
updater <- Updater('TEIE BOTA TOKEN')
# meetod inline-klaviatuuri saatmiseks
test <- function(bot, update) {
# Loome inline-klaviatuuri
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton("Jah", callback_data = 'yes'),
InlineKeyboardButton("Ei", callback_data = 'no')
)
)
)
# Saada klaviatuur vestlusesse
bot$sendMessage(update$message$chat_id,
text = "Kas teil on koronaviirus?",
reply_markup = IKM)
}
# meetod jah-nupu vajutuse töötlemiseks
answer_cb_yes <- function(bot, update) {
# Saame kasutaja nime, kes vajutas nuppu
uname <- update$effective_user()$first_name
# Tulemuse töötlemine
msg <- paste0(uname, ", kahjuks on teie test covid-19 positiivne.")
# Sõnumi saatmine
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# Teavitame boti, et nupp on aktsepteeritud
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# meetod ei-nupu vajutuse töötlemiseks
answer_cb_no <- function(bot, update) {
# Saame kasutaja nime, kes vajutas nuppu
uname <- update$effective_user()$first_name
msg <- paste0(uname, ", õnnitleme, teie test covid-19 on negatiivne.")
# Sõnumi saatmine
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# Teavitame boti, et nupp on aktsepteeritud
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# Loome töötlejad
inline_h <- CommandHandler('test', test)
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')
# Lisame töötlejad jaotajasse
updater <- updater +
inline_h +
query_handler_yes +
query_handler_no
# Käivitame boti
updater$start_polling()Käivitage ülaltoodud koodinäide, asendades 'TEIE BOTA TOKEN' reaalse tokeniga, mille saate boti loomisel BotFather (boti loomise kohta rääkisin ma ).
Nüüd oleme kirjutanud 2 eraldi meetodit, st ühe meetodi iga nupu vajutuse jaoks, ja kasutasime argumenti pattern, kui loome nende töötlejaid:
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')Koodi meetodi lõpp answer_cb käsklusega bot$answerCallbackQuery(callback_query_id = update$callback_query$id), mis teavitab boti, et andmed inline-klaviatuurist on saadud.
Boti näide, mis teatab valitud linna hetkeilma
Proovime kirjutada bot'i, mis küsib ilmaprognoosi andmeid.
Selle töö logika on järgmine. Alguses käsuga /start kutsete peamine klaviatuur, kus on ainult üks nupp "Ilm". Nuppu vajutades saadakse sõnum inline-klaviatuuriga, et valida linn, mille kohta soovite teada hetkeilma. Valite ühe linnade hulgast ja saadate hetkeilma.
Selles koodinäites kasutame mitmeid lisapakette:
httr— pakett HTTP-päringute töötlemiseks, mille alusel põhineb iga API töö. Antud juhul kasutame tasuta API-d .stringr— pakett teksti töötlemiseks, mida kasutame antud juhul valitud linnas ilmateate koostamiseks.
Kood 4: Bot, mis teatab valitud linna praegusest ilmast
library(telegram.bot)
library(httr)
library(stringr)
# Loome Updater klassi eksemplar
updater <- Updater('TEIE TEIE BOTI TOKEN')
# Loome meetodid
## Meetod põhiklahvi käivitamiseks
start <- function(bot, update) {
# Loome klaviatuuri
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Ilm")
)
),
resize_keyboard = TRUE,
one_time_keyboard = TRUE
)
# Saadame klaviatuuri
bot$sendMessage(update$message$chat_id,
text = 'Valige käsk',
reply_markup = RKM)
}
## Meetod Inline klaviatuuri kutsumiseks
weather <- function(bot, update) {
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton(text = 'Moskva', callback_data = 'New York,us'),
InlineKeyboardButton(text = 'Peterburi', callback_data = 'Saint Petersburg'),
InlineKeyboardButton(text = 'New York', callback_data = 'New York')
),
list(
InlineKeyboardButton(text = 'Jekaterinburg', callback_data = 'Yekaterinburg,ru'),
InlineKeyboardButton(text = 'Berliin', callback_data = 'Berlin,de'),
InlineKeyboardButton(text = 'Pariis', callback_data = 'Paris,fr')
),
list(
InlineKeyboardButton(text = 'Rooma', callback_data = 'Rome,it'),
InlineKeyboardButton(text = 'Odessa', callback_data = 'Odessa,ua'),
InlineKeyboardButton(text = 'Kiiev', 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')
)
)
)
# Saada Inline klaviatuur
bot$sendMessage(chat_id = update$message$chat_id,
text = "Valige linn",
reply_markup = IKM)
}
# Meetod ilmastiku teate edastamiseks
answer_cb <- function(bot, update) {
# Saame linnast sõnumist
city <- update$callback_query$data
# Teeme päringu
ans <- GET('https://api.openweathermap.org/data/2.5/weather',
query = list(q = city,
lang = 'et',
units = 'metric',
appid = '4776568ccea136ffe4cda9f1969af340'))
# Parsime vastuse
result <- content(ans)
# Koostame sõnumi
msg <- str_glue("{result$name} ilm:n",
"Praegune temperatuur: {result$main$temp}n",
"Tuulekiirus: {result$wind$speed}n",
"Kirjeldus: {result$weather[[1]]$description}")
# Saame ilma kohta info
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# Loome filtrid
## Sõnumid tekstiga Ilm
MessageFilters$weather <- BaseFilter(function(message) {
# Kontrollime sõnumi teksti
message$text == "Ilm"
}
)
# Loome töötlejad
h_start <- CommandHandler('start', start)
h_weather <- MessageHandler(weather, filters = MessageFilters$weather)
h_query_handler <- CallbackQueryHandler(answer_cb)
# Lisame töötlejad dispatcherisse
updater <- updater +
h_start +
h_weather +
h_query_handler
# Käivitame boti
updater$start_polling()Käivitage ülaltoodud koodinäide, asendades 'TEIE BOTA TOKEN' reaalse tokeniga, mille saate boti loomisel BotFather (boti loomise kohta rääkisin ma ).
Seetõttu töötab meie bot umbes nii:
Skeemiliselt saab seda boti kujutada järgmiselt:
Oleme loonud 3 meetodit, mis on saadaval meie ilmateate botis:
- start — Peamise boti klaviatuuri käivitamine
- weather — Inline klaviatuuri käivitamine linna valimiseks
- answer_cb — Peamine meetod, mis küsib API-st ilmateavet antud linna kohta ja saadab selle vestlusesse.
Meetod start meil on saadud käsuga /start, mille rakendab töötleja CommandHandler('start', start).
Meetodi käivitamiseks weather oleme loonud sama nimega filtri:
# создаём фильтры
## сообщения с текстом Погода
MessageFilters$weather <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Погода"
}
)Ja kutsume selle meetodi järgmise sõnumitöötlejaga: MessageHandler(weather, filters = MessageFilters$weather).
Ja lõpuks, meie peamine meetod answer_cb reaktseerib Inline nuppude vajutustele, mida rakendab spetsiaalne töötleja: CallbackQueryHandler(answer_cb).
Meetodi sees answer_cb, loeme klaviatuurilt saadud andmed ja salvestame need muutuja city: city <- update$callback_query$data. Seejärel küsime API-st ilmadeavet, vormime ja saadame sõnumi ning lõpuks kasutame meetodit answerCallbackQuery et anda botile teada, et oleme Inline nupu vajutuse töötlenud.
Boti näide, mis kuvab nimekirja kõige värskematest artiklitest linkidega antud Hubist .
Toon selle boti, et näidata, kuidas kuvada Inline nuppe, mis viivad veebilehtedele.
Selle boti loogika on sarnane eelmisele, esmalt käivitame põhilise klaviatuuri käsuga /start. Edasi annab bot meile valida 6 hubi hulgast, valime huvipakkuva hubi ja saame 5 kõige värskemat avaldust valitud Hubist.
Nagu mõistate, on sel juhul meil vaja saada artiklite nimekiri ja selleks kasutame spetsiaalset paketti habR, mis võimaldab küsida Hubrist artikleid ja teatud statistikat nende kohta R-s.
Paketti habR saab installida ainult GitHubist, milleks vajate täiendavat paketti devtools. Installimiseks kasutage allolevat koodi.
install.packages('devtools')
devtools::install_github('selesnow/habR')Nüüd vaatame üle ülaltoodud boti ehitamise koodi:
Kood 5: Bot, mis kuvab nimekirja kõige värskematest artiklitest valitud Hubi kohta
library(telegram.bot)
library(habR)
# loome Updater klassi eksemplar
updater <- Updater('TEIE TEIE BOTA TOKE')
# loome meetodid
## meetod põhiklahvi käivitamiseks
start <- function(bot, update) {
# loome klaviatuuri
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Artiklite loetelu")
)
),
resize_keyboard = TRUE,
one_time_keyboard = TRUE
)
# saadame klaviatuuri
bot$sendMessage(update$message$chat_id,
text = 'Vali käsk',
reply_markup = RKM)
}
## Inline klaviatuuri kutse meetod
habs <- function(bot, update) {
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton(text = 'R', callback_data = 'R'),
InlineKeyboardButton(text = 'Andmete kaevandamine', callback_data = 'data_mining'),
InlineKeyboardButton(text = 'Andmete inseneriteadus', callback_data = 'data_engineering')
),
list(
InlineKeyboardButton(text = 'Suurandmed', callback_data = 'bigdata'),
InlineKeyboardButton(text = 'Python', callback_data = 'python'),
InlineKeyboardButton(text = 'Andmete visualiseerimine', callback_data = 'data_visualization')
)
)
)
# Saada Inline Klaviatuur
bot$sendMessage(chat_id = update$message$chat_id,
text = "Vali Hub",
reply_markup = IKM)
}
# meetod ilmajaama teate jaoks
answer_cb <- function(bot, update) {
# saame linnast, mis tuli sõnumiga
hub <- update$callback_query$data
# teade, et nuppude andmed on saadud
bot$answerCallbackQuery(callback_query_id = update$callback_query$id,
text = 'Palun oodake mõni minut, päringut töödeldakse')
# teade, et tuleb oodata, kuni bot saab andmed
mid <- bot$sendMessage(chat_id = update$from_chat_id(),
text = "Palun oodake mõni minut, kuni ma kogun andmeid valitud Hubi kohta")
# parsimine Habr
posts <- head(habr_hub_posts(hub, 1), 5)
# kustutame teate, et oodata
bot$deleteMessage(update$from_chat_id(), mid$message_id)
# vormindame nuppude loendi
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# vormindame klaviatuuri
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)
# saadame ilmaandmed
bot$sendMessage(chat_id = update$from_chat_id(),
text = paste0("5 kõige värskemat artiklit Hubist ", hub),
reply_markup = IKM)
}
# loome filtrid
## sõnumid, mille tekst on Ilm
MessageFilters$hubs <- BaseFilter(function(message) {
# kontrollime sõnumi teksti
message$text == "Artiklite loetelu"
}
)
# loome töötlejad
h_start <- CommandHandler('start', start)
h_hubs <- MessageHandler(habs, filters = MessageFilters$hubs)
h_query_handler <- CallbackQueryHandler(answer_cb)
# lisame töötlejad dispatcherisse
updater <- updater +
h_start +
h_hubs +
h_query_handler
# käivitame boti
updater$start_polling()Käivitage ülaltoodud koodinäide, asendades 'TEIE BOTA TOKEN' reaalse tokeniga, mille saate boti loomisel BotFather (boti loomise kohta rääkisin ma ).
Lõpetuseks saame sellise tulemuse:
Valitud Hubide nimekirja oleme sisse viinud kõvajuhtimismeetodi abil, meetodis 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)
}Teeme antud Hubist artiklite nimekirja saamise käsuga habr_hub_posts(), paketist habR. Sel juhul märkime, et me ei vaja kõigi aegade artiklite nimekirja, vaid ainult esimest lehte, kus asub 20 artiklit. Saadud tabelist kasutame käsu head() ainult 5 kõige ülemist, mis on ka kõige värskemad artiklid.
# парсим Хабр
posts <- head(habr_hub_posts(hub, 1), 5)Loogika on väga sarnane eelmise robotiga, kuid antud juhul genereerime Inline klaviatuuri artiklite nimekirjaga dünaamiliselt funktsiooni lapply().
# формируем список кнопок
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# формируем клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)Nuppu teksti paneme artikli nime posts$title[x], ja argumendiks url artikli link: url = posts$link[x].
Seejärel loome filtri, töötlejad ja käivitame meie roboti.
Kokkuvõte
Nüüd saavad teie kirjutatud robotid olema oluliselt mugavamad kasutada, kuna nende haldamine toimub klaviatuuriga, mitte käsuga sisestamisega. Eriti, kui suhelda robotiga nutitelefonis, muudab klaviatuur oluliselt lihtsamaks selle kasutamise.
Järgmises artiklis uurime, kuidas luua loogilist dialooge robotiga ja töötada andmebaasidega.
Allikas: habr.com
