Это третья статья из серии "Пишем telegram бота на языке R". В предыдущих публикациях мы научились создавать телеграм бота, отправлять через него сообщения, добавили боту команды и фильтры сообщений. Поэтому перед тем как приступить к чтению данной статьи я крайне рекомендую ознакомиться с , fordi Her vil jeg ikke længere dvæle ved de tidligere beskrevne grundprincipper i botbygning.
I denne artikel vil vi forbedre brugervenligheden af vores bot ved at tilføje et tastatur, som vil gøre bot-grænsefladen intuitiv og nem at bruge.
Alle artikler fra serien "Skriv en telegrambot i R"
Indhold
Hvis du er interesseret i dataanalyse, er du måske interesseret i min и kanaler. Det meste af indholdet er afsat til R-sproget.
3.1.
3.2.
3.3.
Hvilke typer tastaturer understøtter telegrambot?
I skrivende stund telegram.bot giver dig mulighed for at oprette to typer tastaturer:
- Reply — Основная, обычная клавиатура, которая находится под панелью ввода текста сообщения. Такая клавиатура просто отправляет боту текстовое сообщение, и в качестве текста отправит тот текст, который написан на самой кнопке.
- Inline — Клавиатура привязанная к конкретному сообщению бота. Данная клавиатура отправляет боту данные, привязанные к нажатой кнопке, эти данные могут отличаться от текста, написанного на самой кнопке. И обрабатываются такие кнопки через CallbackQueryHandler.
For at botten kan åbne tastaturet, er det nødvendigt, når du sender en besked gennem metoden sendMessage(), send det tidligere oprettede tastatur som et argument reply_markup.
Ниже мы разберём несколько примеров.
Svar tastatur
Som jeg skrev ovenfor, er dette det vigtigste bot-kontroltastatur.
Пример создания Reply клавиатуры из официальной справки
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)Ovenstående er et eksempel fra pakkens officielle hjælp telegram.bot. For at oprette et tastatur skal du bruge funktionen ReplyKeyboardMarkup(), som igen tager en liste over lister over knapper, der er oprettet af funktionen KeyboardButton().
Hvorfor i ReplyKeyboardMarkup() Har du brug for at bestå ikke bare en liste, men en liste over lister? Faktum er, at du passerer hovedlisten, og i den definerer du hver række af knapper i separate lister, fordi Du kan placere flere knapper i en række.
argument resize_keyboard позволяет автоматически подбирать оптимальный размер кнопок клавиатуры, а аргумент one_time_keyboard giver dig mulighed for at skjule tastaturet efter hvert tryk på en knap.
Lad os skrive en simpel bot, der vil have 3 knapper:
- Chat-id - Anmod om chat-id for dialog med bot
- Mit navn - Anmod om dit navn
- Mit login - Anmod om dit brugernavn i telegram
Kode 1: Simpel bot med svartastatur
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ør kodeeksemplet ovenfor, efter at have erstattet 'DIN BOTTOKEN' med den rigtige token, du modtog, da du oprettede botten via BotFader (Jeg talte om at oprette en bot i ).
Efter lanceringen skal du give botten en kommando /start, fordi Det er præcis, hvad vi definerede for at starte tastaturet.
Hvis det i øjeblikket er svært for dig at parse det givne kodeeksempel med oprettelse af metoder, filtre og handlere, så skal du vende tilbage til den forrige , hvor jeg beskrev alt dette i detaljer.
Vi har lavet 4 metoder:
- start — Start tastaturet
- chat_id — Anmod om chat-id
- mit_navn — Anmod om dit navn
- mit_brugernavn — Anmod om dit login
At gøre indsigelse Meddelelsesfiltre tilføjet 3 beskedfiltre baseret på deres tekst:
- chat_id — Beskeder med tekst
"Чат ID" - navn — Beskeder med tekst
"Моё имя" - brugernavn — Beskeder med tekst
"Мой логин"
Og vi skabte 4 handlere, der, baseret på givne kommandoer og filtre, vil udføre de angivne metoder.
# создаём обработчики
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)Selve tastaturet er lavet inde i metoden start() hold ReplyKeyboardMarkup().
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Чат ID")),
list(KeyboardButton("Моё имя")),
list(KeyboardButton("Мой логин"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)I vores tilfælde placerede vi alle knapperne under hinanden, men vi kan arrangere dem i én række ved at lave ændringer i listen over knaplister. Fordi en række inde i tastaturet oprettes gennem en indlejret liste af knapper, og for at vise vores knapper i en række skal vi omskrive en del af koden til at konstruere tastaturet sådan her:
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Чат ID"),
KeyboardButton("Моё имя"),
KeyboardButton("Мой логин")
)
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
Отправляется клавиатура в чат методом sendMessage(), i argumentationen reply_markup.
bot$sendMessage(update$message$chat_id,
text = 'Выберите команду',
reply_markup = RKM)Inline клавиатура
Som jeg skrev ovenfor, er Inline-tastaturet knyttet til en bestemt besked. Det er noget sværere at arbejde med end hovedtastaturet.
I første omgang skal du tilføje en metode til botten for at kalde det indbyggede tastatur.
For at reagere på et klik på en Inline-knap kan du også bruge bot-metoden answerCallbackQuery(), который может вывести уведомление в интерфейсе telegram, пользователю нажавшему Inline кнопку.
De data, der sendes fra Inline-knappen, er ikke tekst, så for at behandle dem skal du oprette en speciel behandler ved hjælp af kommandoen CallbackQueryHandler().
Koden til at bygge et Inline-tastatur, som er givet i pakkens officielle hjælp telegram.bot.
Kode til at bygge et Inline-tastatur fra den officielle hjælp
# 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)Du skal bygge et Inline-tastatur ved hjælp af kommandoen InlineKeyboardMarkup(), på samme princip som Svar-tastaturet. I InlineKeyboardMarkup() det er nødvendigt at sende en liste over lister over Inline-knapper, hver enkelt knap oprettes af funktionen InlineKeyboardButton().
En inline-knap kan enten sende nogle data til botten ved hjælp af et argument callback_data, eller åbn en HTML-side angivet ved hjælp af argumentet url.
В результате будет список, в котором каждый элемент так же является списком Inline кнопок, которые необходимо объединить в один ряд.
Dernæst vil vi se på flere eksempler på bots med Inline-knapper.
Et eksempel på en simpel bot med understøttelse af InLine-knapper
Først vil vi skrive en bot til eksprestest for covid-19. Ved kommando /test, vil den sende dig et tastatur med to knapper, afhængigt af hvilken knap der trykkes på, vil den sende dig en besked med resultaterne af din test.
Kode 2: Den enkleste bot med et indbygget tastatur
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ør kodeeksemplet ovenfor, efter at have erstattet 'DIN BOTTOKEN' med den rigtige token, du modtog, da du oprettede botten via BotFader (Jeg talte om at oprette en bot i ).
Resultat:
Vi har lavet to metoder:
- prøve — Для отправки в чат Inline клавиатуры
- answer_cb — At behandle data sendt fra tastaturet.
De data, der sendes fra hver knap, er angivet i argumentet callback_data, når du opretter en knap. Du kan modtage data sendt fra knappen ved hjælp af konstruktionen update$callback_query$data, inde i metoden answer_cb.
For at botten skal reagere på det indbyggede tastatur, metode answer_cb behandlet af en særlig behandler: CallbackQueryHandler(answer_cb). Som kører den angivne metode, når der klikkes på Inline-knappen. Handler CallbackQueryHandler tager to argumenter:
callback— Metoden, der skal kørespattern— Фильтр по данным, которые привязаны к кнопке с помощью аргументаcallback_data.
Derfor bruger argumentet pattern Vi kan skrive en separat metode til at trykke på hver knap:
Kode 3: Separate metoder for hver Inline-knap
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ør kodeeksemplet ovenfor, efter at have erstattet 'DIN BOTTOKEN' med den rigtige token, du modtog, da du oprettede botten via BotFader (Jeg talte om at oprette en bot i ).
Nu har vi skrevet 2 separate metoder dvs. én metode, for hvert knaptryk, og brugte argumentet pattern, при создании их обработчиков:
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')Metodekode slutter answer_cb hold bot$answerCallbackQuery(callback_query_id = update$callback_query$id), som fortæller botten, at data fra inline-tastaturet er blevet modtaget.
Пример бота, который сообщает текущую погоду по выбранному городу
Давайте попробуем написать бота, который запрашивает данные о погоде.
Logikken i dets arbejde vil være som følger. I første omgang af holdet /start du kalder hovedtastaturet, som kun har én "Vejr"-knap. Ved at klikke på denne knap vil du modtage en besked med det indbyggede tastatur for at vælge den by, som du ønsker at finde ud af det aktuelle vejr for. Vælg en af byerne og få det aktuelle vejr.
I dette kodeeksempel vil vi bruge flere ekstra pakker:
httr— en pakke til at arbejde med HTTP-anmodninger, på grundlag af hvilken arbejde med enhver API bygges. I vores tilfælde vil vi bruge den gratis API .stringr— en pakke til at arbejde med tekst, i vores tilfælde vil vi bruge den til at generere en besked om vejret i den valgte by.
Kode 4: En bot, der rapporterer det aktuelle vejr for den valgte by
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ør kodeeksemplet ovenfor, efter at have erstattet 'DIN BOTTOKEN' med den rigtige token, du modtog, da du oprettede botten via BotFader (Jeg talte om at oprette en bot i ).
Som et resultat vil vores bot fungere noget som dette:
Skematisk kan denne bot afbildes sådan:
Vi har oprettet 3 metoder tilgængelige i vores vejrbot:
- starte — Start det primære bot-tastatur
- vejr — Start Inline-tastaturet for at vælge en by
- answer_cb — Hovedmetoden, der anmoder om vejret fra API'en for en given by og sender det til chatten.
fremgangsmåde starte у нас запускается командой /start, som implementeres af handleren CommandHandler('start', start).
At køre en metode vejr vi lavede et filter af samme navn:
# создаём фильтры
## сообщения с текстом Погода
MessageFilters$weather <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Погода"
}
)Og vi kalder denne metode med følgende beskedhåndtering: MessageHandler(weather, filters = MessageFilters$weather).
Og i sidste ende vores vigtigste metode answer_cb reagerer på at trykke på Inline-knapper, som implementeres af en speciel handler: CallbackQueryHandler(answer_cb).
Inde i en metode answer_cb, мы считываем отправленные с клавиатуры данные и записываем их в переменную city: city <- update$callback_query$data. Derefter anmoder vi om vejrdata fra API'et, genererer og sender en besked og bruger til sidst metoden answerCallbackQuery for at informere botten om, at vi har behandlet klikket på Inline-knappen.
Et eksempel på en bot, der viser en liste over de seneste artikler med links til den angivne Hub fra .
Jeg præsenterer denne bot for at vise dig, hvordan du viser Inline-knapper, der fører til websider.
Logikken i denne bot ligner den forrige; i første omgang starter vi hovedtastaturet med kommandoen /start. Derefter giver botten os en liste over 6 hubs at vælge imellem, vi vælger den hub vi er interesseret i, og modtager de 5 seneste publikationer fra den valgte hub.
Как вы понимаете, в данном случае нам необходимо получить список статей, и для этого мы будем использовать специальный пакет habR, som giver dig mulighed for at anmode om artikler fra Habra og nogle statistikker om dem i R.
Installer pakken habR kun muligt fra github, som du skal bruge en ekstra pakke til devtools. Brug koden nedenfor for at installere.
install.packages('devtools')
devtools::install_github('selesnow/habR')Lad os nu se på koden til at bygge botten beskrevet ovenfor:
Kode 5: En bot, der viser en liste over de seneste artikler på den valgte Hub
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ør kodeeksemplet ovenfor, efter at have erstattet 'DIN BOTTOKEN' med den rigtige token, du modtog, da du oprettede botten via BotFader (Jeg talte om at oprette en bot i ).
В итоге мы получим вот такой результат:
Vi har hårdkodet listen over Hubs, der er tilgængelige for valg i metoden 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)
}Vi får en liste over artikler fra den angivne Hub med kommandoen habr_hub_posts(), fra pakken habR. Samtidig gør vi opmærksom på, at vi ikke behøver en liste over artikler for hele tiden, men kun den første side, hvorpå 20 artikler er placeret. Fra den resulterende tabel ved hjælp af kommandoen head() Vi efterlader kun top 5, som er de seneste artikler.
# парсим Хабр
posts <- head(habr_hub_posts(hub, 1), 5)Logikken minder meget om den tidligere bot, men i dette tilfælde genererer vi et Inline-tastatur med en liste over artikler dynamisk ved hjælp af funktionen lapply().
# формируем список кнопок
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# формируем клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)Vi indsætter artiklens titel i knapteksten posts$title[x], og i argumentationen url link til artikel: url = posts$link[x].
Dernæst opretter vi et filter, handlere og starter vores bot.
Konklusion
Nu vil de bots, du skriver, være meget mere bekvemme at bruge, på grund af det faktum, at de vil blive styret fra tastaturet, snarere end ved at indtaste kommandoer. Når du interagerer med en bot via en smartphone, vil tastaturet som minimum forenkle processen med at bruge det betydeligt.
I den næste artikel vil vi finde ud af, hvordan man bygger en logisk dialog med en bot og arbejder med databaser.
Kilde: www.habr.com