Dies ist der dritte Artikel in der Reihe "Einen Telegram-Bot in der R-Sprache erstellen". In den vorherigen Veröffentlichungen haben wir gelernt, wie man einen Telegram-Bot erstellt, Nachrichten über ihn sendet, dem Bot Befehle hinzufügt und Nachrichtenfilter implementiert. Daher empfehle ich dringend, sich mit Beiträgen vertraut zu machen, da ich hier nicht auf die zuvor behandelten Grundlagen des Bot-Baus eingehen werde.
In diesem Artikel werden wir die Benutzerfreundlichkeit unseres Bots verbessern, indem wir eine Tastatur hinzufügen, die die Benutzeroberfläche des Bots intuitiv und einfach zu bedienen macht.
Allen Artikeln der Serie "Wir schreiben einen Telegram-Bot in der Programmiersprache R"
Inhalt
Falls Sie sich für Datenanalyse interessieren, könnten meine und Kanäle für Sie von Interesse sein. Der Großteil der Inhalte widmet sich der R-Sprache.
3.1.
3.2.
3.3.
Welche Arten von Tastaturen unterstützt der Telegram-Bot?
Zum Zeitpunkt des Verfassens des Artikels telegram.bot ermöglicht es Ihnen, Tastaturen in zwei Typen zu erstellen:
- Antwort — Die Haupttastatur, die sich unter dem Texteingabefeld befindet. Diese Tastatur sendet einfach eine Textnachricht an den Bot, wobei der Text den Inhalt der Taste widerspiegelt.
- Inline — Eine Tastatur, die an eine bestimmte Nachricht des Bots gebunden ist. Diese Tastatur überträgt Daten, die an die gedrückte Taste gebunden sind. Diese Daten können vom Text auf der Taste abweichen und werden über CallbackQueryHandler.
Um die Tastatur zu öffnen, muss beim Senden einer Nachricht über die Methode sendMessage(), die zuvor erstellte Tastatur als Argument reply_markup.
übergeben werden. Im Folgenden werden einige Beispiele erläutert.
Antwort-Tastatur
Wie bereits erwähnt, ist dies die Haupttastatur zur Steuerung des Bots.
Beispiel zur Erstellung einer Reply-Tastatur aus der offiziellen Dokumentation
bot <- Bot(token = "TOKEN")
chat_id <- "CHAT_ID"
# Benutzerdefinierte Tastatur erstellen
text <- "Sind diese benutzerdefinierten Tastaturen nicht cool?"
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Ja, das sind sie!")),
list(KeyboardButton("Ich bin mir nicht ganz sicher")),
list(KeyboardButton("Nein..."))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# Benutzerdefinierte Tastatur senden
bot$sendMessage(chat_id, text, reply_markup = RKM)Oben ist ein Beispiel aus der offiziellen Dokumentation des Pakets. telegram.bot. Um eine Tastatur zu erstellen, wird die Funktion ReplyKeyboardMarkup()verwendet, die wiederum eine Liste von Listen von Tasten akzeptiert, die mit der Funktion KeyboardButton().
erstellt werden. ReplyKeyboardMarkup() Warum muss man eine Liste von Listen übergeben? Das liegt daran, dass Sie eine Hauptliste übergeben und darin jeweils separate Listen für jede Reihe von Tasten definieren, da in einer Reihe mehrere Tasten angeordnet werden können.
Das Argument resize_keyboard ermöglicht es, die optimale Größe der Tasten automatisch anzupassen, während das Argument one_time_keyboard es erlaubt, die Tastatur nach jedem Drücken einer Taste auszublenden.
Lassen Sie uns einen einfachen Bot schreiben, der drei Tasten hat:
- Chat-ID — Fordern Sie die Chat-ID des Dialogs mit dem Bot an.
- Mein Name — Fordern Sie Ihren Namen an.
- Mein Benutzername — Fordern Sie Ihren Benutzernamen in Telegram an.
Code 1: Einfacher Bot mit einer Reply-Tastatur.
library(telegram.bot)
# Erstellen Sie eine Instanz der Updater-Klasse
updater <- Updater('IHR BOT-TOKEN')
# Erstellen von Methoden
## Methode zum Starten der Tastatur
start <- function(bot, update) {
# Tastatur erstellen
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Chat ID")),
list(KeyboardButton("Mein Name")),
list(KeyboardButton("Mein Benutzername"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# Tastatur senden
bot$sendMessage(update$message$chat_id,
text = 'Wählen Sie einen Befehl',
reply_markup = RKM)
}
## Methode, die die Chat-ID zurückgibt
chat_id <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Chat-ID dieses Dialogs: ", update$message$chat_id),
parse_mode = "Markdown")
}
## Methode, die den Namen zurückgibt
my_name <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Ihr Name ist ", update$message$from$first_name),
parse_mode = "Markdown")
}
## Methode, die den Benutzernamen zurückgibt
my_username <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Ihr Benutzername ist ", update$message$from$username),
parse_mode = "Markdown")
}
# Filters erstellen
## Nachrichten mit dem Text Chat ID
MessageFilters$chat_id <- BaseFilter(function(message) {
# Überprüfen Sie den Nachrichtentext
message$text == "Chat ID"
}
)
## Nachrichten mit dem Text Mein Name
MessageFilters$name <- BaseFilter(function(message) {
# Überprüfen Sie den Nachrichtentext
message$text == "Mein Name"
}
)
## Nachrichten mit dem Text Mein Benutzername
MessageFilters$username <- BaseFilter(function(message) {
# Überprüfen Sie den Nachrichtentext
message$text == "Mein Benutzername"
)
# Handler erstellen
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)
# Handler zum Dispatcher hinzufügen
updater <- updater +
h_start +
h_chat_id +
h_name +
h_username
# Bot starten
updater$start_polling()Starten Sie das oben angeführte Codebeispiel, indem Sie 'IHR BOT-TOKEN' durch das tatsächliche Token ersetzen, das Sie bei der Erstellung des Bots über BotFather erhalten haben (ich habe in ).
beschrieben, wie man einen Bot erstellt) /start. Nach dem Starten geben Sie dem Bot den Befehl
, da wir genau diesen zum Aktivieren der Tastatur definiert haben. Falls Sie im Moment Schwierigkeiten haben, das angegebene Codebeispiel zu verstehen, sollten Sie zu der vorherigen
zurückkehren, in der ich alles ausführlich erklärt habe.
- Wir haben 4 Methoden erstellt:
- start — Tastatur starten
- chat_id — Anfordern der Chat-ID
- my_name — Anfordern Ihres Namens
my_username — Anfordern Ihres Benutzernamens Im Objekt MessageFilters
- haben wir 3 Nachrichtenfilter nach ihrem Text hinzugefügt:
chat_id — Nachrichten mit dem Text - "Chat ID"
name — Nachrichten mit dem Text - "Mein Name"
username — Nachrichten mit dem Text
"Mein Benutzername"
# создаём обработчики
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)Und wir haben 4 Handler erstellt, die je nach den festgelegten Befehlen und Filtern die angegebenen Methoden ausführen. start() mit dem Befehl ReplyKeyboardMarkup().
Die Tastatur selbst wird in der Methode erstelltRKM <- ReplyKeyboardMarkup( keyboard = list( list(KeyboardButton("Chat ID")), list(KeyboardButton("Mein Name")), list(KeyboardButton("Mein Benutzername")) ), resize_keyboard = FALSE, one_time_keyboard = TRUE )
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Chat-ID"),
KeyboardButton("Mein Name"),
KeyboardButton("Mein Login")
)
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
Die Tastatur wird an den Chat mit der Methode gesendet sendMessage(), im Argument reply_markup.
bot$sendMessage(update$message$chat_id,
text = 'Wählen Sie einen Befehl',
reply_markup = RKM)Inline-Tastatur
Wie bereits erwähnt, ist die Inline-Tastatur an eine bestimmte Nachricht gebunden. Ihre Handhabung ist etwas komplizierter als die der Haupttastatur.
Zunächst müssen Sie dem Bot eine Methode hinzufügen, um die Inline-Tastatur aufzurufen.
Um auf das Drücken der Inline-Schaltfläche zu antworten, kann ebenfalls die Methode des Bots verwendet werden answerCallbackQuery(), die eine Benachrichtigung im Telegram-Interface an den Benutzer anzeigen kann, der die Inline-Schaltfläche gedrückt hat.
Die von der Inline-Schaltfläche gesendeten Daten sind kein Text, daher ist es notwendig, einen speziellen Handler mit dem Befehl zu erstellen CallbackQueryHandler().
Der Code zum Erstellen der Inline-Tastatur, der in der offiziellen Documentation des Pakets aufgeführt wird telegram.bot.
Der Code zum Erstellen der Inline-Tastatur aus der offiziellen Dokumentation
# 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)Die Inline-Tastatur muss mit dem Befehl erstellt werden InlineKeyboardMarkup(), ähnlich wie bei der Reply-Tastatur. In InlineKeyboardMarkup() muss eine Liste von Listen von Inline-Schaltflächen übergeben werden, wobei jede einzelne Schaltfläche durch die Funktion InlineKeyboardButton().
Die Inline-Schaltfläche kann entweder dem Bot Daten über den Parameter callback_data, übermitteln oder eine bestimmte HTML-Seite öffnen, die mit dem Parameter definiert ist. url.
Das Ergebnis wird eine Liste sein, in der jedes Element ebenfalls eine Liste von Inline-Schaltflächen ist, die in einer Reihe zusammengefasst werden müssen.
Im Folgenden betrachten wir einige Beispiele von Bots mit Inline-Schaltflächen.
Beispiel eines einfachen Bots mit Unterstützung für Inline-Buttons
Zunächst werden wir einen Bot für den Schnelltest auf Covid-19 schreiben. Auf den Befehl /test, wird er Ihnen eine Tastatur mit zwei Schaltflächen senden, und je nach gedrückter Schaltfläche wird er Ihnen eine Nachricht mit den Testergebnissen zukommen lassen.
Code 2: Einfacher Bot mit Inline-Tastatur
library(telegram.bot)
# Erstellen Sie eine Instanz der Klasse Updater
updater <- Updater('IHRE BOT-TOKEN')
# Methode zum Senden einer InLine-Tastatur
test <- function(bot, update) {
# Erstellen Sie die InLine-Tastatur
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton("Ja", callback_data = 'yes'),
InlineKeyboardButton("Nein", callback_data = 'no')
)
)
)
# Senden Sie die Tastatur in den Chat
bot$sendMessage(update$message$chat_id,
text = "Haben Sie COVID-19?",
reply_markup = IKM)
}
# Methode zur Verarbeitung des Tastendrucks
answer_cb <- function(bot, update) {
# Erhaltene Daten von der Schaltfläche
data <- update$callback_query$data
# Benutzernamen des Drückenden abrufen
uname <- update$effective_user()$first_name
# Ergebnisverarbeitung
if (data == 'no') {
msg <- paste0(uname, ", herzlichen Glückwunsch, Ihr COVID-19-Test ist negativ.")
} else {
msg <- paste0(uname, ", leider ist Ihr COVID-19-Test positiv.")
}
# Nachricht versenden
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# Informieren Sie den Bot, dass die Anfrage von der Taste akzeptiert wurde
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# Erstellen Sie Handler
inline_h <- CommandHandler('test', test)
query_handler <- CallbackQueryHandler(answer_cb)
# Fügen Sie die Handler dem Dispatcher hinzu
updater <- updater + inline_h + query_handler
# Starten Sie den Bot
updater$start_polling()Starten Sie das oben angeführte Codebeispiel, indem Sie 'IHR BOT-TOKEN' durch das tatsächliche Token ersetzen, das Sie bei der Erstellung des Bots über BotFather erhalten haben (ich habe in ).
Das Ergebnis:
Wir haben zwei Methoden erstellt:
- test — Um Inline-Tastaturen im Chat zu senden
- answer_cb — Zur Verarbeitung der mit der Tastatur gesendeten Daten.
Die Daten, die von jeder Schaltfläche gesendet werden, werden im Argument festgelegt callback_data, beim Erstellen der Schaltfläche. Die von der Schaltfläche gesendeten Daten können mit der Konstruktion update$callback_query$data, innerhalb der Methode answer_cb.
Damit der Bot auf die Inline-Tastatur reagiert, wird die Methode answer_cb von einem speziellen Handler verarbeitet: CallbackQueryHandler(answer_cb). Dieser ruft die angegebene Methode beim Drücken der Inline-Schaltfläche auf. Der Handler CallbackQueryHandler nimmt zwei Argumente entgegen:
callback— die auszuführende Methodepattern— Filter für die Daten, die mit dem Argument an die Schaltfläche gebunden sindcallback_data.
Entsprechend können wir mit Hilfe des Arguments pattern für jeden Knopfdruck eine separate Methode schreiben:
Code 3: Methoden für jede Inline-Schaltfläche getrennt
library(telegram.bot)
# Erstellen Sie eine Instanz der Updater-Klasse
updater <- Updater('IHR BOT TOKEN')
# Methode zum Senden einer InLine-Tastatur
test <- function(bot, update) {
# InLine-Tastatur erstellen
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton("Ja", callback_data = 'yes'),
InlineKeyboardButton("Nein", callback_data = 'no')
)
)
)
# Senden der Tastatur in den Chat
bot$sendMessage(update$message$chat_id,
text = "Haben Sie Coronavirus-Symptome?",
reply_markup = IKM)
}
# Methode zur Verarbeitung des Klicks auf die Schaltfläche Ja
answer_cb_yes <- function(bot, update) {
# Benutzername desjenigen, der die Schaltfläche gedrückt hat, abrufen
uname <- update$effective_user()$first_name
# Verarbeitung des Ergebnisses
msg <- paste0(uname, ", leider ist Ihr Test auf COVID-19 positiv.")
# Nachricht senden
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# dem Bot mitteilen, dass die Anfrage von der Schaltfläche angenommen wurde
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# Methode zur Verarbeitung des Klicks auf die Schaltfläche Nein
answer_cb_no <- function(bot, update) {
# Benutzername desjenigen, der die Schaltfläche gedrückt hat, abrufen
uname <- update$effective_user()$first_name
msg <- paste0(uname, ", herzlichen Glückwunsch, Ihr Test auf COVID-19 ist negativ.")
# Nachricht senden
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# dem Bot mitteilen, dass die Anfrage von der Schaltfläche angenommen wurde
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# Erstellen der Handler
inline_h <- CommandHandler('test', test)
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')
# Fügen Sie die Handler zum Dispatcher hinzu
updater <- updater +
inline_h +
query_handler_yes +
query_handler_no
# Starten Sie den Bot
updater$start_polling()Starten Sie das oben angeführte Codebeispiel, indem Sie 'IHR BOT-TOKEN' durch das tatsächliche Token ersetzen, das Sie bei der Erstellung des Bots über BotFather erhalten haben (ich habe in ).
Jetzt haben wir zwei separate Methoden erstellt, das heißt, eine Methode für jeden Knopfdruck, und haben das Argument verwendet pattern, bei der Erstellung ihrer Handler:
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')Der Code der Methode endet answer_cb mit dem Befehl bot$answerCallbackQuery(callback_query_id = update$callback_query$id), die dem Bot mitteilt, dass die Daten von der Inline-Tastatur empfangen wurden.
Beispiel eines Bots, der das aktuelle Wetter für die ausgewählte Stadt meldet
Lassen Sie uns versuchen, einen Bot zu schreiben, der Wetterdaten abfragt.
Seine Funktionsweise wird folgendermaßen sein. Zunächst rufen Sie mit dem Befehl /start die Haupttaste auf, auf der es nur eine Schaltfläche "Wetter" gibt. Wenn Sie auf diese Schaltfläche klicken, erhalten Sie eine Nachricht mit einer Inline-Tastatur, um die Stadt auszuwählen, für die das aktuelle Wetter abgefragt werden soll. 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 jedem API basiert. In unserem Fall verwenden wir die kostenlose API .stringr— ein Paket zum Arbeiten mit Text, in unserem Fall verwenden wir es, um die Wetternachricht in der gewählten Stadt zu erstellen.
Code 4: Ein Bot, der das aktuelle Wetter für die ausgewählte Stadt meldet
library(telegram.bot)
library(httr)
library(stringr)
# Erstellen einer Instanz der Updater-Klasse
updater <- Updater('TOKEN IHRES BOTS')
# Erstellen von Methoden
## Methode zum Starten der Haupttastatur
start <- function(bot, update) {
# Erstellen der Tastatur
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Wetter")
)
),
resize_keyboard = TRUE,
one_time_keyboard = TRUE
)
# Senden der Tastatur
bot$sendMessage(update$message$chat_id,
text = 'Wählen Sie einen Befehl',
reply_markup = RKM)
}
## Methode zum Aufrufen der Inline-Tastatur
weather <- function(bot, update) {
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton(text = 'Moskau', callback_data = 'New York,us'),
InlineKeyboardButton(text = 'Sankt Petersburg', callback_data = 'Saint Petersburg'),
InlineKeyboardButton(text = 'New York', callback_data = 'New York')
),
list(
InlineKeyboardButton(text = 'Jekaterinburg', callback_data = 'Yekaterinburg,ru'),
InlineKeyboardButton(text = 'Berlin', callback_data = 'Berlin,de'),
InlineKeyboardButton(text = 'Paris', callback_data = 'Paris,fr')
),
list(
InlineKeyboardButton(text = 'Rom', callback_data = 'Rome,it'),
InlineKeyboardButton(text = 'Odessa', callback_data = 'Odessa,ua'),
InlineKeyboardButton(text = 'Kiew', callback_data = 'Kyiv,fr')
),
list(
InlineKeyboardButton(text = 'Tokio', callback_data = 'Tokyo'),
InlineKeyboardButton(text = 'Amsterdam', callback_data = 'Amsterdam,nl'),
InlineKeyboardButton(text = 'Washington', callback_data = 'Washington,us')
)
)
)
# Send Inline-Tastatur
bot$sendMessage(chat_id = update$message$chat_id,
text = "Wählen Sie eine Stadt",
reply_markup = IKM)
}
# Methode zur Wettermeldung
answer_cb <- function(bot, update) {
# Stadt aus der Nachricht abrufen
city <- update$callback_query$data
# Anfrage senden
ans <- GET('https://api.openweathermap.org/data/2.5/weather',
query = list(q = city,
lang = 'de',
units = 'metric',
appid = '4776568ccea136ffe4cda9f1969af340'))
# Antwort parsen
result <- content(ans)
# Nachricht erstellen
msg <- str_glue("{result$name} Wetter:n",
"Aktuelle Temperatur: {result$main$temp}n",
"Windgeschwindigkeit: {result$wind$speed}n",
"Beschreibung: {result$weather[[1]]$description}")
# Wetterinformationen senden
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# Filter erstellen
## Nachrichten mit dem Text Wetter
MessageFilters$weather <- BaseFilter(function(message) {
# Überprüfen des Nachrichtentexts
message$text == "Wetter"
}
)
# Handler erstellen
h_start <- CommandHandler('start', start)
h_weather <- MessageHandler(weather, filters = MessageFilters$weather)
h_query_handler <- CallbackQueryHandler(answer_cb)
# Handler zum Dispatcher hinzufügen
updater <- updater +
h_start +
h_weather +
h_query_handler
# Bot starten
updater$start_polling()Starten Sie das oben angeführte Codebeispiel, indem Sie 'IHR BOT-TOKEN' durch das tatsächliche Token ersetzen, das Sie bei der Erstellung des Bots über BotFather erhalten haben (ich habe in ).
Unser Bot wird folgendermaßen funktionieren:
Schematisch kann dieser Bot wie folgt dargestellt werden:
Wir haben 3 Methoden erstellt, die in unserem Wetterbot verfügbar sind:
- start — Start der Haupttastatur des Bots
- weather — Start der Inline-Tastatur zur Auswahl der Stadt
- answer_cb — Die Hauptmethode, die bei Angabe einer Stadt die Wetterdaten über die API abfragt und diese im Chat versendet.
Methode start wir starten mit dem Befehl /start, umgesetzt durch den Handler CommandHandler('start', start).
Um die Methode zu starten, weather haben wir einen gleichnamigen Filter erstellt:
# создаём фильтры
## сообщения с текстом Погода
MessageFilters$weather <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Погода"
}
)Und wir rufen diese Methode mit folgendem Nachrichtenhandler auf: MessageHandler(weather, filters = MessageFilters$weather).
Und schließlich reagiert unsere Hauptmethode answer_cb auf das Drücken der Inline-Buttons, was durch einen speziellen Handler umgesetzt ist: CallbackQueryHandler(answer_cb).
Innerhalb der Methode answer_cb, lesen wir die von der Tastatur gesendeten Daten und speichern sie in der Variablen city: city <- update$callback_query$data. Danach fragen wir die Wetterdaten von der API an, formulieren und senden die Nachricht, und schließlich verwenden wir die Methode answerCallbackQuery , um dem Bot mitzuteilen, dass wir das Drücken des Inline-Buttons verarbeitet haben.
Ein Beispielbot, der eine Liste der neuesten Artikel mit Links zum angegebenen Hub anzeigt .
Ich präsentiere diesen Bot, um Ihnen zu zeigen, wie man Inline-Tasten erstellt, die auf Webseiten zugreifen.
Die Logik dieses Bots ähnelt der vorherigen. Zunächst starten wir die Haupttastatur mit dem Befehl /start. Danach bietet der Bot uns eine Auswahl von 6 Hubs, aus denen wir den gewünschten Hub auswählen können, und erhalten die 5 neuesten Veröffentlichungen aus dem gewählten Hub.
Wie Sie verstehen, müssen wir in diesem Fall eine Liste von Artikeln abrufen, und dazu verwenden wir ein spezielles Paket habR, das es ermöglicht, Artikel aus Habr zu abrufen und einige Statistiken dazu in R zu erhalten.
Das Paket habR kann nur von GitHub installiert werden, wozu Sie ein zusätzliches Paket benötigen, devtools. Für die Installation verwenden Sie den folgenden Code.
install.packages('devtools')
devtools::install_github('selesnow/habR')Jetzt betrachten wir den Code zur Erstellung des oben beschriebenen Bots:
Code 5: Bot, der die neuesten Artikel aus dem gewählten Hub anzeigt
library(telegram.bot)
library(habR)
# Erstellen Sie eine Instanz der Updater-Klasse
updater <- Updater('IHR BOT-TOKEN')
# Methoden erstellen
## Methode zum Starten der Haupt-Tastatur
start <- function(bot, update) {
# Tastatur erstellen
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Liste der Artikel")
)
),
resize_keyboard = TRUE,
one_time_keyboard = TRUE
)
# Tastatur senden
bot$sendMessage(update$message$chat_id,
text = 'Wählen Sie einen Befehl',
reply_markup = RKM)
}
## Methode zum Aufrufen der Inline-Tastatur
habs <- function(bot, update) {
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton(text = 'R', callback_data = 'R'),
InlineKeyboardButton(text = 'Datenmine', callback_data = 'data_mining'),
InlineKeyboardButton(text = 'Datenengineering', callback_data = 'data_engineering')
),
list(
InlineKeyboardButton(text = 'Big Data', callback_data = 'bigdata'),
InlineKeyboardButton(text = 'Python', callback_data = 'python'),
InlineKeyboardButton(text = 'Datenvisualisierung', callback_data = 'data_visualization')
)
)
)
# Inline-Tastatur senden
bot$sendMessage(chat_id = update$message$chat_id,
text = "Wählen Sie einen Hub",
reply_markup = IKM)
}
# Methode zur Wetternachricht
answer_cb <- function(bot, update) {
# Stadt aus der Nachricht abrufen
hub <- update$callback_query$data
# Nachricht, dass die Daten per Knopfdruck abgerufen wurden
bot$answerCallbackQuery(callback_query_id = update$callback_query$id,
text = 'Bitte warten Sie einige Minuten, Ihre Anfrage wird bearbeitet')
# Nachricht, dass gewartet werden muss, während der Bot die Daten abrufen
mid <- bot$sendMessage(chat_id = update$from_chat_id(),
text = "Bitte warten Sie einige Minuten, während ich die Daten des gewählten Hubs sammle")
# Hubr abrufen
posts <- head(habr_hub_posts(hub, 1), 5)
# Nachricht über das Warten löschen
bot$deleteMessage(update$from_chat_id(), mid$message_id)
# Tastenliste erstellen
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# Tastatur erstellen
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)
# Wetterinformationen senden
bot$sendMessage(chat_id = update$from_chat_id(),
text = paste0("Die 5 aktuellsten Artikel aus dem Hub ", hub),
reply_markup = IKM)
}
# Filter erstellen
## Nachrichten mit dem Text Wetter
MessageFilters$hubs <- BaseFilter(function(message) {
# Überprüfen Sie den Text der Nachricht
message$text == "Liste der Artikel"
}
)
# Handler erstellen
h_start <- CommandHandler('start', start)
h_hubs <- MessageHandler(habs, filters = MessageFilters$hubs)
h_query_handler <- CallbackQueryHandler(answer_cb)
# Handler zum Dispatcher hinzufügen
updater <- updater +
h_start +
h_hubs +
h_query_handler
# Bot starten
updater$start_polling()Starten Sie das oben angeführte Codebeispiel, indem Sie 'IHR BOT-TOKEN' durch das tatsächliche Token ersetzen, das Sie bei der Erstellung des Bots über BotFather erhalten haben (ich habe in ).
Am Ende erhalten wir folgendes Ergebnis:
Die Liste der auswählbaren Hubs haben wir hartcodiert in der Methode 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)
}Die Liste der Artikel aus dem angegebenen Hub erhalten wir mit dem Befehl habr_hub_posts(), aus dem Paket habR. Dabei geben wir an, dass wir nicht die gesamte Artikelliste benötigen, sondern nur die erste Seite, auf der 20 Artikel angezeigt werden. Aus der erhaltenen Tabelle behalten wir mit dem Befehl head() nur die 5 obersten, die die aktuellsten Artikel sind.
# парсим Хабр
posts <- head(habr_hub_posts(hub, 1), 5)Die Logik ähnelt sehr der vorherigen Bot-Implementierung, aber in diesem Fall generieren wir die Inline-Tastatur mit der Artikelliste dynamisch mithilfe der Funktion lapply().
# формируем список кнопок
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# формируем клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)Im Text der Schaltfläche setzen wir den Titel des Artikels ein posts$title[x], und im Argument url den Artikel-Link: url = posts$link[x].
Als Nächstes erstellen wir den Filter, die Handler und starten unseren Bot.
Fazit
Jetzt werden die von Ihnen erstellten Bots viel benutzerfreundlicher sein, da die Steuerung über die Tastatur und nicht über die Eingabe von Befehlen erfolgt. Besonders bei der Interaktion mit dem Bot über ein Smartphone wird die Tastatur den Nutzungsprozess erheblich vereinfachen.
Im nächsten Artikel werden wir uns damit beschäftigen, wie man einen logischen Dialog mit dem Bot aufbaut und mit Datenbanken arbeitet.
Quelle: habr.com
