Dies ist der dritte Artikel in der Reihe „Einen Telegram-Bot in R schreiben“. In früheren Veröffentlichungen haben wir gelernt, wie man einen Telegramm-Bot erstellt, Nachrichten darüber sendet und dem Bot Befehle und Nachrichtenfilter hinzufügt. Bevor Sie mit der Lektüre dieses Artikels beginnen, empfehle ich Ihnen daher dringend, ihn zu lesen , Weil Hier werde ich nicht mehr auf die zuvor beschriebenen Grundlagen des Bot-Buildings eingehen.
In diesem Artikel verbessern wir die Benutzerfreundlichkeit unseres Bots, indem wir eine Tastatur hinzufügen, die die Bot-Oberfläche intuitiv und benutzerfreundlich macht.
Alle Artikel aus der Serie „Einen Telegram-Bot in R schreiben“
Inhalt
Wenn Sie sich für Datenanalyse interessieren, könnten Sie an meiner interessiert sein и Kanäle. Der größte Teil des Inhalts ist der R-Sprache gewidmet.
3.1
3.2
3.3
Welche Tastaturtypen unterstützt der Telegram-Bot?
Zum Zeitpunkt des Schreibens telegram.bot ermöglicht Ihnen, zwei Arten von Tastaturen zu erstellen:
- Antwort – Die normale Haupttastatur, die sich unter dem Nachrichtentext-Eingabefeld befindet. Eine solche Tastatur sendet einfach eine Textnachricht an den Bot und als Text sendet dieser den Text, der auf die Schaltfläche selbst geschrieben ist.
- Inline – Tastatur, die einer bestimmten Bot-Nachricht zugeordnet ist. Diese Tastatur sendet die Bot-Daten, die mit der gedrückten Taste verknüpft sind; diese Daten können von dem auf der Taste selbst geschriebenen Text abweichen. Und solche Schaltflächen werden verarbeitet CallbackQueryHandler.
Damit der Bot die Tastatur öffnen kann, ist es beim Senden einer Nachricht über die Methode erforderlich sendMessage(), übergeben Sie die zuvor erstellte Tastatur als Argument reply_markup.
Im Folgenden betrachten wir einige Beispiele.
Antworttastatur
Wie ich oben geschrieben habe, ist dies die Haupttastatur zur Bot-Steuerung.
Ein Beispiel für die Erstellung einer Antworttastatur aus der offiziellen Hilfe
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)Das Obige ist ein Beispiel aus der offiziellen Hilfe des Pakets telegram.bot. Um eine Tastatur zu erstellen, verwenden Sie die Funktion ReplyKeyboardMarkup(), die wiederum eine Liste von Listen mit Schaltflächen entgegennimmt, die von der Funktion erstellt werden KeyboardButton().
Warum in ReplyKeyboardMarkup() Müssen Sie nicht nur eine Liste, sondern eine Liste von Listen übergeben? Tatsache ist, dass Sie die Hauptliste übergeben und darin jede Reihe von Schaltflächen in separaten Listen definieren, weil Sie können mehrere Schaltflächen in einer Reihe platzieren.
Argument resize_keyboard ermöglicht Ihnen die automatische Auswahl der optimalen Größe der Tastaturtasten und des Arguments one_time_keyboard ermöglicht es Ihnen, die Tastatur nach jedem Tastendruck auszublenden.
Schreiben wir einen einfachen Bot mit drei Schaltflächen:
- Chat-ID – Fordern Sie die Chat-ID des Dialogs mit dem Bot an
- Mein Name – Fordern Sie Ihren Namen an
- Mein Login - Fordern Sie Ihren Benutzernamen per Telegram an
Code 1: Einfacher Bot mit Antworttastatur
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()Führen Sie das obige Codebeispiel aus, nachdem Sie „IHR BOT-TOKEN“ durch das echte Token ersetzt haben, das Sie beim Erstellen des Bots über erhalten haben BotVater (Ich habe über die Erstellung eines Bots gesprochen ).
Geben Sie dem Bot nach dem Start einen Befehl /start, Weil Genau das haben wir definiert, um die Tastatur zu starten.
Wenn es für Sie im Moment schwierig ist, das angegebene Codebeispiel mit der Erstellung von Methoden, Filtern und Handlern zu analysieren, sollten Sie zum vorherigen zurückkehren , in dem ich das alles ausführlich beschrieben habe.
Wir haben 4 Methoden erstellt:
- start – Starten Sie die Tastatur
- chat_id – Chat-ID anfordern
- mein_name – Fordern Sie Ihren Namen an
- mein_Benutzername – Fordern Sie Ihr Login an
Einspruch erheben Nachrichtenfilter 3 Nachrichtenfilter basierend auf ihrem Text hinzugefügt:
- chat_id – Nachrichten mit Text
"Чат ID" - Name – Nachrichten mit Text
"Моё имя" - Benutzername – Nachrichten mit Text
"Мой логин"
Und wir haben 4 Handler erstellt, die basierend auf gegebenen Befehlen und Filtern die angegebenen Methoden ausführen.
# создаём обработчики
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)Die Tastatur selbst wird innerhalb der Methode erstellt start() Team ReplyKeyboardMarkup().
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Чат ID")),
list(KeyboardButton("Моё имя")),
list(KeyboardButton("Мой логин"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)In unserem Fall haben wir alle Schaltflächen untereinander platziert, aber wir können sie in einer Zeile anordnen, indem wir Änderungen an der Liste der Schaltflächenlisten vornehmen. Weil Eine Zeile innerhalb der Tastatur wird durch eine verschachtelte Liste von Schaltflächen erstellt. Um unsere Schaltflächen in einer Zeile anzuzeigen, müssen wir einen Teil des Codes für den Aufbau der Tastatur wie folgt umschreiben:
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Чат ID"),
KeyboardButton("Моё имя"),
KeyboardButton("Мой логин")
)
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
Die Tastatur wird mit der Methode an den Chat gesendet sendMessage(), im Argument reply_markup.
bot$sendMessage(update$message$chat_id,
text = 'Выберите команду',
reply_markup = RKM)Inline-Tastatur
Wie ich oben geschrieben habe, ist die Inline-Tastatur an eine bestimmte Nachricht gebunden. Es ist etwas schwieriger zu bedienen als die Haupttastatur.
Zunächst müssen Sie dem Bot eine Methode hinzufügen, um die Inline-Tastatur aufzurufen.
Um auf einen Klick auf eine Inline-Schaltfläche zu reagieren, können Sie auch die Bot-Methode verwenden answerCallbackQuery(), das dem Benutzer, der die Inline-Taste drückt, eine Benachrichtigung in der Telegrammschnittstelle anzeigen kann.
Die von der Inline-Schaltfläche gesendeten Daten sind kein Text. Um sie zu verarbeiten, müssen Sie mit dem Befehl einen speziellen Handler erstellen CallbackQueryHandler().
Der Code zum Erstellen einer Inline-Tastatur, der in der offiziellen Hilfe des Pakets enthalten ist telegram.bot.
Code zum Erstellen einer Inline-Tastatur aus der offiziellen Hilfe
# 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)Sie müssen mit dem Befehl eine Inline-Tastatur erstellen InlineKeyboardMarkup(), nach dem gleichen Prinzip wie die Antworttastatur. IN InlineKeyboardMarkup() Es ist notwendig, eine Liste mit Listen von Inline-Schaltflächen zu übergeben. Jede einzelne Schaltfläche wird von der Funktion erstellt InlineKeyboardButton().
Eine Inline-Schaltfläche kann entweder mithilfe eines Arguments einige Daten an den Bot übergeben callback_data, oder öffnen Sie eine beliebige HTML-Seite, die mit dem Argument angegeben wird url.
Das Ergebnis ist eine Liste, in der jedes Element auch eine Liste von Inline-Schaltflächen ist, die in einer Zeile zusammengefasst werden müssen.
Als nächstes schauen wir uns einige Beispiele für Bots mit Inline-Buttons an.
Ein Beispiel für einen einfachen Bot mit Unterstützung für InLine-Schaltflächen
Zuerst werden wir einen Bot für Expresstests auf Covid-19 schreiben. Auf Befehl /test, erhalten Sie eine Tastatur mit zwei Tasten. Abhängig von der gedrückten Taste erhalten Sie eine Nachricht mit den Ergebnissen Ihres Tests.
Code 2: Der einfachste Bot mit einer Inline-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()Führen Sie das obige Codebeispiel aus, nachdem Sie „IHR BOT-TOKEN“ durch das echte Token ersetzt haben, das Sie beim Erstellen des Bots über erhalten haben BotVater (Ich habe über die Erstellung eines Bots gesprochen ).
Ergebnis:
Wir haben zwei Methoden erstellt:
- Test — Zum Senden an den Chat Inline-Tastatur
- Antwort_cb — Um von der Tastatur gesendete Daten zu verarbeiten.
Die Daten, die von jeder Schaltfläche gesendet werden, werden im Argument angegeben callback_data, beim Erstellen einer Schaltfläche. Sie können die von der Schaltfläche gesendeten Daten mithilfe des Konstrukts empfangen update$callback_query$data, innerhalb der Methode Antwort_cb.
Damit der Bot auf die Inline-Tastatur reagiert, Methode Antwort_cb von einem speziellen Handler verarbeitet: CallbackQueryHandler(answer_cb). Dadurch wird die angegebene Methode ausgeführt, wenn auf die Inline-Schaltfläche geklickt wird. Handler CallbackQueryHandler braucht zwei Argumente:
callback– Die Methode, die ausgeführt werden musspattern– Filtern Sie nach Daten, die über ein Argument an die Schaltfläche gebunden sindcallback_data.
Dementsprechend wird das Argument verwendet pattern Wir können eine separate Methode zum Drücken jeder Taste schreiben:
Code 3: Separate Methoden für jede Inline-Schaltfläche
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()Führen Sie das obige Codebeispiel aus, nachdem Sie „IHR BOT-TOKEN“ durch das echte Token ersetzt haben, das Sie beim Erstellen des Bots über erhalten haben BotVater (Ich habe über die Erstellung eines Bots gesprochen ).
Jetzt haben wir zwei separate Methoden geschrieben, d.h. eine Methode für jeden Tastendruck und verwendete das Argument pattern, beim Erstellen ihrer Handler:
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')Der Methodencode endet Antwort_cb Team bot$answerCallbackQuery(callback_query_id = update$callback_query$id), was dem Bot mitteilt, dass Daten von der Inline-Tastatur empfangen wurden.
Ein Beispiel für einen Bot, der das aktuelle Wetter für eine ausgewählte Stadt meldet
Versuchen wir, einen Bot zu schreiben, der Wetterdaten anfordert.
Die Logik seiner Arbeit wird wie folgt sein. Zunächst vom Team /start Sie rufen die Haupttastatur auf, die nur über eine „Wetter“-Taste verfügt. Durch Klicken auf diese Schaltfläche erhalten Sie eine Meldung mit der Inline-Tastatur, in der Sie die Stadt auswählen können, für die Sie das aktuelle Wetter erfahren möchten. Wählen Sie eine der Städte aus und erhalten Sie das aktuelle Wetter.
In diesem Codebeispiel verwenden wir mehrere zusätzliche Pakete:
httr— ein Paket für die Arbeit mit HTTP-Anfragen, auf dessen Grundlage die Arbeit mit jeder API erstellt wird. In unserem Fall verwenden wir die kostenlose API .stringr— ein Paket zum Arbeiten mit Text, in unserem Fall werden wir es verwenden, um eine Nachricht über das Wetter in der ausgewählten Stadt zu generieren.
Code 4: Ein Bot, der das aktuelle Wetter für die ausgewählte Stadt meldet
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()Führen Sie das obige Codebeispiel aus, nachdem Sie „IHR BOT-TOKEN“ durch das echte Token ersetzt haben, das Sie beim Erstellen des Bots über erhalten haben BotVater (Ich habe über die Erstellung eines Bots gesprochen ).
Als Ergebnis wird unser Bot etwa so funktionieren:
Schematisch lässt sich dieser Bot wie folgt darstellen:
Wir haben drei Methoden erstellt, die in unserem Wetter-Bot verfügbar sind:
- Anfang – Starten Sie die Haupt-Bot-Tastatur
- Wetter — Starten Sie die Inline-Tastatur, um eine Stadt auszuwählen
- Antwort_cb – Die Hauptmethode, die das Wetter von der API für eine bestimmte Stadt anfordert und an den Chat sendet.
Verfahren Anfang Wir starten es mit dem Befehl /start, die vom Handler implementiert wird CommandHandler('start', start).
Um eine Methode auszuführen Wetter Wir haben einen gleichnamigen Filter erstellt:
# создаём фильтры
## сообщения с текстом Погода
MessageFilters$weather <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Погода"
}
)Und wir rufen diese Methode mit dem folgenden Nachrichtenhandler auf: MessageHandler(weather, filters = MessageFilters$weather).
Und am Ende unsere Hauptmethode Antwort_cb reagiert auf das Drücken von Inline-Buttons, was durch einen speziellen Handler implementiert wird: CallbackQueryHandler(answer_cb).
Innerhalb einer Methode Antwort_cb, lesen wir die von der Tastatur gesendeten Daten und schreiben sie in eine Variable city: city <- update$callback_query$data. Dann fordern wir Wetterdaten von der API an, generieren und senden eine Nachricht und verwenden schließlich die Methode answerCallbackQuery um den Bot darüber zu informieren, dass wir den Klick auf die Inline-Schaltfläche verarbeitet haben.
Ein Beispiel für einen Bot, der eine Liste der neuesten Artikel mit Links zum angegebenen Hub von anzeigt .
Ich präsentiere diesen Bot, um Ihnen zu zeigen, wie Sie Inline-Schaltflächen anzeigen, die zu Webseiten führen.
Die Logik dieses Bots ähnelt der des vorherigen; zunächst starten wir die Haupttastatur mit dem Befehl /start. Als nächstes gibt uns der Bot eine Liste mit 6 Hubs zur Auswahl, wir wählen den Hub aus, an dem wir interessiert sind, und erhalten die 5 neuesten Veröffentlichungen vom ausgewählten Hub.
Wie Sie wissen, benötigen wir in diesem Fall eine Artikelliste und verwenden dafür ein spezielles Paket habR, mit dem Sie Artikel von Habra und einige Statistiken dazu in R anfordern können.
Installationspaket habR Nur über Github möglich, hierfür benötigen Sie ein zusätzliches Paket devtools. Verwenden Sie zur Installation den folgenden Code.
install.packages('devtools')
devtools::install_github('selesnow/habR')Schauen wir uns nun den Code zum Erstellen des oben beschriebenen Bots an:
Code 5: Ein Bot, der eine Liste der neuesten Artikel auf dem ausgewählten Hub anzeigt
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()Führen Sie das obige Codebeispiel aus, nachdem Sie „IHR BOT-TOKEN“ durch das echte Token ersetzt haben, das Sie beim Erstellen des Bots über erhalten haben BotVater (Ich habe über die Erstellung eines Bots gesprochen ).
Als Ergebnis erhalten wir dieses Ergebnis:
Wir haben die Liste der Hubs, die in der Methode zur Auswahl stehen, fest codiert 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)
}Mit dem Befehl erhalten wir eine Liste der Artikel vom angegebenen Hub habr_hub_posts(), aus der Packung habR. Gleichzeitig weisen wir darauf hin, dass wir keine Artikelliste für die gesamte Zeit benötigen, sondern lediglich die erste Seite, auf der sich 20 Artikel befinden. Aus der resultierenden Tabelle mit dem Befehl head() Wir belassen nur die Top 5, also die aktuellsten Artikel.
# парсим Хабр
posts <- head(habr_hub_posts(hub, 1), 5)Die Logik ist dem vorherigen Bot sehr ähnlich, aber in diesem Fall generieren wir mithilfe der Funktion dynamisch eine Inline-Tastatur mit einer Liste von Artikeln lapply().
# формируем список кнопок
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# формируем клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)Wir fügen den Titel des Artikels in den Button-Text ein posts$title[x], und im Argument url Link zum Artikel: url = posts$link[x].
Als nächstes erstellen wir einen Filter, Handler und starten unseren Bot.
Abschluss
Jetzt sind die von Ihnen geschriebenen Bots viel bequemer zu verwenden, da sie über die Tastatur und nicht durch die Eingabe von Befehlen gesteuert werden. Wenn Sie mit einem Bot über ein Smartphone interagieren, vereinfacht die Tastatur zumindest die Bedienung erheblich.
Im nächsten Artikel werden wir herausfinden, wie man einen logischen Dialog mit einem Bot aufbaut und mit Datenbanken arbeitet.
Source: habr.com