Toto je třetí článek ze série „Psaní telegramového robota v R“. V předchozích publikacích jsme se naučili, jak vytvořit telegramového robota, posílat přes něj zprávy, přidávat příkazy a filtry zpráv do robota. Než tedy začnete číst tento článek, vřele doporučuji přečíst , protože Zde se již nebudu zdržovat dříve popsanými základy stavby botů.
V tomto článku vylepšíme použitelnost našeho robota přidáním klávesnice, díky které bude rozhraní robota intuitivní a snadno použitelné.
Všechny články ze série „Psaní telegramového robota v R“
Obsah
Pokud vás zajímá analýza dat, mohla by vás zajímat moje и kanály. Většina obsahu je věnována jazyku R.
3.1.
3.2.
3.3.
Jaké typy klávesnic podporuje telegramový bot?
V době psaní tohoto článku telegram.bot umožňuje vytvořit dva typy klávesnic:
- Odpověď – Hlavní, běžná klávesnice, která se nachází pod panelem pro zadávání textu zprávy. Taková klávesnice jednoduše pošle textovou zprávu botovi a jako text odešle text, který je napsán na samotném tlačítku.
- Inline – klávesnice spojená s konkrétní zprávou robota. Tato klávesnice odesílá data robota spojená se stisknutým tlačítkem; tato data se mohou lišit od textu napsaného na samotném tlačítku. A taková tlačítka jsou zpracována skrz CallbackQueryHandler.
Aby bot mohl otevřít klávesnici, je to nutné při odesílání zprávy prostřednictvím metody sendMessage(), předejte dříve vytvořenou klávesnici jako argument reply_markup.
Níže se podíváme na několik příkladů.
Klávesnice odpovědi
Jak jsem psal výše, jedná se o hlavní klávesnici pro ovládání botů.
Příklad vytvoření Reply klávesnice z oficiální nápovědy
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)Výše uvedené je příklad z oficiální nápovědy balíčku telegram.bot. Chcete-li vytvořit klávesnici, použijte funkci ReplyKeyboardMarkup(), který zase přebírá seznam seznamů tlačítek vytvořených funkcí KeyboardButton().
Proč v ReplyKeyboardMarkup() Potřebujete předat nejen seznam, ale i seznam seznamů? Faktem je, že předáte hlavní seznam a v něm definujete každý řádek tlačítek v samostatných seznamech, protože Do jedné řady můžete umístit několik tlačítek.
argument resize_keyboard umožňuje automaticky vybrat optimální velikost tlačítek klávesnice a argument one_time_keyboard umožňuje skrýt klávesnici po každém stisknutí tlačítka.
Pojďme napsat jednoduchého robota, který bude mít 3 tlačítka:
- ID chatu – Vyžádejte si ID chatu pro dialog s robotem
- Moje jméno – Vyžádejte si své jméno
- Moje přihlašovací údaje - Vyžádejte si své uživatelské jméno v telegramu
Kód 1: Jednoduchý robot s odpovědní klávesnicí
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()Spusťte výše uvedený příklad kódu poté, co nahradíte „VÁŠ BOT TOKEN“ skutečným tokenem, který jste obdrželi při vytváření robota prostřednictvím Oba Otec (Mluvil jsem o vytvoření robota v ).
Po spuštění dejte robotovi příkaz /start, protože To je přesně to, co jsme definovali pro spuštění klávesnice.
Pokud je pro vás v tuto chvíli obtížné analyzovat daný příklad kódu s vytvářením metod, filtrů a handlerů, měli byste se vrátit k předchozímu , ve kterém jsem to vše podrobně popsal.
Vytvořili jsme 4 metody:
- start — Spuštění klávesnice
- chat_id — Vyžádání ID chatu
- my_name — Vyžádejte si své jméno
- my_username — Vyžádejte si přihlašovací údaje
Namítat MessageFilters přidány 3 filtry zpráv na základě jejich textu:
- chat_id — zprávy s textem
"Чат ID" - jméno — Zprávy s textem
"Моё имя" - uživatelské jméno — Zprávy s textem
"Мой логин"
A vytvořili jsme 4 handlery, které na základě daných příkazů a filtrů budou provádět zadané metody.
# создаём обработчики
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)Samotná klávesnice je vytvořena uvnitř metody start() tým ReplyKeyboardMarkup().
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Чат ID")),
list(KeyboardButton("Моё имя")),
list(KeyboardButton("Мой логин"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)V našem případě jsme všechna tlačítka umístili pod sebe, ale můžeme je uspořádat do jedné řady provedením změn v seznamu seznamů tlačítek. Protože jeden řádek uvnitř klávesnice je vytvořen prostřednictvím vnořeného seznamu tlačítek, pak abychom mohli zobrazit naše tlačítka v jednom řádku, musíme přepsat část kódu pro konstrukci klávesnice takto:
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Чат ID"),
KeyboardButton("Моё имя"),
KeyboardButton("Мой логин")
)
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
Klávesnice je odeslána do chatu pomocí metody sendMessage(), v argumentu reply_markup.
bot$sendMessage(update$message$chat_id,
text = 'Выберите команду',
reply_markup = RKM)Inline klávesnice
Jak jsem psal výše, Inline klávesnice je vázána na konkrétní zprávu. Práce s ní je poněkud obtížnější než s hlavní klávesnicí.
Zpočátku musíte do robota přidat metodu pro volání inline klávesnice.
Chcete-li reagovat na kliknutí na tlačítko Inline, můžete také použít metodu bota answerCallbackQuery(), který může zobrazit upozornění v rozhraní telegramu uživateli, který stiskne tlačítko Inline.
Data odeslaná z tlačítka Inline nejsou textová, takže pro jejich zpracování je třeba vytvořit speciální handler pomocí příkazu CallbackQueryHandler().
Kód pro sestavení Inline klávesnice, který je uveden v oficiální nápovědě k balíčku telegram.bot.
Kód pro sestavení inline klávesnice z oficiální nápovědy
# 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)Pomocí příkazu musíte sestavit vloženou klávesnici InlineKeyboardMarkup(), na stejném principu jako klávesnice Reply. V InlineKeyboardMarkup() je nutné předat seznam seznamů Inline tlačítek, každé jednotlivé tlačítko je vytvořeno funkcí InlineKeyboardButton().
Vložené tlačítko může buď předat některá data robotu pomocí argumentu callback_datanebo otevřete libovolnou stránku HTML zadanou pomocí argumentu url.
Výsledkem bude seznam, ve kterém je každý prvek zároveň seznamem Inline tlačítek, která je potřeba sloučit do jednoho řádku.
Dále se podíváme na několik příkladů robotů s tlačítky Inline.
Příklad jednoduchého bota s podporou tlačítek InLine
Nejprve napíšeme robota pro expresní testování na covid-19. Podle příkazu /test, odešle vám klávesnici se dvěma tlačítky, v závislosti na stisknutém tlačítku vám pošle zprávu s výsledky vašeho testování.
Kód 2: Nejjednodušší robot s inline klávesnicí
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()Spusťte výše uvedený příklad kódu poté, co nahradíte „VÁŠ BOT TOKEN“ skutečným tokenem, který jste obdrželi při vytváření robota prostřednictvím Oba Otec (Mluvil jsem o vytvoření robota v ).
Výsledek:
Vytvořili jsme dvě metody:
- test — Chcete-li odeslat do chatu Inline klávesnice
- answer_cb — Pro zpracování dat odeslaných z klávesnice.
Data, která budou odeslána z každého tlačítka, jsou specifikována v argumentu callback_data, při vytváření tlačítka. Data odeslaná z tlačítka můžete přijímat pomocí konstruktu update$callback_query$data, uvnitř metody answer_cb.
Aby robot reagoval na vloženou klávesnici, metoda answer_cb zpracovává speciální manipulátor: CallbackQueryHandler(answer_cb). Která spustí zadanou metodu po kliknutí na tlačítko Inline. Psovod CallbackQueryHandler bere dva argumenty:
callback— Metoda, kterou je třeba spustitpattern— Filtrujte podle dat, která jsou vázána na tlačítko pomocí argumentucallback_data.
V souladu s tím pomocí argumentu pattern Pro stisknutí každého tlačítka můžeme napsat samostatnou metodu:
Kód 3: Samostatné metody pro každé tlačítko 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()Spusťte výše uvedený příklad kódu poté, co nahradíte „VÁŠ BOT TOKEN“ skutečným tokenem, který jste obdrželi při vytváření robota prostřednictvím Oba Otec (Mluvil jsem o vytvoření robota v ).
Nyní jsme napsali 2 samostatné metody tj. jedna metoda, pro každé stisknutí tlačítka, a použitý argument pattern, při vytváření jejich ovladačů:
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')Kód metody končí answer_cb tým bot$answerCallbackQuery(callback_query_id = update$callback_query$id), který robotovi sdělí, že byla přijata data z inline klávesnice.
Příklad robota, který hlásí aktuální počasí pro vybrané město
Zkusme napsat robota, který požaduje data o počasí.
Logika jeho práce bude následující. Zpočátku týmem /start zavoláte hlavní klávesnici, která má pouze jedno tlačítko „Počasí“. Kliknutím na toto tlačítko obdržíte zprávu pomocí klávesnice Inline pro výběr města, pro které chcete zjistit aktuální počasí. Vyberte jedno z měst a získejte aktuální počasí.
V tomto příkladu kódu použijeme několik dalších balíčků:
httr— balíček pro práci s HTTP požadavky, na jehož základě je postavena práce s libovolným API. V našem případě použijeme bezplatné API .stringr— balíček pro práci s textem, v našem případě jej využijeme pro vygenerování zprávy o počasí ve vybraném městě.
Kód 4: Robot, který hlásí aktuální počasí pro vybrané město
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()Spusťte výše uvedený příklad kódu poté, co nahradíte „VÁŠ BOT TOKEN“ skutečným tokenem, který jste obdrželi při vytváření robota prostřednictvím Oba Otec (Mluvil jsem o vytvoření robota v ).
V důsledku toho bude náš robot fungovat nějak takto:
Schematicky lze tento robot znázornit takto:
Vytvořili jsme 3 metody dostupné v našem meteorologickém robotu:
- Začít — Spusťte hlavní klávesnici robota
- počasí — Spusťte Inline klávesnici a vyberte město
- answer_cb — Hlavní metoda, která si vyžádá počasí z API pro dané město a odešle je do chatu.
metoda Začít spustíme jej příkazem /start, který je implementován handlerem CommandHandler('start', start).
Chcete-li spustit metodu počasí vytvořili jsme filtr se stejným názvem:
# создаём фильтры
## сообщения с текстом Погода
MessageFilters$weather <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Погода"
}
)A tuto metodu voláme s následující obslužnou rutinou zpráv: MessageHandler(weather, filters = MessageFilters$weather).
A nakonec naše hlavní metoda answer_cb reaguje na stisknutí tlačítek Inline, což je implementováno speciálním handlerem: CallbackQueryHandler(answer_cb).
Uvnitř metody answer_cb, načteme data odeslaná z klávesnice a zapíšeme je do proměnné city: city <- update$callback_query$data. Poté si z API vyžádáme data o počasí, vygenerujeme a odešleme zprávu a nakonec metodu použijeme answerCallbackQuery abychom robota informovali, že jsme zpracovali kliknutí na tlačítko Inline.
Příklad robota, který zobrazuje seznam nejnovějších článků s odkazy na zadaný Hub .
Představuji tohoto robota, abych vám ukázal, jak zobrazit tlačítka Inline, která vedou na webové stránky.
Logika tohoto robota je podobná jako u předchozího, nejprve spustíme hlavní klávesnici příkazem /start. Dále nám bot dá seznam 6 hub, ze kterých si můžeme vybrat, vybereme hub, který nás zajímá, a obdržíme 5 nejnovějších publikací z vybraného Hubu.
Jak jste pochopili, v tomto případě potřebujeme získat seznam článků, a k tomu použijeme speciální balíček habR, která vám umožňuje požadovat články od Habra a některé statistiky k nim v R.
Nainstalujte balíček habR možné pouze z githubu, ke kterému budete potřebovat další balíček devtools. K instalaci použijte níže uvedený kód.
install.packages('devtools')
devtools::install_github('selesnow/habR')Nyní se podívejme na kód pro sestavení robota popsaného výše:
Kód 5: Robot, který zobrazuje seznam nejnovějších článků ve vybraném centru
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()Spusťte výše uvedený příklad kódu poté, co nahradíte „VÁŠ BOT TOKEN“ skutečným tokenem, který jste obdrželi při vytváření robota prostřednictvím Oba Otec (Mluvil jsem o vytvoření robota v ).
V důsledku toho dostaneme tento výsledek:
Pevně jsme zakódovali seznam rozbočovačů dostupných pro výběr v 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)
}Příkazem získáme seznam článků ze zadaného Hubu habr_hub_posts(), z balíčku habR. Zároveň upozorňujeme, že nepotřebujeme seznam článků na celou dobu, ale pouze první stránku, na které se nachází 20 článků. Z výsledné tabulky pomocí příkazu head() Necháme pouze 5 nejlepších, což jsou nejnovější články.
# парсим Хабр
posts <- head(habr_hub_posts(hub, 1), 5)Logika je velmi podobná předchozímu botovi, ale v tomto případě generujeme Inline klávesnici se seznamem článků dynamicky pomocí funkce lapply().
# формируем список кнопок
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# формируем клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)Do textu tlačítka vložíme nadpis článku posts$title[x]a v argumentu url odkaz na článek: url = posts$link[x].
Dále vytvoříme filtr, handlery a spustíme našeho robota.
Závěr
Nyní bude použití robotů, které píšete, mnohem pohodlnější, protože budou řízeni z klávesnice, spíše než zadáváním příkazů. Minimálně při interakci s botem prostřednictvím smartphonu klávesnice výrazně zjednoduší proces používání.
V příštím článku přijdeme na to, jak vybudovat logický dialog s botem a pracovat s databázemi.
Zdroj: www.habr.com