See on kolmas artikkel sarjast "Telegram Boti kirjutamine R-is". Eelmistes väljaannetes õppisime, kuidas luua Telegram Boti, selle kaudu sõnumeid saata, botile käske ja sõnumifiltreid lisada. Seetõttu soovitan enne selle artikli lugemist tungivalt lugeda , sest siinkohal ma ei hakka pikemalt peatuma eelnevalt kirjeldatud botide ehitamise põhitõdedel.
Selles artiklis parandame oma roboti kasutatavust klaviatuuri lisamisega, mis muudab roboti liidese intuitiivseks ja hõlpsasti kasutatavaks.
Kõik artiklid sarjast “Telegrammiroti kirjutamine R-is”
Sisu
Kui olete huvitatud andmete analüüsist, võite olla huvitatud minu и kanalid. Suurem osa sisust on pühendatud R-keelele.
3.1.
3.2.
3.3.
Milliseid klaviatuuritüüpe Telegrami bot toetab?
Selle kirjutamise ajal telegram.bot võimaldab teil luua kahte tüüpi klaviatuure:
- Vasta – peamine tavaline klaviatuur, mis asub sõnumi tekstisisestuspaneeli all. See klaviatuur saadab robotile lihtsalt tekstisõnumi ja tekstina saadab see nupule kirjutatud teksti.
- Tekstisisene – klaviatuur, mis on seotud kindla botisõnumiga. See klaviatuur saadab boti andmed, mis on seotud vajutatud nupuga ja need andmed võivad erineda nupul olevast tekstist. Selliseid nuppe töödeldakse järgmiste toimingute abil: Tagasihelistamise päringukäitleja.
Selleks, et bot saaks klaviatuuri avada, on see meetodi kaudu sõnumi saatmisel vajalik sendMessage(), edastage argumendile eelnevalt loodud klaviatuur reply_markup.
Allpool vaatleme mõningaid näiteid.
Vastamisklaviatuur
Nagu ma eespool kirjutasin, on see boti juhtimiseks mõeldud peamine klaviatuur.
Näide vastuseklaviatuuri loomisest ametlikust abist
bot <- Bot(token = "TOKEN")
chat_id <- "CHAT_ID"
# Create Custom Keyboard
text <- "Aren't those custom keyboards cool?"
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Yes, they certainly are!")),
list(KeyboardButton("I'm not quite sure")),
list(KeyboardButton("No..."))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# Send Custom Keyboard
bot$sendMessage(chat_id, text, reply_markup = RKM)Ülal on näide ametlikust abipaketist. telegram.botKlaviatuuri loomiseks kasutage funktsiooni ReplyKeyboardMarkup(), mis omakorda võtab funktsiooni loodud nuppude loendi KeyboardButton().
Miks sisse ReplyKeyboardMarkup() Kas on vaja edastada mitte ainult nimekiri, vaid terve nimekiri nimekirjadest? Asi on selles, et edastatakse peamine nimekiri ja selles määratakse iga nupurea eraldi nimekirjana, kuna ühte ritta saab paigutada mitu nuppu.
argument resize_keyboard võimaldab teil automaatselt valida klaviatuurinuppude optimaalse suuruse ja argumendi one_time_keyboard Võimaldab klaviatuuri iga nupuvajutuse järel peita.
Kirjutame lihtsa roboti, millel on 3 nuppu:
- Vestluse ID – robotiga peetava dialoogi vestluse ID taotlemine
- Minu nimi - Küsi oma nime
- Minu sisselogimine - Taotle oma kasutajanime Telegramis
Kood 1: Lihtne bot vastamisklaviatuuriga
library(telegram.bot)
# создаём экземпляр класса Updater
updater <- Updater('ТОКЕН ВАШЕГО БОТА')
# создаём методы
## метод для запуска клавиатуры
start <- function(bot, update) {
# создаём клавиатуру
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Чат ID")),
list(KeyboardButton("Моё имя")),
list(KeyboardButton("Мой логин"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# отправляем клавиатуру
bot$sendMessage(update$message$chat_id,
text = 'Выберите команду',
reply_markup = RKM)
}
## метод возвразающий id чата
chat_id <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Чат id этого диалога: ", update$message$chat_id),
parse_mode = "Markdown")
}
## метод возвращающий имя
my_name <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Вас зовут ", update$message$from$first_name),
parse_mode = "Markdown")
}
## метод возвращающий логин
my_username <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Ваш логин ", update$message$from$username),
parse_mode = "Markdown")
}
# создаём фильтры
## сообщения с текстом Чат ID
MessageFilters$chat_id <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Чат ID"
}
)
## сообщения с текстом Моё имя
MessageFilters$name <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Моё имя"
}
)
## сообщения с текстом Мой логин
MessageFilters$username <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Мой логин"
)
# создаём обработчики
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)
# добавляем обработчики в диспетчер
updater <- updater +
h_start +
h_chat_id +
h_name +
h_username
# запускаем бота
updater$start_polling()Käivitage ülaltoodud koodinäide pärast seda, kui olete asendanud "TEIE BOTI MÄRGI" tõelise märgiga, mille saite roboti loomisel BotFather (Ma rääkisin roboti loomisest ).
Pärast käivitamist anna robotile käsk /start, kuna just seda me klaviatuuri käivitamiseks defineerisime.
Kui teil on hetkel raske antud koodinäidet meetodite, filtrite ja käitlejate loomisega mõista, peaksite naasma eelmise juurde. , milles ma seda kõike üksikasjalikult kirjeldasin.
Oleme loonud 4 meetodit:
- alusta — Käivita klaviatuur
- chat_id — Vestluse ID taotlemine
- minu_nimi — Küsi oma nime
- minu_kasutajanimi — Taotle sisselogimist
Objekti sisse Sõnumifiltrid lisasin 3 sõnumifiltrit teksti järgi:
- chat_id — Tekstiga sõnumid
"Чат ID" - nimi — Tekstiga sõnumid
"Моё имя" - kasutajanimi — tekstisõnumid
"Мой логин"
Ja nad lõid 4 käitlejat, mis käivitavad määratud meetodeid määratud käskude ja filtrite põhjal.
# создаём обработчики
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)Klaviatuur ise luuakse meetodi sees start() meeskond ReplyKeyboardMarkup().
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Чат ID")),
list(KeyboardButton("Моё имя")),
list(KeyboardButton("Мой логин"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)Meie puhul paigutasime kõik nupud üksteise alla, aga saame need ühte ritta paigutada, muutes nuppude loendite loendit. Kuna klaviatuuri üks rida luuakse pesastatud nuppude loendi kaudu, siis nuppude kuvamiseks ühes reas peame osa klaviatuuri loomise koodist ümber kirjutama järgmiselt:
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Чат ID"),
KeyboardButton("Моё имя"),
KeyboardButton("Мой логин")
)
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
Klaviatuur saadetakse vestlusele meetodi abil sendMessage(), argumendis reply_markup.
bot$sendMessage(update$message$chat_id,
text = 'Выберите команду',
reply_markup = RKM)Sisseehitatud klaviatuur
Nagu ma eespool kirjutasin, on tekstisisene klaviatuur seotud kindla sõnumiga. Sellega on mõnevõrra keerulisem töötada kui põhiklaviatuuriga.
Esmalt peate botile lisama meetodi, mis kutsub esile sisemise klaviatuuri.
Samuti saate bot-meetodit kasutada, et reageerida tekstisisese nupu klõpsule. answerCallbackQuery(), mis saab telegrammi liideses kuvada teate kasutajale, kes vajutas tekstisisest nuppu.
Tekstisisese nupu kaudu saadetud andmed ei ole tekstid, seega peate nende töötlemiseks looma spetsiaalse käitleja, kasutades käsku CallbackQueryHandler().
Sisseehitatud klaviatuuri loomise kood on toodud ametlikus abipaketis. telegram.bot.
Sisseehitatud klaviatuuri loomise kood ametlikust abist
# 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)Sisseehitatud klaviatuuri loomiseks peate kasutama käsku InlineKeyboardMarkup(), samal põhimõttel nagu vastamisklaviatuur. InlineKeyboardMarkup() on vaja edastada tekstisiseste nuppude loendite loend, iga üksiku nupu loob funktsioon InlineKeyboardButton().
Tekstisisene nupp saab argumendi abil robotile andmeid edastada callback_datavõi avage argumendi abil määratud HTML-leht url.
Tulemuseks on loend, kus iga element on ka loend tekstisisestest nuppudest, mis tuleb ühendada üheks reaks.
Järgmisena vaatleme mõningaid näiteid robotitest, millel on tekstisisesed nupud.
Näide lihtsaimast robotist, mis toetab InLine nuppe
Alustuseks kirjutame COVID-19 kiirtestimise roboti. Käskluse peale. /test, saadab see sulle kahe nupuga klaviatuuri ja olenevalt vajutatud nupust saadab see sulle testi tulemustega teate.
Kood 2: Lihtsaim robot sisseehitatud klaviatuuriga
library(telegram.bot)
# создаём экземпляр класса Updater
updater <- Updater('ТОКЕН ВАШЕГО БОТА')
# метод для отправки InLine клавиатуры
test <- function(bot, update) {
# создаём InLine клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton("Да", callback_data = 'yes'),
InlineKeyboardButton("Нет", callback_data = 'no')
)
)
)
# Отправляем клавиатуру в чат
bot$sendMessage(update$message$chat_id,
text = "Вы болете коронавирусом?",
reply_markup = IKM)
}
# метод для обработки нажатия кнопки
answer_cb <- function(bot, update) {
# полученные данные с кнопки
data <- update$callback_query$data
# получаем имя пользователя, нажавшего кнопку
uname <- update$effective_user()$first_name
# обработка результата
if ( data == 'no' ) {
msg <- paste0(uname, ", поздравляю, ваш тест на covid-19 отрицательный.")
} else {
msg <- paste0(uname, ", к сожалени ваш тест на covid-19 положительный.")
}
# Отправка сообщения
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# сообщаем боту, что запрос с кнопки принят
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# создаём обработчики
inline_h <- CommandHandler('test', test)
query_handler <- CallbackQueryHandler(answer_cb)
# добавляем обработчики в диспетчер
updater <- updater + inline_h + query_handler
# запускаем бота
updater$start_polling()Käivitage ülaltoodud koodinäide pärast seda, kui olete asendanud "TEIE BOTI MÄRGI" tõelise märgiga, mille saite roboti loomisel BotFather (Ma rääkisin roboti loomisest ).
Tulemus:
Oleme loonud kaks meetodit:
- test — Vestlusele saatmiseks Tekstisisene klaviatuur
- vastus_cb — Klaviatuurilt saadetud andmete töötlemiseks.
Iga nupu kaudu saadetavad andmed on argumendis täpsustatud. callback_data, nupu loomisel. Nupult saadetud andmed saab hankida konstruktsiooni abil update$callback_query$datameetodi sees vastus_cb.
Selleks, et bot reageeriks tekstisisesele klaviatuurile, on meetod vastus_cb töödeldud spetsiaalse käitleja poolt: CallbackQueryHandler(answer_cb)Mis käivitab määratud meetodi, kui vajutatakse nuppu „Inline”. Käitleja Tagasihelistamise päringukäitleja esitab kaks argumenti:
callback— Meetod, mida tuleb käivitadapattern— Filtreeri nupuga seotud andmete järgi argumendi abilcallback_data.
Seega, kasutades argumenti pattern Iga nupuvajutuse jaoks saame kirjutada eraldi meetodi:
Kood 3: Eraldi meetodid iga tekstisisese nupu jaoks
library(telegram.bot)
# создаём экземпляр класса Updater
updater <- Updater('ТОКЕН ВАШЕГО БОТА')
# метод для отправки InLine клавиатуры
test <- function(bot, update) {
# создаём InLine клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton("Да", callback_data = 'yes'),
InlineKeyboardButton("Нет", callback_data = 'no')
)
)
)
# Отправляем клавиатуру в чат
bot$sendMessage(update$message$chat_id,
text = "Вы болете коронавирусом?",
reply_markup = IKM)
}
# метод для обработки нажатия кнопки Да
answer_cb_yes <- function(bot, update) {
# получаем имя пользователя, нажавшего кнопку
uname <- update$effective_user()$first_name
# обработка результата
msg <- paste0(uname, ", к сожалени ваш текст на covid-19 положительный.")
# Отправка сообщения
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# сообщаем боту, что запрос с кнопки принят
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# метод для обработки нажатия кнопки Нет
answer_cb_no <- function(bot, update) {
# получаем имя пользователя, нажавшего кнопку
uname <- update$effective_user()$first_name
msg <- paste0(uname, ", поздравляю, ваш текст на covid-19 отрицательный.")
# Отправка сообщения
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# сообщаем боту, что запрос с кнопки принят
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# создаём обработчики
inline_h <- CommandHandler('test', test)
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')
# добавляем обработчики в диспетчер
updater <- updater +
inline_h +
query_handler_yes +
query_handler_no
# запускаем бота
updater$start_polling()Käivitage ülaltoodud koodinäide pärast seda, kui olete asendanud "TEIE BOTI MÄRGI" tõelise märgiga, mille saite roboti loomisel BotFather (Ma rääkisin roboti loomisest ).
Nüüd oleme kirjutanud kaks eraldi meetodit, st iga nupuvajutuse jaoks ühe meetodi, ja kasutanud argumenti pattern, nende käitlejate loomisel:
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')Meetodi kood lõpeb vastus_cb meeskond bot$answerCallbackQuery(callback_query_id = update$callback_query$id), mis annab robotile teada, et tekstisiseselt klaviatuurilt on andmed vastu võetud.
Näide robotist, mis annab teada valitud linna praegusest ilmast
Proovime kirjutada roboti, mis pärib ilmastikuandmeid.
Selle töö loogika on järgmine. Algselt meeskond /start Sa kutsud peamise klaviatuuri, millel on ainult üks nupp "Ilm". Sellele nupule vajutades kuvatakse teade sisseehitatud klaviatuuriga, kus saab valida linna, mille praegust ilma soovid teada. Vali üks linnadest ja saad praeguse ilma.
Selles koodinäites kasutame mitmeid lisapakette:
httr— pakett HTTP-päringutega töötamiseks, mille põhjal luuakse töö mis tahes API-ga. Meie puhul kasutame tasuta API-t .stringr— pakett tekstiga töötamiseks, meie puhul kasutame seda valitud linna ilma kohta teate genereerimiseks.
Kood 4: Bot, mis annab teada valitud linna praegusest ilmast
library(telegram.bot)
library(httr)
library(stringr)
# создаём экземпляр класса Updater
updater <- Updater('ТОКЕН ВАШЕГО БОТА')
# создаём методы
## метод для запуска основной клавиатуры
start <- function(bot, update) {
# создаём клавиатуру
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Погода")
)
),
resize_keyboard = TRUE,
one_time_keyboard = TRUE
)
# отправляем клавиатуру
bot$sendMessage(update$message$chat_id,
text = 'Выберите команду',
reply_markup = RKM)
}
## Метод вызова Inine клавиатуры
weather <- function(bot, update) {
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton(text = 'Москва', callback_data = 'New York,us'),
InlineKeyboardButton(text = 'Санкт-Петербург', callback_data = 'Saint Petersburg'),
InlineKeyboardButton(text = 'Нью-Йорк', callback_data = 'New York')
),
list(
InlineKeyboardButton(text = 'Екатеринбург', callback_data = 'Yekaterinburg,ru'),
InlineKeyboardButton(text = 'Берлин', callback_data = 'Berlin,de'),
InlineKeyboardButton(text = 'Париж', callback_data = 'Paris,fr')
),
list(
InlineKeyboardButton(text = 'Рим', callback_data = 'Rome,it'),
InlineKeyboardButton(text = 'Одесса', callback_data = 'Odessa,ua'),
InlineKeyboardButton(text = 'Киев', callback_data = 'Kyiv,fr')
),
list(
InlineKeyboardButton(text = 'Токио', callback_data = 'Tokyo'),
InlineKeyboardButton(text = 'Амстердам', callback_data = 'Amsterdam,nl'),
InlineKeyboardButton(text = 'Вашингтон', callback_data = 'Washington,us')
)
)
)
# Send Inline Keyboard
bot$sendMessage(chat_id = update$message$chat_id,
text = "Выберите город",
reply_markup = IKM)
}
# метод для сообщения погоды
answer_cb <- function(bot, update) {
# получаем из сообщения город
city <- update$callback_query$data
# отправляем запрос
ans <- GET('https://api.openweathermap.org/data/2.5/weather',
query = list(q = city,
lang = 'ru',
units = 'metric',
appid = '4776568ccea136ffe4cda9f1969af340'))
# парсим ответ
result <- content(ans)
# формируем сообщение
msg <- str_glue("{result$name} погода:n",
"Текущая температура: {result$main$temp}n",
"Скорость ветра: {result$wind$speed}n",
"Описание: {result$weather[[1]]$description}")
# отправляем информацию о погоде
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# создаём фильтры
## сообщения с текстом Погода
MessageFilters$weather <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Погода"
}
)
# создаём обработчики
h_start <- CommandHandler('start', start)
h_weather <- MessageHandler(weather, filters = MessageFilters$weather)
h_query_handler <- CallbackQueryHandler(answer_cb)
# добавляем обработчики в диспетчер
updater <- updater +
h_start +
h_weather +
h_query_handler
# запускаем бота
updater$start_polling()Käivitage ülaltoodud koodinäide pärast seda, kui olete asendanud "TEIE BOTI MÄRGI" tõelise märgiga, mille saite roboti loomisel BotFather (Ma rääkisin roboti loomisest ).
Selle tulemusel töötab meie bot umbes nii:
Skemaatiliselt saab seda robotit kujundada järgmiselt:
Oleme oma ilmaroboti sees loonud 3 meetodit:
- algus — Käivitage peamine boti klaviatuur
- ilm — Käivita linna valimiseks tekstisisene klaviatuur
- vastus_cb — Peamine meetod, mis küsib API-st antud linna ilmateadet ja saadab selle vestlusse.
Meetod algus käivitame selle käsuga /start, mille rakendab käitleja CommandHandler('start', start).
Meetodi käivitamiseks ilm lõime samanimelise filtri:
# создаём фильтры
## сообщения с текстом Погода
MessageFilters$weather <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Погода"
}
)Ja me kutsume seda meetodit välja järgmise sõnumikäitlejaga: MessageHandler(weather, filters = MessageFilters$weather).
Ja lõpuks, meie peamine meetod vastus_cb reageerib tekstisiseste nuppude vajutamisele, mida rakendab spetsiaalne käitleja: CallbackQueryHandler(answer_cb).
Meetodi sees vastus_cb, loeme klaviatuurilt saadetud andmeid ja kirjutame need muutujasse city: city <- update$callback_query$dataPärast seda küsime API-lt ilmaandmeid, koostame ja saadame sõnumi ning lõpuks kasutame meetodit answerCallbackQuery et teavitada robotit tekstisisese nupu klõpsu töödeldusest.
Näide robotist, mis kuvab uusimate artiklite loendi koos linkidega määratud keskusele saidilt .
Pakun seda botti, et näidata teile, kuidas kuvada veebilehtedele viivaid tekstisiseseid nuppe.
Selle boti loogika on sarnane eelmisega, esialgu käivitame peaklaviatuuri käsuga /startJärgmisena annab bot meile nimekirja kuuest keskusest, mille vahel valida, valime meid huvitava keskuse ja saame valitud keskusest 6 uusimat väljaannet.
Nagu te aru saate, peame sel juhul hankima artiklite loendi ja selleks kasutame spetsiaalset paketti habR, mis võimaldab teil Habraha artikleid ja nende kohta R-is statistikat taotleda.
Installipakett habR võimalik ainult githubist, mille jaoks vajate lisapaketti devtoolsPaigaldamiseks kasutage allolevat koodi.
install.packages('devtools')
devtools::install_github('selesnow/habR')Vaatame nüüd ülalkirjeldatud roboti loomise koodi:
Kood 5: Bot, mis kuvab valitud keskuse uusimate artiklite loendi
library(telegram.bot)
library(habR)
# создаём экземпляр класса Updater
updater <- Updater('ТОКЕН ВАШЕГО БОТА')
# создаём методы
## метод для запуска основной клавиатуры
start <- function(bot, update) {
# создаём клавиатуру
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Список статей")
)
),
resize_keyboard = TRUE,
one_time_keyboard = TRUE
)
# отправляем клавиатуру
bot$sendMessage(update$message$chat_id,
text = 'Выберите команду',
reply_markup = RKM)
}
## Метод вызова 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)
}
# метод для сообщения погоды
answer_cb <- function(bot, update) {
# получаем из сообщения город
hub <- update$callback_query$data
# сообщение о том, что данные по кнопке получены
bot$answerCallbackQuery(callback_query_id = update$callback_query$id,
text = 'Подождите несколько минут, запрос обрабатывается')
# сообщение о том, что надо подождать пока бот получит данные
mid <- bot$sendMessage(chat_id = update$from_chat_id(),
text = "Подождите несколько минут пока, я соберу данные по выбранному Хабу")
# парсим Хабр
posts <- head(habr_hub_posts(hub, 1), 5)
# удаляем сообщение о том, что надо подождать
bot$deleteMessage(update$from_chat_id(), mid$message_id)
# формируем список кнопок
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# формируем клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)
# отправляем информацию о погоде
bot$sendMessage(chat_id = update$from_chat_id(),
text = paste0("5 наиболее свежих статей из Хаба ", hub),
reply_markup = IKM)
}
# создаём фильтры
## сообщения с текстом Погода
MessageFilters$hubs <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Список статей"
}
)
# создаём обработчики
h_start <- CommandHandler('start', start)
h_hubs <- MessageHandler(habs, filters = MessageFilters$hubs)
h_query_handler <- CallbackQueryHandler(answer_cb)
# добавляем обработчики в диспетчер
updater <- updater +
h_start +
h_hubs +
h_query_handler
# запускаем бота
updater$start_polling()Käivitage ülaltoodud koodinäide pärast seda, kui olete asendanud "TEIE BOTI MÄRGI" tõelise märgiga, mille saite roboti loomisel BotFather (Ma rääkisin roboti loomisest ).
Selle tulemusel saame järgmise tulemuse:
Oleme meetodisse valimiseks saadaolevate jaoturite loendi kõvakodeerinud 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)
}Saame määratud keskusest artiklite loendi käsu abil habr_hub_posts(), pakendist habRSel juhul näitame, et me ei vaja kogu aja artiklite loendit, vaid ainult esimest lehekülge, millel asub 20 artiklit. Saadud tabelist käsuga head() Jätame alles vaid viis parimat, mis on kõige uuemad artiklid.
# парсим Хабр
posts <- head(habr_hub_posts(hub, 1), 5)Loogika on väga sarnane eelmise robotiga, kuid antud juhul genereerime funktsiooni abil dünaamiliselt artiklite loendiga tekstisisese klaviatuuri lapply().
# формируем список кнопок
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# формируем клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)Asendame artikli pealkirja nupu tekstiga. posts$title[x]ja argumendis url link artiklile: url = posts$link[x].
Järgmisena loome filtri, käitlejad ja käivitame oma roboti.
Järeldus
Nüüd on teie kirjutatud robotitega palju mugavam töötada, kuna neid juhitakse klaviatuurilt, mitte käskude sisestamise teel. Vähemalt nutitelefoni kaudu robotiga suheldes lihtsustab klaviatuur selle kasutamist oluliselt.
Järgmises artiklis selgitame välja, kuidas luua loogiline dialoog robotiga ja töötada andmebaasidega.
Allikas: www.habr.com
