L'audience de Telegram augmente chaque jour de manière exponentielle, grâce à la commodité du messager, la présence de chaînes et de chats, et bien sûr la possibilité de créer des bots.

Les bots peuvent être utilisés à des fins très diverses, de l'automatisation des communications avec vos clients à la gestion de vos propres tâches.

En essence, à travers un bot, il est possible d'effectuer n'importe quelle opération sur Telegram : envoyer ou demander des données, lancer des tâches sur le serveur, collecter des informations dans une base de données, envoyer des e-mails, etc.

Je prévois d'écrire une série d'articles sur comment travailler avec l'API du bot Telegram, et de créer des bots selon mes besoins.

Dans cet article, le premier, nous allons découvrir comment créer un bot Telegram et envoyer des notifications via celui-ci.

En conséquence, nous obtiendrons un bot qui vérifiera le statut de la dernière exécution de toutes les tâches dans le planificateur de tâches Windows et vous enverra des notifications si certaines ont échoué.

Cependant, l'objectif de cette série d'articles n'est pas de vous apprendre à écrire un bot pour une tâche précise, mais de vous familiariser en général avec la syntaxe du package telegram.bot, et des exemples de code, grâce auxquels vous pourrez écrire des bots pour résoudre vos propres tâches.

Contenu

Si vous vous intéressez à l'analyse de données, mes telegram et youtube canaux pourraient vous intéresser. La majeure partie du contenu y est consacrée au langage R.

Création d'un bot Telegram
Installation du package pour travailler avec le bot Telegram en R
Envoi de messages de R vers Telegram
Configuration du calendrier pour vérifier les tâches
Conclusion

Création d'un bot Telegram

Pour commencer, nous devons créer un bot. Cela se fait via un bot spécial BotFather, rendez-vous sur le lien et écrivez au bot /start.

Après cela, vous recevrez un message avec la liste des commandes :

Message de BotFather

Je peux vous aider à créer et gérer des bots Telegram. Si vous débutez avec l'API Bot, veuillez consulter le manuel (https://core.telegram.org/bots).

Vous pouvez me contrôler en envoyant ces commandes :

/newbot - créer un nouveau bot
/mybots - modifier vos bots [beta]

Modifier les bots
/setname - changer le nom d'un bot
/setdescription - changer la description du bot
/setabouttext - changer les informations sur le bot
/setuserpic - changer la photo de profil du bot
/setcommands - changer la liste des commandes
/deletebot - supprimer un bot

Paramètres du bot
/token - générer un jeton d'autorisation
/revoke - révoquer le jeton d'accès du bot
/setinline - basculer le mode inline (https://core.telegram.org/bots/inline)
/setinlinegeo - activer ou désactiver les demandes de localisation inline (https://core.telegram.org/bots/inline#location-based-results)
/setinlinefeedback - changer les paramètres de retour d'information inline (https://core.telegram.org/bots/inline#collecting-feedback)
/setjoingroups - votre bot peut-il être ajouté à des groupes ?
/setprivacy - basculer le mode de confidentialité (https://core.telegram.org/bots#privacy-mode) dans les groupes

Jeux
/mygames - modifier vos jeux (https://core.telegram.org/bots/games) [beta]
/newgame - créer un nouveau jeu (https://core.telegram.org/bots/games)
/listgames - obtenir une liste de vos jeux
/editgame - modifier un jeu
/deletegame - supprimer un jeu existant

Pour créer un nouveau bot, envoyez la commande /newbot.

BotFather vous demandera de saisir le nom et le nom d'utilisateur du bot.

BotFather, [25.07.20 09:39]
D'accord, un nouveau bot. Comment allons-nous l'appeler ? Veuillez choisir un nom pour votre bot.

Alexey Seleznev, [25.07.20 09:40]
Mon Bot de Test

BotFather, [25.07.20 09:40]
Bien. Maintenant, choisissons un nom d'utilisateur pour votre bot. Il doit se terminer par `bot`. Comme ceci, par exemple : TetrisBot ou tetris_bot.

Alexey Seleznev, [25.07.20 09:40]
@mon_bot_de_test

Vous pouvez entrer un nom au choix, mais le nom d'utilisateur doit se terminer par bot.

Si vous avez tout fait correctement, vous recevrez le message suivant :

Fait ! Félicitations pour votre nouveau bot. Vous le trouverez à t.me/mon_bot_de_test. Vous pouvez maintenant ajouter une description, une section à propos et une photo de profil pour votre bot, voir /help pour une liste de commandes. Au fait, une fois que vous aurez fini de créer votre super bot, contactez notre support Bot si vous souhaitez un meilleur nom d'utilisateur pour celui-ci. Assurez-vous simplement que le bot est entièrement opérationnel avant de le faire.

Utilisez ce jeton pour accéder à l'API HTTP :
123456789:abcdefghijklmnopqrstuvwxyz

Pour une description de l'API Bot, consultez cette page : https://core.telegram.org/bots/api

Ensuite, vous aurez besoin du jeton API obtenu, dans mon exemple c'est 123456789:abcdefghijklmnopqrstuvwxyz.

À ce stade, les préparatifs pour la création du bot sont terminés.

Installation du package pour travailler avec le bot Telegram en R

Je suppose que vous avez déjà installé R et l'environnement de développement RStudio. Si ce n'est pas le cas, vous pouvez consulter ce tutoriel vidéo sur la façon de les installer.

Pour travailler avec l'API Bot de Telegram, nous allons utiliser le paquet R telegram.bot.

L'installation des paquets en R se fait par la fonction install.packages(), donc pour installer le paquet dont nous avons besoin, utilisez la commande install.packages("telegram.bot").

Pour en savoir plus sur l'installation des différents paquets, consultez cette vidéo.

Après l'installation du paquet, il faut le connecter :

library(telegram.bot)

Envoi de messages de R vers Telegram

Vous pouvez trouver le bot que vous avez créé dans Telegram avec le nom d'utilisateur que vous avez défini lors de sa création, dans mon cas c'est @mon_bot_de_test.

Envoyez un message quelconque au bot, par exemple « Bonjour bot ». Pour le moment, nous en avons besoin pour obtenir l'ID de votre chat avec le bot.

Maintenant, dans R, écrivez le code suivant.

library(telegram.bot)

# créons une instance du bot
bot <- Bot(token = "123456789:abcdefghijklmnopqrstuvwxyz")

# Demandons des informations sur le bot
print(bot$getMe())

# Obtenons les mises à jour du bot, c'est-à-dire la liste des messages qui lui ont été envoyés
updates <- bot$getUpdates()

# Demandons l'identifiant du chat
# Remarque : avant de demander les mises à jour, vous devez envoyer un message au bot
chat_id <- updates[[1L]]$from_chat_id()

Au départ, nous créons une instance de notre bot avec la fonction Bot(), en tant qu'argument, il est nécessaire de transmettre le token obtenu précédemment.

Conserver le token dans le code n’est pas la meilleure pratique, vous pouvez donc le stocker dans une variable d'environnement et le lire à partir de celle-ci. Par défaut, le package telegram.bot implémente le support des variables d'environnement suivantes : R_TELEGRAM_BOT_NOM_DE_VOTRE_BOT. Au lieu de NOM_DE_VOTRE_BOT insérez le nom que vous avez défini lors de sa création, dans mon cas la variable sera R_TELEGRAM_BOT_My Test Bot.

Vous pouvez créer une variable d'environnement de plusieurs manières. Je vais vous parler de la méthode la plus universelle et multiplateforme. Créez dans votre répertoire personnel (vous pouvez le trouver en utilisant la commande path.expand("~")) un fichier texte nommé .Renviron. Vous pouvez également le faire à l'aide de la commande file.edit(path.expand(file.path("~", ".Renviron"))).

Et ajoutez-y la ligne suivante.

R_TELEGRAM_BOT_NOM_DE_VOTRE_BOT=123456789:abcdefghijklmnopqrstuvwxyz

Ensuite, vous pouvez utiliser le token enregistré dans la variable d'environnement avec la fonction bot_token(), c'est-à-dire comme ceci :

bot <- Bot(token = bot_token("My Test Bot"))

Méthode getUpdates()permet de recevoir les mises à jour du bot, c’est-à-dire les messages qui lui ont été envoyés. La méthode from_chat_id(), permet d’obtenir l'identifiant du chat à partir duquel le message a été envoyé. Cet identifiant est nécessaire pour envoyer des messages au bot.

En plus de l'ID du chat de l'objet obtenu par la méthode getUpdates() vous obtenez également des informations utiles supplémentaires. Par exemple, des informations sur l'utilisateur qui a envoyé le message.

updates[[1L]]$message$from

$id
[1] 000000000

$is_bot
[1] FALSE

$first_name
[1] "Alexey"

$last_name
[1] "Seleznev"

$username
[1] "AlexeySeleznev"

$language_code
[1] "ru"

Ainsi, à ce stade, nous avons déjà tout ce qu'il faut pour envoyer un message depuis le bot sur Telegram. Utilisons la méthode sendMessage(), dans lequel il est nécessaire de transmettre l'identifiant du chat, le texte du message et le type de balisage du texte du message. Le type de balisage peut être Markdown ou HTML et est défini par un argument. parse_mode.

# Отправка сообщения
bot$sendMessage(chat_id,
                text = "Привет, *жирный текст* _курсив_",
                parse_mode = "Markdown"
)

Principes de base du balisage Markdown :

Le texte en gras est mis en évidence à l'aide du symbole * :
- exemple : *texte en gras*
- résultat : texte en gras
L'italique est défini par un underscore :
- exemple : _italique_
- résultat : italique
Le texte en monospace, généralement utilisé pour le code, est défini à l'aide d'accent graves ` :
- exemple : `texte en monospace`
- résultat : texte en monospace

Principes de base du balisage HTML :
En HTML, vous entourez une partie du texte que vous souhaitez mettre en évidence avec des balises, exemple texte.

— balise d'ouverture
— balise de fermeture

Balises de balisage HTML

<b> — texte en gras
- exemple : <b>texte en gras</b>
- résultat texte en gras
— italique

exemple : italique

résultat : italique

— texte en monospace exemple : texte en monospace résultat : texte en monospace

En plus du texte, vous pouvez envoyer d'autres contenus en utilisant des méthodes spéciales :

# Отправить изображение
bot$sendPhoto(chat_id,
  photo = "https://telegram.org/img/t_logo.png"
)

# Отправка голосового сообщения
bot$sendAudio(chat_id,
  audio = "http://www.largesound.com/ashborytour/sound/brobob.mp3"
)

# Отправить документ
bot$sendDocument(chat_id,
  document = "https://github.com/ebeneditos/telegram.bot/raw/gh-pages/docs/telegram.bot.pdf"
)

# Отправить стикер
bot$sendSticker(chat_id,
  sticker = "https://www.gstatic.com/webp/gallery/1.webp"
)

# Отправить видео
bot$sendVideo(chat_id,
  video = "http://techslides.com/demos/sample-videos/small.mp4"
)

# Отправить gif анимацию
bot$sendAnimation(chat_id,
  animation = "https://media.giphy.com/media/sIIhZliB2McAo/giphy.gif"
)

# Отправить локацию
bot$sendLocation(chat_id,
  latitude = 51.521727,
  longitude = -0.117255
)

# Имитация действия в чате
bot$sendChatAction(chat_id,
  action = "typing"
)

C'est-à-dire, par exemple, à l'aide de la méthode sendPhoto() vous pouvez envoyer un graphique enregistré sous forme d'image que vous avez créé à l'aide du package ggplot2.

`Vérification du planificateur de tâches Windows et envoi d'une notification concernant les tâches dont l'exécution a échoué`

Pour travailler avec le planificateur de tâches Windows, vous devez installer le package taskscheduleR, et pour faciliter le travail avec les données, nous installerons le package dplyr.

# Установка пакетов
install.packages(c('taskscheduleR', 'dplyr'))
# Подключение пакетов
library(taskscheduleR)
library(dplyr)

Ensuite, à l'aide de la fonction taskscheduler_ls() nous demandons des informations sur les tâches de notre planificateur. Avec la fonction filter() du paquet dplyr nous supprimons de la liste des tâches celles qui ont été exécutées avec succès et qui ont un statut de dernier résultat 0, celles qui n'ont jamais été lancées et qui ont un statut 267011, les tâches désactivées et celles qui s'exécutent actuellement.

# запрашиваем список задач
task <- task <- taskscheduler_ls() %>%
        filter(! `Last Result`  %in% c("0", "267011") & 
               `Scheduled Task State` == "Enabled" & 
               Status != "Running") %>%
        select(TaskName) %>%
        unique() %>%
        unlist() %>%
        paste0(., collapse = "n")

Dans l'objet task nous avons maintenant une liste de tâches dont l'exécution a échoué, cette liste doit être envoyée sur Telegram.

Si nous examinons chaque commande plus en détail, alors :

filter() — filtre la liste des tâches selon les conditions décrites ci-dessus select() — ne conserve dans le tableau qu'un seul champ avec le nom des tâches unique() — supprime les doublons des noms unlist() — convertit la colonne sélectionnée du tableau en vecteur paste0() — relie les noms des tâches en une seule chaîne, en utilisant comme séparateur un retour à la ligne, c'est-à-dire. n.

Tout ce qu'il nous reste à faire est d'envoyer ce résultat sur Telegram.

bot$sendMessage(chat_id,
                text = task,
                parse_mode = "Markdown"
)

À ce jour, le code du bot ressemble à ceci :

Code du bot vérifiant les tâches

# Подключение пакета
library(telegram.bot)
library(taskscheduleR)
library(dplyr)

# инициализируем бота
bot <- Bot(token = "123456789:abcdefghijklmnopqrstuvwxyz")

# идентификатор чата
chat_id <- 123456789

# запрашиваем список задач
task <- taskscheduler_ls() %>%
        filter(! `Last Result`  %in% c("0", "267011")  &
               `Scheduled Task State` == "Enabled" & 
               Status != "Running") %>%
        select(TaskName) %>%
        unique() %>%
        unlist() %>%
        paste0(., collapse = "n")

# если есть проблемные задачи отправляем сообщение
if ( task != "" ) {

  bot$sendMessage(chat_id,
                  text = task,
                  parse_mode = "Markdown"
  )

}

En utilisant l'exemple ci-dessus, remplacez dans le code le token de votre bot et votre identifiant de chat.

Vous pouvez ajouter des conditions de filtrage des tâches, par exemple en vérifiant uniquement les tâches que vous avez créées, en excluant celles du système.

Vous pouvez également extraire divers paramètres dans un fichier de configuration séparé et y stocker l'id de chat et le token. Vous pouvez lire la configuration par exemple à l'aide du package configr.

Exemple de configuration ini

[telegram_bot]
;paramètres du bot Telegram et du chat dans lequel les notifications seront envoyées
chat_id=12345678
bot_token=123456789:abcdefghijklmnopqrstuvwxyz"

Exemple de lecture des variables depuis la config en R

library(configr)

# lecture de la config
config <- read.config('C:/chemin_vers_la_config/config.cfg', rcmd.parse = TRUE)

bot_token <- config$telegram_bot$bot_token
chat_id     <- config$telegram_bot$chat_id

`Configuration du calendrier pour vérifier les tâches`

Le processus de configuration pour l'exécution de scripts selon un calendrier est expliqué en détail dans cet article. articleIci, je vais simplement décrire les étapes à suivre. Si l'une des étapes n'est pas claire, veuillez vous référer à l'article dont j'ai fourni le lien.

Supposons que nous avons enregistré le code de notre bot dans un fichier check_bot.R. Pour planifier l'exécution régulière de ce fichier, suivez les étapes suivantes :

Ajoutez dans la variable système Path le chemin du dossier où R est installé, sous Windows, le chemin sera à peu près le suivant : C:Program FilesRR-4.0.2bin. Créez un fichier bat exécutable, qui contiendra uniquement une ligne R CMD BATCH C:rscriptscheck_botcheck_bot.R. Remplacez C:rscriptscheck_botcheck_bot.R vers le chemin complet de votre fichier R. Ensuite, configurez à l'aide du planificateur de tâches Windows un emploi du temps d'exécution, par exemple toutes les demi-heures.

`Conclusion`

Dans cet article, nous avons étudié comment créer un bot et envoyer diverses notifications via Telegram.

J'ai décrit la tâche de contrôle du planificateur de tâches Windows, mais vous pouvez utiliser le matériel de cet article pour envoyer n'importe quelles notifications, des prévisions météo aux cotations boursières, car R vous permet de vous connecter à d'innombrables sources de données.

Dans le prochain article, nous examinerons comment ajouter des commandes et un clavier au bot, afin qu'il puisse non seulement envoyer des notifications, mais également effectuer des actions plus complexes.

Source : habr.com

Création d'un bot Telegram en langage R (partie 1) : Créons le bot et envoyons des messages dans Telegram avec lui