Questu hè u terzu articulu in a serie "Scrivu un telegram bot in R". In publicazioni precedenti, avemu amparatu cumu creà un telegram bot, mandà messagi attraversu, aghjunghje cumandamenti è filtri di messagi à u bot. Dunque, prima di principià à leghje stu articulu, vi cunsigliu assai di leghje , perchè Quì ùn aghju micca più nantu à i principii di basa di a custruzione di bot.
In questu articulu, migliurà l'usabilità di u nostru bot aghjunghjendu un teclatu, chì farà l'interfaccia di bot intuitiva è faciule d'utilizà.
Tutti l'articuli di a serie "Scrivu un telegram bot in R"
Cuntenuti
Sè vo site interessatu in l'analisi di dati, pudete esse interessatu in u mo и canali. A maiò parte di u cuntenutu hè dedicatu à a lingua R.
3.1.
3.2.
3.3.
Chì tipi di tastiere supporta u telegram bot?
À u mumentu di sta scrittura telegram.bot permette di creà dui tipi di tastiere:
- Rispondi - U teclatu principale, regulare, chì si trova sottu à u pannellu di input di testu di u messagiu. Un tali teclatu simpricimenti manda un missaghju di testu à u bot, è cum'è u testu hà da mandà u testu chì hè scrittu nantu à u buttone stessu.
- Inline - Tastiera assuciata à un missaghju bot specificu. Stu teclatu manda i dati di u bot assuciatu cù u buttone pressatu sta dati pò esse diffirenti da u testu scrittu nantu à u buttone stessu. E tali buttoni sò processati attraversu CallbackQueryHandler.
Per chì u bot apre u teclatu, hè necessariu di mandà un missaghju per mezu di u metudu sendMessage(), passa u teclatu creatu prima cum'è argumentu reply_markup.
Quì sottu avemu da fighjulà parechji esempi.
Tastiera di risposta
Cumu aghju scrittu sopra, questu hè u teclatu di cuntrollu di bot principale.
Un esempiu di creazione di un teclatu Rispondi da l'aiutu ufficiale
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)U sopra hè un esempiu da l'aiutu ufficiale di u pacchettu telegram.bot. Per creà un teclatu, utilizate a funzione ReplyKeyboardMarkup(), chì à u turnu piglia una lista di listi di buttoni chì sò creati da a funzione KeyboardButton().
Perchè in ReplyKeyboardMarkup() Avete bisognu di passà micca solu una lista, ma una lista di listi? U fattu hè chì passate a lista principale, è in ella definisce ogni fila di buttoni in listi separati, perchè Pudete mette parechji buttoni in una fila.
argumentu resize_keyboard permette di selezziunà automaticamente a dimensione ottima di i buttoni di u teclatu, è l'argumentu one_time_keyboard permette di ammuccià u teclatu dopu à ogni buttone.
Scrivemu un bot simplice chì avarà 3 buttoni:
- ID di chat - Richiede l'ID di chat di dialogu cù u bot
- U mo nome - Richiede u vostru nome
- U mo login - Richiede u vostru nome d'utilizatore in telegram
Codice 1: Bot simplice cù tastiera Rispondi
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()Eseguite l'esempiu di codice sopra, dopu avè rimpiazzatu "TU TOKEN BOT" cù u token reale chì avete ricevutu quandu crea u bot via BotPather (Aghju parlatu di creà un bot in ).
Dopu avè lanciatu, dà un cumandamentu à u bot /start, perchè Questu hè esattamente ciò chì avemu definitu per lancià u teclatu.
Se à u mumentu hè difficiule per voi di analizà l'esempiu di codice datu, cù a creazione di metudi, filtri è manipolatori, allura duvete vultà à u precedente. , in quale aghju descrittu tuttu questu in dettu.
Avemu creatu 4 metudi:
- start - Lanciari u teclatu
- chat_id - Richiede l'ID di chat
- my_name - Richiede u vostru nome
- my_username - Richiede u vostru login
Per ughjettu MessageFilters aghjustatu 3 filtri di messagi basatu nantu à u so testu:
- chat_id - Missaghji cù testu
"Чат ID" - nome - Missaghji cù testu
"Моё имя" - username - Missaghji cù testu
"Мой логин"
E avemu criatu 4 handlers chì, basatu nantu à cumandamenti dati è filtri, eseguisce i metudi specificati.
# создаём обработчики
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)U teclatu stessu hè creatu in u metudu start() squadra ReplyKeyboardMarkup().
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Чат ID")),
list(KeyboardButton("Моё имя")),
list(KeyboardButton("Мой логин"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)In u nostru casu, avemu pusatu tutti i buttoni sottu à l'altru, ma pudemu organizà in una fila facendu cambiamenti à a lista di listi di buttone. Perchè una fila in u teclatu hè creata per mezu di una lista nidificata di buttoni, dopu per vede i nostri buttoni in una fila, avemu bisognu di riscrive una parte di u codice per custruisce u teclatu cusì:
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Чат ID"),
KeyboardButton("Моё имя"),
KeyboardButton("Мой логин")
)
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
U teclatu hè mandatu à u chat cù u metudu sendMessage(), in l'argumentu reply_markup.
bot$sendMessage(update$message$chat_id,
text = 'Выберите команду',
reply_markup = RKM)Tastiera in linea
Cumu aghju scrittu sopra, u teclatu Inline hè ligatu à un missaghju specificu. Hè un pocu più difficiule di travaglià cù u teclatu principale.
In principiu, avete bisognu di aghjunghje un metudu à u bot per chjamà u teclatu Inline.
Per risponde à un clic di buttone Inline, pudete puru aduprà u metudu bot answerCallbackQuery(), chì ponu vede una notificazione in l'interfaccia di telegramma à l'utilizatore chì pressu u buttone Inline.
I dati mandati da u buttone Inline ùn sò micca testu, cusì per processà, avete bisognu di creà un gestore speciale cù u cumandimu CallbackQueryHandler().
U codice per custruisce un teclatu Inline chì hè datu in l'aiutu ufficiale di u pacchettu telegram.bot.
Codice per custruisce un teclatu Inline da l'aiutu 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)Avete bisognu di custruisce un teclatu Inline cù u cumandimu InlineKeyboardMarkup(), nantu à u listessu principiu cum'è u teclatu Rispondi. IN InlineKeyboardMarkup() hè necessariu di passà una lista di listi di i buttoni Inline, ogni buttone individuali hè creatu da a funzione InlineKeyboardButton().
Un buttone in linea pò passà qualchì dati à u bot utilizendu un argumentu callback_data, o apre ogni pagina HTML specificata cù l'argumentu url.
U risultatu serà una lista in quale ogni elementu hè ancu una lista di i buttoni Inline chì deve esse cumminati in una fila.
In seguitu, fighjemu parechji esempi di bots cù i buttoni Inline.
Un esempiu di un bot simplice cù supportu per i buttoni InLine
Prima, scriveremu un bot per a prova espressa per covid-19. Per cumanda /test, vi manderà un teclatu cù dui buttoni, secondu u buttone pressatu vi manderà un missaghju cù i risultati di a vostra prova.
Code 2: U bot più simplice cù un teclatu Inline
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()Eseguite l'esempiu di codice sopra, dopu avè rimpiazzatu "TU TOKEN BOT" cù u token reale chì avete ricevutu quandu crea u bot via BotPather (Aghju parlatu di creà un bot in ).
Risultatu:
Avemu criatu dui metudi:
- francese test - Per mandà à chat Inline keyboard
- risposta_cb - Per processà i dati mandati da u teclatu.
I dati chì saranu mandati da ogni buttone hè specificatu in l'argumentu callback_data, quandu crea un buttone. Pudete riceve i dati mandati da u buttone cù a custruzzione update$callback_query$data, Dentru u metudu risposta_cb.
Per u bot per reagisce à u teclatu Inline, metudu risposta_cb trattatu da un gestore speciale: CallbackQueryHandler(answer_cb). Chì corre u metudu specificatu quandu u buttone Inline hè clicatu. Manipulatore CallbackQueryHandler piglia dui argumenti:
callback- U metudu chì deve esse eseguitupattern- Filtrà per dati chì sò ligati à u buttone cù un argumentucallback_data.
Per quessa, usendu l'argumentu pattern Pudemu scrive un metudu separatu per pressu ogni buttone:
Code 3: Separate metudi per ogni buttone Inline
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()Eseguite l'esempiu di codice sopra, dopu avè rimpiazzatu "TU TOKEN BOT" cù u token reale chì avete ricevutu quandu crea u bot via BotPather (Aghju parlatu di creà un bot in ).
Avà avemu scrittu 2 metudi separati i.e. un mètudu, per ogni buttone buttone, è usatu l 'argumentu pattern, quandu creanu i so gestori:
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')U codice di u metudu finisce risposta_cb squadra bot$answerCallbackQuery(callback_query_id = update$callback_query$id), chì dice à u bot chì i dati da u teclatu inline sò stati ricevuti.
Un esempiu di un bot chì informa u tempu attuale per una cità scelta
Pruvemu di scrive un bot chì dumanda dati climatichi.
A logica di u so travagliu serà a siguenti. In principiu da a squadra /start chjamate u teclatu principale, chì hà solu un buttone "Weather". Cliccà nant'à stu buttone riceverete un missaghju cù u teclatu Inline per selezziunà a cità per quale vulete sapè u clima attuale. Sceglite una di e cità è uttene u clima attuale.
In questu esempiu di codice useremu parechji pacchetti supplementari:
httr- un pacchettu per travaglià cù richieste HTTP, nantu à a basa di quale u travagliu cù qualsiasi API hè custruitu. In u nostru casu avemu aduprà l'API gratuitu .stringr- un pacchettu per travaglià cù u testu, in u nostru casu avemu da aduprà per generà un missaghju nantu à u clima in a cità scelta.
Codice 4: Un bot chì informa u clima attuale per a cità scelta
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()Eseguite l'esempiu di codice sopra, dopu avè rimpiazzatu "TU TOKEN BOT" cù u token reale chì avete ricevutu quandu crea u bot via BotPather (Aghju parlatu di creà un bot in ).
In u risultatu, u nostru bot hà da travaglià qualcosa cum'è questu:
Schematicamente, stu bot pò esse rapprisintatu cusì:
Avemu creatu 3 metudi dispunibili in u nostru bot meteorologicu:
- Partendu - Lanciate u teclatu principale di u bot
- camping - Lanciate u teclatu Inline per selezziunà una cità
- risposta_cb - U metudu principale chì dumanda u clima da l'API per una cità determinata è u manda à u chat.
Metu Partendu lanciamu cù u cumandamentu /start, chì hè implementatu da u gestore CommandHandler('start', start).
Per eseguisce un metudu camping avemu creatu un filtru di u listessu nome:
# создаём фильтры
## сообщения с текстом Погода
MessageFilters$weather <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Погода"
}
)E chjamemu stu metudu cù u seguente gestore di missaghju: MessageHandler(weather, filters = MessageFilters$weather).
È à a fine, u nostru mètudu principale risposta_cb reagisce à pressu i buttoni Inline, chì hè implementatu da un gestore speciale: CallbackQueryHandler(answer_cb).
Dentru un mètudu risposta_cb, leghjemu i dati mandati da u teclatu è scrivemu à una variàbile city: city <- update$callback_query$data. Allora dumandemu dati climatichi da l'API, generà è mandà un missaghju, è infine aduprà u metudu answerCallbackQuery per informà u bot chì avemu trattatu u clicu di u buttone Inline.
Un esempiu di un bot chì mostra una lista di l'ultimi articuli cù ligami à u Hub specificatu da .
Prestu stu bot per mostrà cumu fà vede i buttoni Inline chì portanu à e pagine web.
A logica di stu bot hè simile à u precedente inizialmente lanciamu u teclatu principale cù u cumandimu /start. In seguitu, u bot ci dà una lista di 6 hubs per sceglie, selezziunate u hub chì ci interessa, è riceve e publicazioni 5 più recenti da u Hub sceltu.
Comu capisci, in questu casu avemu bisognu di ottene una lista di articuli, è per questu avemu aduprà un pacchettu speciale habR, chì permette di dumandà articuli da Habra è alcune statistiche nantu à elli in R.
Installa u pacchettu habR solu pussibule da github, per quale avete bisognu di un pacchettu supplementu devtools. Per installà, utilizate u codice sottu.
install.packages('devtools')
devtools::install_github('selesnow/habR')Avà fighjemu u codice per custruisce u bot descrittu sopra:
Code 5: Un bot chì mostra una lista di l'articuli più recenti nantu à u Hub sceltu
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()Eseguite l'esempiu di codice sopra, dopu avè rimpiazzatu "TU TOKEN BOT" cù u token reale chì avete ricevutu quandu crea u bot via BotPather (Aghju parlatu di creà un bot in ).
In u risultatu, uttene stu risultatu:
Hardcoded a lista di Hubs dispunibuli per a selezzione in u metudu 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)
}Avemu una lista di articuli da u Hub specificatu cù u cumandimu habr_hub_posts(), da u pacchettu habR. À u listessu tempu, signalemu chì ùn avemu micca bisognu di una lista di articuli per tuttu u tempu, ma solu a prima pagina in quale 20 articuli sò situati. Da a tavola resultanti usendu u cumandimu head() Lascemu solu i primi 5, chì sò l'articuli più recenti.
# парсим Хабр
posts <- head(habr_hub_posts(hub, 1), 5)A logica hè assai simili à u bot precedente, ma in questu casu generà un teclatu Inline cù una lista di articuli dinamicamente utilizendu a funzione lapply().
# формируем список кнопок
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# формируем клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)Inseremu u titulu di l'articulu in u testu di u buttone posts$title[x], è in l'argumentu url ligame à l'articulu: url = posts$link[x].
In seguitu, avemu criatu un filtru, i gestori è lanciamu u nostru bot.
cunchiusioni
Avà i bots chì scrivite seranu assai più convenienti à utilizà, per via di u fattu chì seranu cuntrullati da u teclatu, piuttostu cà d'entre cumandamenti. À u minimu, quandu interagisce cù un bot via un smartphone, u teclatu simplificà significativamente u prucessu di usu.
In u prossimu articulu avemu da capisce cumu fà un dialogu logicu cù un bot è travaglià cù basa di dati.
Source: www.habr.com