C'est le troisième article de la série "Créer un bot Telegram en R". Dans les publications précédentes, nous avons appris à créer un bot Telegram, à lui faire envoyer des messages, et nous avons ajouté des commandes et des filtres de messages. Donc, avant de commencer à lire cet article, je vous recommande fortement de consulter les , car ici je ne reviendrai pas sur les bases de la création de bots décrites précédemment.
Dans cet article, nous améliorerons l'utilisabilité de notre bot en ajoutant un clavier qui rendra l'interface du bot intuitive et facile à utiliser.
Tous les articles de la série "Écrire un bot Telegram en R"
Contenu
Si vous vous intéressez à l'analyse de données, mes et canaux pourraient vous intéresser. La majeure partie du contenu y est consacrée au langage R.
3.1.
3.2.
3.3.
Quels types de claviers sont pris en charge par le bot Telegram
Au moment de la rédaction de cet article telegram.bot vous permet de créer des claviers de deux types :
- Réponse — Le clavier principal, qui se trouve sous le champ de saisie de texte du message. Ce clavier envoie simplement un message texte au bot, et en tant que texte, il enverra le texte qui est écrit sur le bouton lui-même.
- Inline — Un clavier lié à un message spécifique du bot. Ce clavier envoie des données au bot liées au bouton pressé, ces données peuvent différer du texte écrit sur le bouton lui-même. Et les ces boutons sont traités par CallbackQueryHandler.
Pour que le bot ouvre le clavier, il est nécessaire lors de l'envoi du message via la méthode sendMessage(), de transmettre le clavier créé précédemment en argument reply_markup.
Ci-dessous, nous examinerons quelques exemples.
Clavier de réponse
Comme je l'ai écrit ci-dessus, c'est le clavier principal pour contrôler le bot.
Exemple de création d'un clavier de réponse à partir de la documentation officielle
bot <- Bot(token = "TOKEN")
chat_id <- "CHAT_ID"
# Créer un Clavier Personnalisé
text <- "Ces claviers personnalisés sont-ils cool ?"
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Oui, ils le sont certainement !")),
list(KeyboardButton("Je ne suis pas tout à fait sûr")),
list(KeyboardButton("Non..."))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# Envoyer le Clavier Personnalisé
bot$sendMessage(chat_id, text, reply_markup = RKM)L'exemple ci-dessus provient de la documentation officielle du package telegram.bot. Pour créer un clavier, on utilise la fonction ReplyKeyboardMarkup(), qui prend en charge une liste de listes de boutons, créés par la fonction KeyboardButton().
Pourquoi dans ReplyKeyboardMarkup() Il est nécessaire de transmettre non seulement une liste, mais une liste de listes ? En effet, vous transmettez une liste principale, et dans celle-ci, vous définissez chaque rangée de boutons sous forme de listes distinctes, car plusieurs boutons peuvent être placés sur une seule rangée.
Argument resize_keyboard permet de définir automatiquement la taille optimale des boutons du clavier, et l'argument one_time_keyboard permet de masquer le clavier après chaque pression sur un bouton.
Écrivons un bot simple qui contiendra 3 boutons :
- Chat ID — Demander l'ID du chat de dialogue avec le bot
- Mon nom — Demander mon nom
- Mon identifiant — Demander mon nom d'utilisateur sur Telegram
Code 1 : Un bot simple avec un clavier de réponse
library(telegram.bot)
# Création d'une instance de la classe Updater
updater <- Updater('VOTRE TOKEN DE BOT')
# Création des méthodes
## Méthode pour lancer le clavier
start <- function(bot, update) {
# Création du clavier
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Chat ID")),
list(KeyboardButton("Mon nom")),
list(KeyboardButton("Mon identifiant"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# Envoi du clavier
bot$sendMessage(update$message$chat_id,
text = 'Choisissez une commande',
reply_markup = RKM)
}
## Méthode retournant l'id du chat
chat_id <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("L'id du chat de ce dialogue est : ", update$message$chat_id),
parse_mode = "Markdown")
}
## Méthode retournant le nom
my_name <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Vous vous appelez ", update$message$from$first_name),
parse_mode = "Markdown")
}
## Méthode retournant l'identifiant
my_username <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Votre identifiant est ", update$message$from$username),
parse_mode = "Markdown")
}
# Création des filtres
## Messages avec le texte Chat ID
MessageFilters$chat_id <- BaseFilter(function(message) {
# Vérification du texte du message
message$text == "Chat ID"
}
)
## Messages avec le texte Mon nom
MessageFilters$name <- BaseFilter(function(message) {
# Vérification du texte du message
message$text == "Mon nom"
}
)
## Messages avec le texte Mon identifiant
MessageFilters$username <- BaseFilter(function(message) {
# Vérification du texte du message
message$text == "Mon identifiant"
)
# Création des gestionnaires
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)
# Ajout des gestionnaires au dispatcher
updater <- updater +
h_start +
h_chat_id +
h_name +
h_username
# Démarrage du bot
updater$start_polling()Exécutez l'exemple de code ci-dessus, en remplaçant 'VOTRE TOKEN DE BOT' par le véritable token que vous avez obtenu lors de la création du bot via BotFather (j'ai parlé de la création de bot dans ).
Après le démarrage, donnez une commande au bot /start, car c'est elle que nous avons définie pour lancer le clavier.
Si à l'heure actuelle vous avez du mal à comprendre l'exemple de code donné, concernant la création de méthodes, de filtres et de gestionnaires, il est préférable de revenir à la précédente. , dans laquelle j'ai tout expliqué en détail.
Nous avons créé 4 méthodes :
- start — Lancement du clavier
- chat_id — Demande de l'identifiant du chat
- my_name — Demande de votre nom
- my_username — Demande de votre identifiant
Dans l'objet MessageFilters nous avons ajouté 3 filtres de messages, selon leur texte :
- chat_id — Messages avec le texte
"Chat ID" - name — Messages avec le texte
"Mon nom" - username — Messages avec le texte
"Mon identifiant"
Et nous avons créé 4 gestionnaires qui exécuteront les méthodes spécifiées en fonction des commandes et des filtres donnés.
# создаём обработчики
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)Le clavier lui-même est créé à l'intérieur de la méthode start() la commande ReplyKeyboardMarkup().
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Chat ID")),
list(KeyboardButton("Mon nom")),
list(KeyboardButton("Mon identifiant"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)Dans notre cas, toutes les boutons sont alignés les uns sous les autres, mais nous pouvons les disposer en une seule rangée en modifiant la liste de listes de boutons. Comme une seule rangée dans le clavier est créée par une liste imbriquée de boutons, pour afficher nos boutons en une seule rangée, nous devons réécrire une partie du code de construction du clavier comme suit :
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Chat ID"),
KeyboardButton("Mon nom"),
KeyboardButton("Mon identifiant")
)
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
Le clavier est envoyé au chat par la méthode sendMessage(), dans l'argument reply_markup.
bot$sendMessage(update$message$chat_id,
text = 'Choisissez une commande',
reply_markup = RKM)Clavier Inline
Comme je l'ai déjà mentionné, le clavier Inline est attaché à un message spécifique. Il est un peu plus compliqué de travailler avec lui qu'avec le clavier principal.
Vous devez d'abord ajouter à votre bot une méthode pour appeler le clavier Inline.
Pour répondre à l'appui sur un bouton Inline, vous pouvez également utiliser la méthode du bot answerCallbackQuery(), qui peut afficher une notification dans l'interface de telegram, à l'utilisateur ayant appuyé sur le bouton Inline.
Les données envoyées par le bouton Inline ne sont pas du texte, donc pour les traiter, vous devez créer un gestionnaire spécial avec la commande CallbackQueryHandler().
Le code de construction du clavier Inline figurant dans la documentation officielle du paquet telegram.bot.
Le code de construction du clavier Inline dans la documentation officielle
# 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)La construction du clavier Inline doit se faire à l'aide de la commande InlineKeyboardMarkup(), de la même manière que le clavier Reply. Dans InlineKeyboardMarkup() il est nécessaire de transmettre une liste, des listes de boutons Inline, chaque bouton individuel est créé par la fonction InlineKeyboardButton().
Un bouton Inline peut soit transmettre des données au bot via l'argument callback_data, soit ouvrir une page HTML, définie par l'argument url.
En conséquence, il y aura une liste, où chaque élément est également une liste de boutons Inline, qui doivent être combinés en une seule rangée.
Nous examinerons plusieurs exemples de bots avec des boutons Inline.
Exemple d'un bot basique avec des boutons Inline
Pour commencer, nous allons créer un bot pour des tests rapides de dépistage du covid-19. Sur commande /test, il vous enverra un clavier avec deux boutons, selon le bouton pressé, il vous enverra un message avec les résultats de votre test.
Code 2 : Le bot le plus simple avec un clavier Inline
library(telegram.bot)
# créez une instance de la classe Updater
updater <- Updater('VOTRE TOKEN DE BOT')
# méthode pour envoyer un clavier Inline
test <- function(bot, update) {
# créez un clavier Inline
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton("Oui", callback_data = 'yes'),
InlineKeyboardButton("Non", callback_data = 'no')
)
)
)
# Envoyez le clavier dans le chat
bot$sendMessage(update$message$chat_id,
text = "Avez-vous le coronavirus?",
reply_markup = IKM)
}
# méthode pour traiter le bouton pressé
answer_cb <- function(bot, update) {
# données reçues du bouton
data <- update$callback_query$data
# obtenez le nom d'utilisateur qui a appuyé sur le bouton
uname <- update$effective_user()$first_name
# traitement du résultat
if ( data == 'no' ) {
msg <- paste0(uname, ", félicitations, votre test de covid-19 est négatif.")
} else {
msg <- paste0(uname, ", désolé, votre test de covid-19 est positif.")
}
# Envoi du message
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# informe le bot que la requête du bouton a été acceptée
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# créez les gestionnaires
inline_h <- CommandHandler('test', test)
query_handler <- CallbackQueryHandler(answer_cb)
# ajoutez les gestionnaires au dispatcher
updater <- updater + inline_h + query_handler
# lancez le bot
updater$start_polling()Exécutez l'exemple de code ci-dessus, en remplaçant 'VOTRE TOKEN DE BOT' par le véritable token que vous avez obtenu lors de la création du bot via BotFather (j'ai parlé de la création de bot dans ).
Résultat :
Nous avons créé deux méthodes :
- test — Pour envoyer un clavier Inline dans le chat
- answer_cb — Pour traiter les données envoyées depuis le clavier.
Les données qui seront envoyées par chaque bouton sont définies dans l'argument callback_data, lors de la création du bouton. Les données envoyées par le bouton peuvent être obtenues à l'aide de la structure update$callback_query$data, à l'intérieur de la méthode answer_cb.
Pour que le bot réagisse au clavier Inline, la méthode answer_cb traité par un gestionnaire spécialisé : CallbackQueryHandler(answer_cb). Qui exécute la méthode spécifiée lors de l'appui sur un bouton Inline. Le gestionnaire CallbackQueryHandler prend deux arguments :
callback— La méthode à exécuterpattern— Filtre des données qui sont liées au bouton via l'argumentcallback_data.
Ainsi, à l'aide de l'argument pattern nous pouvons écrire une méthode distincte pour chaque bouton lorsque celui-ci est pressé :
Code 3 : Séparons les méthodes pour chaque bouton Inline
library(telegram.bot)
# créer une instance de la classe Updater
updater <- Updater('VOTRE TOKEN DE BOT')
# méthode pour envoyer un clavier InLine
test <- function(bot, update) {
# créer le clavier InLine
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton("Oui", callback_data = 'yes'),
InlineKeyboardButton("Non", callback_data = 'no')
)
)
)
# Envoyer le clavier dans le chat
bot$sendMessage(update$message$chat_id,
text = "Avez-vous le coronavirus ?",
reply_markup = IKM)
}
# méthode pour traiter l'appui sur le bouton Oui
answer_cb_yes <- function(bot, update) {
# obtenir le nom d'utilisateur qui a appuyé sur le bouton
uname <- update$effective_user()$first_name
# traitement du résultat
msg <- paste0(uname, ", malheureusement votre test pour le covid-19 est positif.")
# Envoi du message
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# informer le bot que la requête du bouton a été acceptée
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# méthode pour traiter l'appui sur le bouton Non
answer_cb_no <- function(bot, update) {
# obtenir le nom d'utilisateur qui a appuyé sur le bouton
uname <- update$effective_user()$first_name
msg <- paste0(uname, ", félicitations, votre test pour le covid-19 est négatif.")
# Envoi du message
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# informer le bot que la requête du bouton a été acceptée
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# créer des gestionnaires
inline_h <- CommandHandler('test', test)
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')
# ajouter les gestionnaires au dispatcher
updater <- updater +
inline_h +
query_handler_yes +
query_handler_no
# démarrer le bot
updater$start_polling()Exécutez l'exemple de code ci-dessus, en remplaçant 'VOTRE TOKEN DE BOT' par le véritable token que vous avez obtenu lors de la création du bot via BotFather (j'ai parlé de la création de bot dans ).
Nous avons maintenant écrit 2 méthodes distinctes, c'est-à-dire une méthode pour l'appui sur chaque bouton, et utilisé l'argument pattern, lors de la création de leurs gestionnaires :
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')Le code de la méthode se termine answer_cb la commande bot$answerCallbackQuery(callback_query_id = update$callback_query$id), qui informe le bot que les données du clavier inline ont été reçues.
Exemple d'un bot qui informe de la météo actuelle dans une ville choisie
Essayons de créer un bot qui demande des données sur la météo.
Sa logique de fonctionnement sera la suivante. Au départ, vous /start appelez le clavier principal, qui ne contient qu'un seul bouton "Météo". En appuyant sur ce bouton, vous recevez un message avec un clavier Inline pour sélectionner la ville dont vous souhaitez connaître la météo actuelle. Vous choisissez l'une des villes, et vous recevez la météo actuelle.
Dans cet exemple de code, nous allons utiliser plusieurs packages supplémentaires :
httr— un package pour travailler avec des requêtes HTTP, sur la base duquel toute interaction avec une API est construite. Dans notre cas, nous allons utiliser une API gratuite .stringr— un package pour travailler avec le texte, que nous utiliserons pour formuler le message sur la météo de la ville choisie.
Code 4 : Un bot qui informe de la météo actuelle dans la ville choisie
library(telegram.bot)
library(httr)
library(stringr)
# Créons une instance de la classe Updater
updater <- Updater('VOTRE TOKEN DE BOT')
# Créons des méthodes
## méthode pour lancer le clavier principal
start <- function(bot, update) {
# Créons le clavier
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Météo")
)
),
resize_keyboard = TRUE,
one_time_keyboard = TRUE
)
# Envoyons le clavier
bot$sendMessage(update$message$chat_id,
text = 'Choisissez une commande',
reply_markup = RKM)
}
## Méthode pour appeler le clavier Inline
weather <- function(bot, update) {
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton(text = 'Moscou', callback_data = 'New York,us'),
InlineKeyboardButton(text = 'Saint-Pétersbourg', callback_data = 'Saint Petersburg'),
InlineKeyboardButton(text = 'New York', callback_data = 'New York')
),
list(
InlineKeyboardButton(text = 'Ekaterinbourg', callback_data = 'Yekaterinburg,ru'),
InlineKeyboardButton(text = 'Berlin', callback_data = 'Berlin,de'),
InlineKeyboardButton(text = 'Paris', callback_data = 'Paris,fr')
),
list(
InlineKeyboardButton(text = 'Rome', callback_data = 'Rome,it'),
InlineKeyboardButton(text = 'Odessa', callback_data = 'Odessa,ua'),
InlineKeyboardButton(text = 'Kyiv', callback_data = 'Kyiv,fr')
),
list(
InlineKeyboardButton(text = 'Tokyo', callback_data = 'Tokyo'),
InlineKeyboardButton(text = 'Amsterdam', callback_data = 'Amsterdam,nl'),
InlineKeyboardButton(text = 'Washington', callback_data = 'Washington,us')
)
)
)
# Envoyer le Clavier Inline
bot$sendMessage(chat_id = update$message$chat_id,
text = "Choisissez une ville",
reply_markup = IKM)
}
# Méthode pour répondre avec la météo
answer_cb <- function(bot, update) {
# Obtenons la ville depuis le message
city <- update$callback_query$data
# Envoyons la requête
ans <- GET('https://api.openweathermap.org/data/2.5/weather',
query = list(q = city,
lang = 'fr',
units = 'metric',
appid = '4776568ccea136ffe4cda9f1969af340'))
# Analysons la réponse
result <- content(ans)
# Formons le message
msg <- str_glue("{result$name} météo:n",
"Température actuelle : {result$main$temp}n",
"Vitesse du vent : {result$wind$speed}n",
"Description : {result$weather[[1]]$description}")
# Envoyons l'information sur la météo
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# Créons des filtres
## messages avec texte Météo
MessageFilters$weather <- BaseFilter(function(message) {
# Vérifions le texte du message
message$text == "Météo"
}
)
# Créons des gestionnaires
h_start <- CommandHandler('start', start)
h_weather <- MessageHandler(weather, filters = MessageFilters$weather)
h_query_handler <- CallbackQueryHandler(answer_cb)
# Ajoutons des gestionnaires au dispatcher
updater <- updater +
h_start +
h_weather +
h_query_handler
# Démarrons le bot
updater$start_polling()Exécutez l'exemple de code ci-dessus, en remplaçant 'VOTRE TOKEN DE BOT' par le véritable token que vous avez obtenu lors de la création du bot via BotFather (j'ai parlé de la création de bot dans ).
En conséquence, notre bot fonctionnera à peu près comme ça :
Schématiquement, ce bot peut être représenté comme suit :
Nous avons créé 3 méthodes disponibles dans notre bot météo :
- start — Lancement du clavier principal du bot
- weather — Lancement du clavier Inline pour choisir une ville
- answer_cb — La méthode principale qui, pour la ville donnée, interroge l'API météo et envoie les informations au chat.
Méthode start nous l'activons avec la commande /start, ce qui est réalisé par le gestionnaire CommandHandler('start', start).
Pour activer la méthode weather nous avons créé un filtre homonyme :
# создаём фильтры
## сообщения с текстом Погода
MessageFilters$weather <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Погода"
}
)Et nous appelons cette méthode avec le gestionnaire de messages suivant : MessageHandler(weather, filters = MessageFilters$weather).
Et finalement, notre méthode principale answer_cb réagit à l'appui des boutons Inline, ce qui est réalisé par un gestionnaire spécial : CallbackQueryHandler(answer_cb).
À l'intérieur de la méthode answer_cb, nous lisons les données envoyées depuis le clavier et les enregistrons dans la variable city: city <- update$callback_query$data. Après cela, nous demandons des données météo via l'API, formons et envoyons un message, et finalement utilisons la méthode answerCallbackQuery pour informer le bot que nous avons traité l'appui du bouton Inline.
Un exemple de bot qui affiche la liste des articles les plus récents avec des liens vers le Hub spécifié depuis .
Ce bot est fourni pour vous montrer comment afficher des boutons Inline qui mènent à des pages web.
La logique de ce bot est similaire à la précédente, nous lançons d'abord le clavier principal avec la commande /start. Ensuite, le bot nous propose une liste de 6 hubs, nous choisissons le hub qui nous intéresse, et recevons les 5 publications les plus récentes du hub sélectionné.
Comme vous pouvez le comprendre, dans ce cas, nous devons obtenir une liste d'articles, et pour cela nous allons utiliser un paquet spécial habR, qui permet de demander des articles sur Habr et quelques statistiques à leur sujet en R.
Le paquet habR ne peut être installé que depuis github, pour cela, vous aurez besoin d'un paquet supplémentaire devtools. Pour installer, utilisez le code ci-dessous.
install.packages('devtools')
devtools::install_github('selesnow/habR')Maintenant, examinons le code de construction du bot décrit ci-dessus :
Code 5 : Bot qui affiche la liste des articles les plus récents selon le Hub sélectionné
library(telegram.bot)
library(habR)
# Créons une instance de la classe Updater
updater <- Updater('VOTRE TOKEN DE BOT')
# Créons des méthodes
## méthode pour lancer le clavier principal
start <- function(bot, update) {
# Créons le clavier
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Liste des articles")
)
),
resize_keyboard = TRUE,
one_time_keyboard = TRUE
)
# Envoyons le clavier
bot$sendMessage(update$message$chat_id,
text = 'Sélectionnez une commande',
reply_markup = RKM)
}
## Méthode pour appeler le clavier Inline
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 = 'Visualisation des données', callback_data = 'data_visualization')
)
)
)
# Envoyer le clavier inline
bot$sendMessage(chat_id = update$message$chat_id,
text = "Sélectionnez un Hub",
reply_markup = IKM)
}
# méthode pour répondre sur la météo
answer_cb <- function(bot, update) {
# obtenons la ville depuis le message
hub <- update$callback_query$data
# message pour indiquer que les données de la bouton ont été reçues
bot$answerCallbackQuery(callback_query_id = update$callback_query$id,
text = 'Veuillez patienter quelques minutes, la demande est en cours de traitement')
# message pour indiquer qu'il faut attendre pendant que le bot obtient les données
mid <- bot$sendMessage(chat_id = update$from_chat_id(),
text = "Veuillez patienter quelques minutes pendant que je recueille les données du Hub sélectionné")
# parsing Hub
posts <- head(habr_hub_posts(hub, 1), 5)
# supprime le message demandant d'attendre
bot$deleteMessage(update$from_chat_id(), mid$message_id)
# formons la liste des boutons
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# créons le clavier
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)
# envoyons les informations sur la météo
bot$sendMessage(chat_id = update$from_chat_id(),
text = paste0("5 articles les plus récents du Hub ", hub),
reply_markup = IKM)
}
# Créons des filtres
## messages avec le texte Météo
MessageFilters$hubs <- BaseFilter(function(message) {
# vérifions le texte du message
message$text == "Liste des articles"
}
)
# Créons des gestionnaires
h_start <- CommandHandler('start', start)
h_hubs <- MessageHandler(habs, filters = MessageFilters$hubs)
h_query_handler <- CallbackQueryHandler(answer_cb)
# ajoutons les gestionnaires au gestionnaire
updater <- updater +
h_start +
h_hubs +
h_query_handler
# Démarrons le bot
updater$start_polling()Exécutez l'exemple de code ci-dessus, en remplaçant 'VOTRE TOKEN DE BOT' par le véritable token que vous avez obtenu lors de la création du bot via BotFather (j'ai parlé de la création de bot dans ).
En fin de compte, nous obtiendrons le résultat suivant :
La liste des hubs disponibles pour sélection a été codée en dur dans la méthode hubs:
## Метод вызова 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)
}Nous obtenons la liste des articles du hub spécifié par la commande habr_hub_posts(), à partir du package habR. Indiquant que nous ne souhaitons pas la liste des articles de tout temps, mais seulement la première page contenant 20 articles. À partir du tableau obtenu avec la commande head() , nous ne gardons que les 5 premiers, qui sont les plus récents.
# парсим Хабр
posts <- head(habr_hub_posts(hub, 1), 5)La logique est très similaire à celle du précédent bot, mais dans ce cas, nous générons dynamiquement le clavier Inline avec la liste des articles à l'aide de la fonction lapply().
# формируем список кнопок
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# формируем клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)Nous insérons le titre de l'article dans le texte du bouton posts$title[x], et en argument url le lien vers l'article : url = posts$link[x].
Ensuite, nous créons un filtre, des gestionnaires et lançons notre bot.
Conclusion
Maintenant, les bots que vous avez écrits seront beaucoup plus pratiques à utiliser, car leur gestion se fera par le biais du clavier, et non par la saisie de commandes. Au moins lors de l'interaction avec le bot via un smartphone, le clavier simplifiera considérablement l'utilisation.
Dans le prochain article, nous verrons comment construire un dialogue logique avec le bot et travailler avec des bases de données.
Source : habr.com
