Dies ist der dritte Artikel aus der Reihe "Einen Telegram-Bot in der Programmiersprache R schreiben". In den vorherigen Veröffentlichungen haben wir gelernt, wie man einen Telegram-Bot erstellt, Nachrichten über ihn sendet, dem Bot Befehle und Nachrichtenfilter hinzufügt. Daher empfehle ich dringend, sich mit den vertraut zu machen, da ich hier nicht auf die zuvor beschriebenen Grundlagen des Bot-Bauens eingehen werde.
In diesem Artikel verbessern wir die Benutzerfreundlichkeit unseres Bots, indem wir eine Tastatur hinzufügen, die die Benutzeroberfläche des Bots intuitiv und einfach zu bedienen macht.
Alle Artikel der Serie "Wir schreiben einen Telegram-Bot in der Programmiersprache R"
Inhalt
Wenn Sie sich für Datenanalyse interessieren, könnten Ihnen meine und Kanäle interessieren. Der Großteil des Inhalts widmet sich der Programmiersprache R.
3.1.
3.2.
3.3.
Welche Arten von Tastaturen unterstützt der Telegram-Bot?
Zum Zeitpunkt des Schreibens des Artikels telegram.bot ermöglicht es Ihnen, Tastaturen von zwei Typen zu erstellen:
- Reply — Die Haupttastatur, die sich unter der Texteingabefeld befindet. Diese Tastatur sendet einfach eine textuelle Nachricht an den Bot und überträgt den Text, der auf der Taste geschrieben steht.
- Inline — Die Tastatur, die an eine bestimmte Bot-Nachricht gebunden ist. Diese Tastatur sendet Daten an den Bot, die an den gedrückten Button gebunden sind; diese Daten können von dem Text abweichen, der auf der Taste geschrieben steht. Und solche Buttons werden über CallbackQueryHandler.
aktiviert, wenn der Bot die Tastatur öffnen soll, muss beim Senden der Nachricht über die Methode sendMessage(), die zuvor erstellte Tastatur als Argument übergeben werden. reply_markup.
Im Folgenden werden wir einige Beispiele durchgehen.
Reply-Tastatur
Wie bereits oben erwähnt, handelt es sich um die Haupttastatur zur Steuerung des Bots.
Beispiel zur Erstellung einer Reply-Tastatur aus der offiziellen Dokumentation
bot <- Bot(token = "TOKEN")
chat_id <- "CHAT_ID"
# Erstellen Sie eine benutzerdefinierte Tastatur
text <- "Sind diese benutzerdefinierten Tastaturen nicht cool?"
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Ja, das sind sie mit Sicherheit!")),
list(KeyboardButton("Ich bin mir nicht ganz sicher")),
list(KeyboardButton("Nein..."))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# Senden Sie die benutzerdefinierte Tastatur
bot$sendMessage(chat_id, text, reply_markup = RKM)Oben sehen Sie ein Beispiel aus der offiziellen Dokumentation des Pakets telegram.bot. Zur Erstellung der Tastatur wird die Funktion ReplyKeyboardMarkup(), die ihrerseits eine Liste von Listen von Tasten akzeptiert, die durch die Funktion KeyboardButton().
erzeugt werden. ReplyKeyboardMarkup() Müssen nicht nur Listen, sondern Listen von Listen übergeben werden? Der Grund ist, dass Sie eine Hauptliste übergeben, in der Sie separate Listen für jede Reihe von Schaltflächen angeben, da in einer Reihe mehrere Schaltflächen platziert werden können.
Argument resize_keyboard erlaubt es, die optimale Größe der Tastaturschaltflächen automatisch anzupassen, während das Argument one_time_keyboard es ermöglicht, die Tastatur nach jedem Tastendruck auszublenden.
Lassen Sie uns einen einfachsten Bot schreiben, der drei Schaltflächen 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 Reply-Tastatur
library(telegram.bot)
# Erstellen Sie eine Instanz der Klasse Updater
updater <- Updater('TOKEN IHRES BOTS')
# Erstellen Sie Methoden
## Methode zum Starten der Tastatur
start <- function(bot, update) {
# Erstellen Sie die Tastatur
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Chat-ID")),
list(KeyboardButton("Mein Name")),
list(KeyboardButton("Mein Benutzername"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# Senden Sie die Tastatur
bot$sendMessage(update$message$chat_id,
text = 'Wählen Sie einen Befehl',
reply_markup = RKM)
}
## Methode zur Rückgabe der Chat-ID
chat_id <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Chat-ID dieses Gesprächs: ", update$message$chat_id),
parse_mode = "Markdown")
}
## Methode zur Rückgabe des Namens
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 zur Rückgabe des Benutzernamens
my_username <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Ihr Benutzername ist ", update$message$from$username),
parse_mode = "Markdown")
}
# Erstellen Sie Filter
## 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"
)
# Erstellen Sie Handler
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)
# Fügen Sie Handler zum Dispatcher hinzu
updater <- updater +
h_start +
h_chat_id +
h_name +
h_username
# Starten Sie den Bot
updater$start_polling()Führen Sie das oben stehende Beispiel aus, nachdem Sie 'IHR BOT TOKEN' durch das tatsächliche Token ersetzt haben, das Sie bei der Erstellung des Bots über BotFather (ich habe in ).
Nachdem Sie gestartet haben, geben Sie dem Bot einen Befehl /start, da wir genau dies für den Start der Tastatur definiert haben.
Wenn es Ihnen derzeit schwerfällt, das Beispiel für den Code zu verstehen, das Methoden, Filter und Handler erstellt, sollten Sie zu dem vorherigen zurückkehren, , in dem ich alles detailliert beschrieben habe.
Wir haben 4 Methoden erstellt:
- start — Tastatur starten
- chat_id — Anfrage zur Chat-ID
- my_name — Anfrage nach Ihrem Namen
- my_username — Anfrage nach Ihrem Benutzernamen
Im Objekt MessageFilters haben wir 3 Filter für Nachrichten basierend auf ihrem Text hinzugefügt:
- chat_id — Nachrichten mit Text
"Chat-ID" - name — Nachrichten mit Text
"Mein Name" - username — Nachrichten mit Text
"Mein Benutzername"
Und wir haben 4 Handler erstellt, die auf bestimmten 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() Wir setzen ein eigenes Passwort für den Benutzer ReplyKeyboardMarkup().
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Chat-ID")),
list(KeyboardButton("Mein Name")),
list(KeyboardButton("Mein Benutzername"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)In unserem Fall haben wir alle Tasten untereinander angeordnet, aber wir können sie auch in einer Reihe anordnen, indem wir die Listen der Tasten anpassen. Da eine Reihe innerhalb der Tastatur durch eine verschachtelte Liste von Tasten erstellt wird, müssen wir einen Teil des Codes zur Erstellung der Tastatur so umschreiben,
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Chat-ID"),
KeyboardButton("Mein Name"),
KeyboardButton("Mein Benutzername")
)
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
Die Tastatur wird im 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 ich bereits oben erwähnt habe, ist die Inline-Tastatur an eine bestimmte Nachricht gebunden. Mit ihr zu arbeiten, ist etwas komplizierter als mit 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-Taste zu antworten, kann auch die Bot-Methode verwendet werden answerCallbackQuery(), die eine Benachrichtigung in der Telegram-Oberfläche an den Benutzer senden kann, der die Inline-Taste gedrückt hat.
Die Daten, die von der Inline-Taste gesendet werden, sind kein Text, weshalb für ihre Verarbeitung ein spezieller Handler mit dem Befehl erstellt werden muss CallbackQueryHandler().
Der Code zur Erstellung der Inline-Tastatur, der in der offiziellen Dokumentation des Pakets angegeben wird. telegram.bot.
Der Code zur Erstellung 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(), auf die gleiche Weise wie die Reply-Tastatur. In InlineKeyboardMarkup() muss eine Liste von Listen von Inline-Tasten übergeben werden, wobei jede einzelne Taste durch die Funktion InlineKeyboardButton().
Eine Inline-Taste kann entweder einige Daten an den Bot übermitteln mit dem Argument callback_data, oder eine bestimmte HTML-Seite öffnen, die durch das Argument festgelegt wird. url.
Das Ergebnis wird eine Liste sein, in der jedes Element ebenfalls eine Liste von Inline-Tasten ist, die in einer Reihe zusammengeführt werden müssen.
Im Folgenden betrachten wir einige Beispiele für Bots mit Inline-Tasten.
Beispiel eines einfachen Bots mit Unterstützung für Inline-Buttons
Zunächst schreiben wir einen Bot für einen Schnelltest auf COVID-19. Auf den Befehl /test, wird er Ihnen eine Tastatur mit zwei Tasten senden, je nach gedrückter Taste wird er Ihnen eine Nachricht mit den Ergebnissen Ihres Tests senden.
Code 2: Einfacher Bot mit Inline-Tastatur
library(telegram.bot)
# erstellen Sie eine Instanz der Updater-Klasse
updater <- Updater('IHR BOT- TOKEN')
# Methode zum Senden der 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 im Chat
bot$sendMessage(update$message$chat_id,
text = "Haben Sie COVID-19?",
reply_markup = IKM)
}
# Methode zum Verarbeiten des Tastendrucks
answer_cb <- function(bot, update) {
# Die empfangenen Daten von der Taste
data <- update$callback_query$data
# Holen Sie sich den Benutzernamen des Benutzers, der die Taste gedrückt hat
uname <- update$effective_user()$first_name
# Verarbeitung des Ergebnisses
if ( data == 'no' ) {
msg <- paste0(uname, ", herzlichen Glückwunsch, Ihr Test auf COVID-19 ist negativ.")
} else {
msg <- paste0(uname, ", leider ist Ihr Test auf COVID-19 positiv.")
}
# Nachricht senden
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 die Handler
inline_h <- CommandHandler('test', test)
query_handler <- CallbackQueryHandler(answer_cb)
# Fügen Sie die Handler zum Dispatcher hinzu
updater <- updater + inline_h + query_handler
# Starten Sie den Bot
updater$start_polling()Führen Sie das oben stehende Beispiel aus, nachdem Sie 'IHR BOT TOKEN' durch das tatsächliche Token ersetzt haben, das Sie bei der Erstellung des Bots über BotFather (ich habe in ).
Ergebnis:
Wir haben zwei Methoden erstellt:
- test — Um die Inline-Tastatur im Chat zu senden
- answer_cb — Um die von der Tastatur gesendeten Daten zu verarbeiten.
Die Daten, die mit jeder Taste gesendet werden, werden im Argument callback_data, beim Erstellen der Taste festgelegt. Die empfangenen Daten von der Taste können mit der Konstruktion update$callback_query$data, innerhalb der Methode answer_cb.
Um sicherzustellen, dass der Bot auf die Inline-Tastatur reagiert, verwenden Sie die Methode answer_cb wird von einem speziellen Handler verarbeitet: CallbackQueryHandler(answer_cb). Der beim Drücken der Inline-Taste die angegebene Methode aufruft. Der Handler CallbackQueryHandler nimmt zwei Argumente an:
callback— Die Methode, die aufgerufen werden sollpattern— Ein Filter für die Daten, die mit dem Argument an die Taste gebunden sindcallback_data.
Entsprechend können wir für das Drücken jeder Taste eine separate Methode schreiben: pattern Code 3: Methoden für jede Inline-Taste trennen
library(telegram.bot)# Erstellen eines Instanz der Klasse Updater updater <- Updater('TOKEN IHRES BOTS')# Methode zum Senden der Inline-Tastatur test <- function(bot, update) {# Erstellen der Inline-Tastatur 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 Drückens der Ja-Taste answer_cb_yes <- function(bot, update) {# Benutzername des Benutzers, der die Taste gedrückt hat, abrufen uname <- update$effective_user()$first_name# Verarbeitung des Ergebnisses msg <- paste0(uname, ", leider ist Ihr Covid-19-Test positiv.")# Senden der Nachricht bot$sendMessage(chat_id = update$from_chat_id(), text = msg)# Benachrichtigen Sie den Bot, dass die Anfrage von der Taste angenommen wurde bot$answerCallbackQuery(callback_query_id = update$callback_query$id) }# Methode zur Verarbeitung des Drückens der Nein-Taste answer_cb_no <- function(bot, update) {# Benutzername des Benutzers, der die Taste gedrückt hat, abrufen uname <- update$effective_user()$first_namemsg <- paste0(uname, ", gratuliere, Ihr Covid-19-Test ist negativ.")# Senden der Nachricht bot$sendMessage(chat_id = update$from_chat_id(), text = msg)# Benachrichtigen Sie den Bot, dass die Anfrage von der Taste angenommen wurde bot$answerCallbackQuery(callback_query_id = update$callback_query$id) }# Erstellen von Handlern inline_h <- CommandHandler('test', test) query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes') query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')# Handler zum Dispatcher hinzufügen updater <- updater + inline_h + query_handler_yes + query_handler_no# Bot starten updater$start_polling()
Jetzt haben wir 2 separate Methoden geschrieben, d.h. eine Methode für das Drücken jeder Taste, und haben das ArgumentFühren Sie das oben stehende Beispiel aus, nachdem Sie 'IHR BOT TOKEN' durch das tatsächliche Token ersetzt haben, das Sie bei der Erstellung des Bots über BotFather (ich habe in ).
, bei der Erstellung ihrer Handler verwendet: patternquery_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes') query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')
Der Code der Methode endetbot$answerCallbackQuery(callback_query_id = update$callback_query$id) answer_cb Wir setzen ein eigenes Passwort für den Benutzer , das dem Bot mitteilt, dass die Daten von der Inline-Tastatur erhalten wurden., die dem Bot mitteilt, dass die Daten von der Inline-Tastatur erhalten wurden.
Beispiel eines Bots, der das aktuelle Wetter für die ausgewählte Stadt anzeigt
Lass uns versuchen, einen Bot zu schreiben, der Wetterdaten abfragt.
Die Logik seiner Funktionsweise wird wie folgt sein. Zunächst mit dem Befehl /start rufen Sie die Haupttastatur auf, die nur einen Knopf "Wetter" enthält. Wenn Sie diesen Knopf drücken, erhalten Sie eine Nachricht mit einer Inline-Tastatur zur Auswahl der Stadt, für die Sie das aktuelle Wetter erfragen möchten. Wählen Sie eine der Städte aus und erhalten Sie das aktuelle Wetter.
In diesem Beispielcode werden wir mehrere zusätzliche Pakete verwenden:
httr— ein Paket zur Arbeit mit HTTP-Anfragen, auf dessen Grundlage die Arbeit mit jeder API aufgebaut ist. In unserem Fall werden wir die kostenlose API .stringr— ein Paket zur Textverarbeitung, in unserem Fall werden wir es verwenden, um die Wetternachricht für die ausgewählte Stadt zu erstellen.
Code 4: Bot, der das aktuelle Wetter für die gewählte Stadt meldet
library(telegram.bot)
library(httr)
library(stringr)
# Erstellen Sie eine Instanz der Klasse Updater
updater <- Updater('IHRE BOT-TOKENS')
# Methoden erstellen
## Methode zum Starten der Haupttastatur
start <- function(bot, update) {
# Tastatur erstellen
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Wetter")
)
),
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
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')
)
)
)
# Inline-Tastatur senden
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 = 'ru',
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) {
# Nachrichtentext überprüfen
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()Führen Sie das oben stehende Beispiel aus, nachdem Sie 'IHR BOT TOKEN' durch das tatsächliche Token ersetzt haben, das Sie bei der Erstellung des Bots über BotFather (ich habe in ).
Infolgedessen wird unser Bot ungefähr so arbeiten:
Schematically kann dieser Bot so entworfen werden:
Wir haben 3 Methoden erstellt, die innerhalb unseres Wetterbots verfügbar sind:
- start — Start der Haupttastatur des Bots
- Wetter — Start der Inline-Tastatur zur Auswahl der Stadt
- answer_cb — Die Hauptmethode, die bei angegebener Stadt die Wetterdaten über die API anfordert und sie in den Chat sendet.
Methode start wird bei uns mit dem Befehl gestartet /start, der durch den Handler realisiert wird CommandHandler('start', start).
Um die Methode zu starten Wetter haben wir einen gleichnamigen Filter erstellt:
# создаём фильтры
## сообщения с текстом Погода
MessageFilters$weather <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Погода"
}
)Und wir rufen diese Methode mit dem folgenden Nachrichtenhandler auf: MessageHandler(wetter, filters = MessageFilters$wetter).
Und schließlich reagiert unsere Hauptmethode answer_cb auf das Drücken von Inline-Tasten, das durch einen speziellen Handler umgesetzt wird: CallbackQueryHandler(answer_cb).
Innerhalb der Methode answer_cb, lesen wir die von der Tastatur gesendeten Daten und speichern sie in der Variable stadt: stadt <- update$callback_query$data. Danach fordern wir Wetterdaten über die API an, erstellen und senden die Nachricht und verwenden schließlich die Methode answerCallbackQuery , um dem Bot mitzuteilen, dass wir das Drücken der Inline-Taste verarbeitet haben.
Ein Beispiel für einen Bot, der eine Liste der neuesten Artikel mit Links zum angegebenen Hub ausgibt .
Diesen Bot führe ich an, um Ihnen zu zeigen, wie man Inline-Tasten erstellt, die auf Webseiten verlinken.
Die Logik dieses Bots ähnelt der vorherigen; zunächst starten wir die Haupttastatur mit dem Befehl /start. Danach bietet der Bot eine Auswahl aus 6 Hubs, wir wählen den gewünschten Hub aus und erhalten die 5 neuesten Publikationen 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 und einige Statistiken von Habr in R abzufragen.
Das Paket habR kann nur von GitHub installiert werden, dafür benötigen Sie ein zusätzliches Paket devtools. Zur Installation verwenden Sie den folgenden Code.
install.packages('devtools')
devtools::install_github('selesnow/habR')Nun betrachten wir den Code zur Erstellung des oben beschriebenen Bots:
Code 5: Bot, der eine Liste der neuesten Artikel zum gewählten Hub ausgibt.
library(telegram.bot)
library(habR)
# Erstellen Sie eine Instanz der Klasse Updater
updater <- Updater('TOKEN IHRES BOTS')
# Erstellen Sie Methoden
## Methode zum Starten der Haupttastatur
start <- function(bot, update) {
# Erstellen Sie die Tastatur
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Liste der Artikel")
)
),
resize_keyboard = TRUE,
one_time_keyboard = TRUE
)
# Senden Sie die Tastatur
bot$sendMessage(update$message$chat_id,
text = 'Wählen Sie einen Befehl',
reply_markup = RKM)
}
## Methode zum Aufruf der Inline-Tastatur
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 = 'Datenvisualisierung', callback_data = 'data_visualization')
)
)
)
# Senden Sie die Inline-Tastatur
bot$sendMessage(chat_id = update$message$chat_id,
text = "Wählen Sie einen Hub",
reply_markup = IKM)
}
# Methode zur Wettermeldung
answer_cb <- function(bot, update) {
# Erhalten Sie die Stadt aus der Nachricht
hub <- update$callback_query$data
# Nachricht, dass die Daten per Knopf erhalten wurden
bot$answerCallbackQuery(callback_query_id = update$callback_query$id,
text = 'Bitte warten Sie einige Minuten, Anfrage wird bearbeitet')
# Nachricht, dass man warten muss, bis der Bot die Daten erhält
mid <- bot$sendMessage(chat_id = update$from_chat_id(),
text = "Bitte warten Sie einige Minuten, während ich die Daten für den gewählten Hub sammle")
# Parsen von Habr
posts <- head(habr_hub_posts(hub, 1), 5)
# Löschen Sie die Nachricht, dass man warten muss
bot$deleteMessage(update$from_chat_id(), mid$message_id)
# Erstellen Sie die Liste der Tasten
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# Erstellen Sie die Tastatur
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)
# Senden Sie die Wetterinformationen
bot$sendMessage(chat_id = update$from_chat_id(),
text = paste0("Die 5 aktuellsten Artikel aus dem Hub ", hub),
reply_markup = IKM)
}
# Erstellen Sie Filter
## Nachrichten mit dem Text Wetter
MessageFilters$hubs <- BaseFilter(function(message) {
# Überprüfen Sie den Text der Nachricht
message$text == "Liste der Artikel"
}
)
# Erstellen von Handlern
h_start <- CommandHandler('start', start)
h_hubs <- MessageHandler(habs, filters = MessageFilters$hubs)
h_query_handler <- CallbackQueryHandler(answer_cb)
# Fügen Sie die Handler zum Dispatcher hinzu
updater <- updater +
h_start +
h_hubs +
h_query_handler
# Starten Sie den Bot
updater$start_polling()Führen Sie das oben stehende Beispiel aus, nachdem Sie 'IHR BOT TOKEN' durch das tatsächliche Token ersetzt haben, das Sie bei der Erstellung des Bots über BotFather (ich habe in ).
Am Ende erhalten wir das folgende Ergebnis:
Die Liste der verfügbaren 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 keine Liste von Artikeln für immer benötigen, sondern nur die erste Seite, auf der 20 Artikel platziert sind. Aus der erhaltenen Tabelle verwenden wir den Befehl head() und behalten nur die 5 obersten, die die aktuellsten Artikel sind.
# парсим Хабр
posts <- head(habr_hub_posts(hub, 1), 5)Die Logik ist sehr ähnlich zu dem vorherigen Bot, aber in diesem Fall generieren wir die Inline-Tastatur mit der Liste der Artikel dynamisch mit der Funktion lapply().
# формируем список кнопок
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# формируем клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)In den Text der Schaltfläche setzen wir den Titel des Artikels ein posts$title[x], und im Argument url den Link zum Artikel: url = posts$link[x].
Dann erstellen wir den Filter, die Handler und starten unseren Bot.
Fazit
Jetzt werden die von Ihnen geschriebenen Bots deutlich einfacher zu bedienen sein, da die Steuerung über die Tastatur und nicht über die Eingabe von Befehlen erfolgt. Zumindest bei der Interaktion mit dem Bot über ein Smartphone wird die Tastatur den Nutzungsvorgang 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
