This is the third article in the "Writing a telegram bot in R" series. In previous publications, we learned how to create a telegram bot, send messages through it, added commands and message filters to the bot. Therefore, before reading this article, I highly recommend that you familiarize yourself with previous, because here I will not stop on the previously described basics of bot building.

In this article, we will improve the usability of our bot by adding a keyboard that will make the bot's interface intuitive and easy to use.

All articles from the series "Writing a telegram bot in R"

Content

If you are interested in data analysis, you might be interested in my telegram и youtube channels. Most of the content of which is devoted to the R language.

What types of keyboards does the telegram bot support?
Reply keyboard
Inline keyboard
3.1. An example of a simple bot with support for InLine buttons
3.2. An example of a bot that reports the current weather for a selected city
3.3. An example of a bot that displays a list of the most recent articles with links according to the specified Habu from habr.com
Conclusion

What types of keyboards does the telegram bot support?

At the time of writing the article telegram.bot allows you to create two types of keyboards:

Reply - The main, regular keyboard, which is located under the message text input panel. Such a keyboard simply sends a text message to the bot, and as text it will send the text that is written on the button itself.
Inline - Keyboard tied to a specific bot message. This keyboard sends to the bot data associated with the pressed button, this data may differ from the text written on the button itself. And such buttons are processed through CallbackQueryHandler.

In order for the bot to open the keyboard, it is necessary when sending a message through the method sendMessage(), pass the previously created keyboard to the argument reply_markup.

Below we will look at a few examples.

Reply keyboard

As I wrote above, this is the main bot control keyboard.

An example of creating a Reply keyboard from official help

bot <- Bot(token = "TOKEN")
chat_id <- "CHAT_ID"

# Create Custom Keyboard
text <- "Aren't those custom keyboards cool?"
RKM <- ReplyKeyboardMarkup(
  keyboard = list(
    list(KeyboardButton("Yes, they certainly are!")),
    list(KeyboardButton("I'm not quite sure")),
    list(KeyboardButton("No..."))
  ),
  resize_keyboard = FALSE,
  one_time_keyboard = TRUE
)

# Send Custom Keyboard
bot$sendMessage(chat_id, text, reply_markup = RKM)

The above is an example from the official package help. telegram.bot. To create a keyboard, use the function ReplyKeyboardMarkup(), which in turn accepts a list of button lists that are created by the function KeyboardButton().

Why in ReplyKeyboardMarkup() it is necessary to transfer not just a list, but a list of lists? The thing is that you are passing the main list, and in it you set each row of buttons as separate lists, because Several buttons can be placed in one row.

Argument resize_keyboard allows you to automatically select the optimal size of the keyboard buttons, and the argument one_time_keyboard allows you to hide the keyboard after each button press.

Let's write a simple bot that will have 3 buttons:

Chat ID - Request the chat ID of the conversation with the bot
My name - Request your name
My login - Request your username in telegram

Code 1: Simple Bot with Reply Keyboard

library(telegram.bot)

# создаём экземпляр класса Updater
updater <- Updater('ТОКЕН ВАШЕГО БОТА')

# создаём методы
## метод для запуска клавиатуры
start <- function(bot, update) {

  # создаём клавиатуру
  RKM <- ReplyKeyboardMarkup(
    keyboard = list(
      list(KeyboardButton("Чат ID")),
      list(KeyboardButton("Моё имя")),
      list(KeyboardButton("Мой логин"))
    ),
    resize_keyboard = FALSE,
    one_time_keyboard = TRUE
  )

  # отправляем клавиатуру
  bot$sendMessage(update$message$chat_id,
                  text = 'Выберите команду', 
                  reply_markup = RKM)

}

## метод возвразающий id чата
chat_id <- function(bot, update) {

  bot$sendMessage(update$message$chat_id, 
                  text = paste0("Чат id этого диалога: ", update$message$chat_id),
                  parse_mode = "Markdown")

}

## метод возвращающий имя
my_name <- function(bot, update) {

  bot$sendMessage(update$message$chat_id, 
                  text = paste0("Вас зовут ", update$message$from$first_name),
                  parse_mode = "Markdown")

}

## метод возвращающий логин
my_username <- function(bot, update) {

  bot$sendMessage(update$message$chat_id, 
                  text = paste0("Ваш логин ", update$message$from$username),
                  parse_mode = "Markdown")

}

# создаём фильтры
## сообщения с текстом Чат ID
MessageFilters$chat_id <- BaseFilter(function(message) {

  # проверяем текст сообщения
  message$text == "Чат ID"

}
)

## сообщения с текстом Моё имя
MessageFilters$name <- BaseFilter(function(message) {

  # проверяем текст сообщения
  message$text == "Моё имя"

}
)

## сообщения с текстом Мой логин
MessageFilters$username <- BaseFilter(function(message) {

  # проверяем текст сообщения
  message$text == "Мой логин"
)

# создаём обработчики
h_start    <- CommandHandler('start', start)
h_chat_id  <- MessageHandler(chat_id, filters = MessageFilters$chat_id)
h_name     <- MessageHandler(my_name, filters = MessageFilters$name)
h_username <- MessageHandler(my_username, filters = MessageFilters$username)

# добавляем обработчики в диспетчер
updater <- updater + 
            h_start +
            h_chat_id +
            h_name +
            h_username

# запускаем бота 
updater$start_polling()

Run the code example above, after replacing 'YOUR BOT TOKEN' with the real token you received when you created the bot via Bot Father (I talked about creating a bot in first article).

After launch, give the bot the command /start, because that is what we defined to launch the keyboard.

If at the moment it is difficult for you to parse the given code example, with the creation of methods, filters and handlers, then you should return to the previous one. article, in which I described all this in detail.

We have created 4 methods:

start — Keyboard start
chat_id — Query chat id
my_name - Request your name
my_username - Request your login

To object MessageFilters added 3 message filters, by their text:

chat_id — Messages with text "Чат ID"
name — Messages with text "Моё имя"
username — Messages with text "Мой логин"

And we created 4 handlers that, according to the given commands and filters, will execute the specified methods.

# создаём обработчики
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)

The keyboard itself is created inside the method start() the team ReplyKeyboardMarkup().

RKM <- ReplyKeyboardMarkup(
    keyboard = list(
      list(KeyboardButton("Чат ID")),
      list(KeyboardButton("Моё имя")),
      list(KeyboardButton("Мой логин"))
    ),
    resize_keyboard = FALSE,
    one_time_keyboard = TRUE
)

In our case, we placed all the buttons under each other, but we can arrange them in one row by making changes to the list of button lists. Because one row inside the keyboard is created through a nested list of buttons, then in order to bring our buttons into one row, we need to rewrite part of the code for building the keyboard like this:

RKM <- ReplyKeyboardMarkup(
    keyboard = list(
      list(
          KeyboardButton("Чат ID"),
          KeyboardButton("Моё имя"),
          KeyboardButton("Мой логин")
     )
    ),
    resize_keyboard = FALSE,
    one_time_keyboard = TRUE
)

The keyboard is sent to the chat by the method sendMessage(), in the argument reply_markup.

  bot$sendMessage(update$message$chat_id,
                  text = 'Выберите команду', 
                  reply_markup = RKM)

Inline keyboard

As I wrote above, the Inline keyboard is tied to a specific message. Working with it is somewhat more difficult than with the main keyboard.

Initially, you need to add a method to the bot to call the Inline keyboard.

To respond to an Inline button press, you can also use the bot method answerCallbackQuery(), which can display a notification in the telegram interface, to the user who clicked the Inline button.

The data sent from the Inline button is not text, so to process it, you need to create a special handler using the command CallbackQueryHandler().

The code for building an Inline keyboard, which is given in the official help of the package telegram.bot.

Code for building an Inline keyboard from the official help

# 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)

It is necessary to build an Inline keyboard using the command InlineKeyboardMarkup(), in the same way as the Reply keyboard. IN InlineKeyboardMarkup() it is necessary to pass a list, Inline lists of buttons, each individual button is created by a function InlineKeyboardButton().

An inline button can either pass some data to the bot using an argument callback_data, or open any HTML page specified with the argument url.

The result will be a list in which each element is also a list of Inline buttons that need to be combined into one row.

Next, we will look at several examples of bots with Inline buttons.

An example of a simple bot with support for InLine buttons

To begin with, we will write a bot for express testing for covid-19. On command /test, it will send you a keyboard with two buttons, depending on the button pressed, it will send you a message with the results of your testing.

Code 2: The simplest bot with Inline keyboard

library(telegram.bot)

# создаём экземпляр класса Updater
updater <- Updater('ТОКЕН ВАШЕГО БОТА')

# метод для отправки InLine клавиатуры
test <- function(bot, update) {

  # создаём InLine клавиатуру
  IKM <- InlineKeyboardMarkup(
    inline_keyboard = list(
      list(
        InlineKeyboardButton("Да", callback_data = 'yes'),
        InlineKeyboardButton("Нет", callback_data = 'no')
      )
    )
  )

  # Отправляем клавиатуру в чат
  bot$sendMessage(update$message$chat_id, 
                  text = "Вы болете коронавирусом?", 
                  reply_markup = IKM)
}

# метод для обработки нажатия кнопки
answer_cb <- function(bot, update) {

  # полученные данные с кнопки
  data <- update$callback_query$data

  # получаем имя пользователя, нажавшего кнопку
  uname <- update$effective_user()$first_name

  # обработка результата
  if ( data == 'no' ) {

    msg <- paste0(uname, ", поздравляю, ваш тест на covid-19 отрицательный.")

  } else {

    msg <- paste0(uname, ", к сожалени ваш тест на covid-19 положительный.")

  }

  # Отправка сообщения
  bot$sendMessage(chat_id = update$from_chat_id(),
                  text = msg)

  # сообщаем боту, что запрос с кнопки принят
  bot$answerCallbackQuery(callback_query_id = update$callback_query$id) 
}

# создаём обработчики
inline_h      <- CommandHandler('test', test)
query_handler <- CallbackQueryHandler(answer_cb)

# добавляем обработчики в диспетчер
updater <- updater + inline_h + query_handler

# запускаем бота
updater$start_polling()

Run the code example above, after replacing 'YOUR BOT TOKEN' with the real token you received when you created the bot via Bot Father (I talked about creating a bot in first article).

Result:

We have created two methods:

test — To send chat to Inline keyboard
answer_cb — To process data sent from the keyboard.

The data that will be sent from each button is specified in the argument callback_data, when creating the button. You can get the data sent from the button using the construction update$callback_query$data, inside the method answer_cb.

To make the bot react to the Inline keyboard, the method answer_cb processed by a special handler: CallbackQueryHandler(answer_cb). Which launches the specified method on pressing the Inline button. Handler CallbackQueryHandler takes two arguments:

callback - Method to run
pattern - Filter by data that is attached to the button using an argument callback_data.

Accordingly, using the argument pattern we can write a separate method for pressing each button:

Code 3: Separate methods for each Inline button

library(telegram.bot)

# создаём экземпляр класса Updater
updater <- Updater('ТОКЕН ВАШЕГО БОТА')

# метод для отправки InLine клавиатуры
test <- function(bot, update) {  

  # создаём InLine клавиатуру
  IKM <- InlineKeyboardMarkup(
    inline_keyboard = list(
      list(
        InlineKeyboardButton("Да", callback_data = 'yes'),
        InlineKeyboardButton("Нет", callback_data = 'no')
      )
    )
  )

  # Отправляем клавиатуру в чат
  bot$sendMessage(update$message$chat_id, 
                  text = "Вы болете коронавирусом?", 
                  reply_markup = IKM)
}

# метод для обработки нажатия кнопки Да
answer_cb_yes <- function(bot, update) {

  # получаем имя пользователя, нажавшего кнопку
  uname <- update$effective_user()$first_name

  # обработка результата
  msg <- paste0(uname, ", к сожалени ваш текст на covid-19 положительный.")

  # Отправка сообщения
  bot$sendMessage(chat_id = update$from_chat_id(),
                  text = msg)

  # сообщаем боту, что запрос с кнопки принят
  bot$answerCallbackQuery(callback_query_id = update$callback_query$id) 
}

# метод для обработки нажатия кнопки Нет
answer_cb_no <- function(bot, update) {

  # получаем имя пользователя, нажавшего кнопку
  uname <- update$effective_user()$first_name

  msg <- paste0(uname, ", поздравляю, ваш текст на covid-19 отрицательный.")

  # Отправка сообщения
  bot$sendMessage(chat_id = update$from_chat_id(),
                  text = msg)

  # сообщаем боту, что запрос с кнопки принят
  bot$answerCallbackQuery(callback_query_id = update$callback_query$id) 
}

# создаём обработчики
inline_h          <- CommandHandler('test', test)
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no  <- CallbackQueryHandler(answer_cb_no, pattern = 'no')

# добавляем обработчики в диспетчер
updater <- updater + 
            inline_h + 
            query_handler_yes +
            query_handler_no

# запускаем бота
updater$start_polling()

Run the code example above, after replacing 'YOUR BOT TOKEN' with the real token you received when you created the bot via Bot Father (I talked about creating a bot in first article).

Now we have written 2 separate methods i.e. one method at a time, under the click of each button, and used the argument pattern, when creating their handlers:

query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no  <- CallbackQueryHandler(answer_cb_no, pattern = 'no')

Method code ends answer_cb the team bot$answerCallbackQuery(callback_query_id = update$callback_query$id), which tells the bot that data has been received from the inline keyboard.

An example of a bot that reports the current weather for a selected city

Let's try to write a bot that requests weather data.

The logic of its work will be as follows. Initially by the team /start you call the main keyboard, in which there is only one button "Weather". By clicking on this button you get a message with an Inline keyboard to select the city for which you want to know the current weather. Choose one of the cities and get the current weather.

In this code example, we will be using a few additional packages:

httr - a package for working with HTTP requests, on the basis of which work with any API is built. In our case, we will use the free API openweathermap.org.
stringr - a package for working with text, in our case we will use it to generate a message about the weather in the selected city.

Code 4: Bot that reports the current weather for the selected city

library(telegram.bot)
library(httr)
library(stringr)

# создаём экземпляр класса Updater
updater <- Updater('ТОКЕН ВАШЕГО БОТА')

# создаём методы
## метод для запуска основной клавиатуры
start <- function(bot, update) {

  # создаём клавиатуру
  RKM <- ReplyKeyboardMarkup(
    keyboard = list(
      list(
        KeyboardButton("Погода")
      )
    ),
    resize_keyboard = TRUE,
    one_time_keyboard = TRUE
  )

  # отправляем клавиатуру
  bot$sendMessage(update$message$chat_id,
                  text = 'Выберите команду', 
                  reply_markup = RKM)

}

## Метод вызова Inine клавиатуры
weather <- function(bot, update) {

  IKM <- InlineKeyboardMarkup(
    inline_keyboard = list(
      list(
        InlineKeyboardButton(text = 'Москва', callback_data = 'New York,us'),
        InlineKeyboardButton(text = 'Санкт-Петербург', callback_data = 'Saint Petersburg'),
        InlineKeyboardButton(text = 'Нью-Йорк', callback_data = 'New York')
      ),
      list(
        InlineKeyboardButton(text = 'Екатеринбург', callback_data = 'Yekaterinburg,ru'),
        InlineKeyboardButton(text = 'Берлин', callback_data = 'Berlin,de'),
        InlineKeyboardButton(text = 'Париж', callback_data = 'Paris,fr')
      ),
      list(
        InlineKeyboardButton(text = 'Рим', callback_data = 'Rome,it'),
        InlineKeyboardButton(text = 'Одесса', callback_data = 'Odessa,ua'),
        InlineKeyboardButton(text = 'Киев', callback_data = 'Kyiv,fr')
      ),
      list(
        InlineKeyboardButton(text = 'Токио', callback_data = 'Tokyo'),
        InlineKeyboardButton(text = 'Амстердам', callback_data = 'Amsterdam,nl'),
        InlineKeyboardButton(text = 'Вашингтон', callback_data = 'Washington,us')
      )
    )
  )

  # Send Inline Keyboard
  bot$sendMessage(chat_id = update$message$chat_id, 
                  text = "Выберите город", 
                  reply_markup = IKM)
}

# метод для сообщения погоды
answer_cb <- function(bot, update) {

  # получаем из сообщения город
  city <- update$callback_query$data

  # отправляем запрос
  ans <- GET('https://api.openweathermap.org/data/2.5/weather', 
             query = list(q     = city,
                          lang  = 'ru',
                          units = 'metric',
                          appid = '4776568ccea136ffe4cda9f1969af340')) 

  # парсим ответ
  result <- content(ans)

  # формируем сообщение
  msg <- str_glue("{result$name} погода:n",
                  "Текущая температура: {result$main$temp}n",
                  "Скорость ветра: {result$wind$speed}n",
                  "Описание: {result$weather[[1]]$description}")

  # отправляем информацию о погоде
  bot$sendMessage(chat_id = update$from_chat_id(),
                  text    = msg)

  bot$answerCallbackQuery(callback_query_id = update$callback_query$id) 
}

# создаём фильтры
## сообщения с текстом Погода
MessageFilters$weather <- BaseFilter(function(message) {

  # проверяем текст сообщения
  message$text == "Погода"

}
)

# создаём обработчики
h_start         <- CommandHandler('start', start)
h_weather       <- MessageHandler(weather, filters = MessageFilters$weather)
h_query_handler <- CallbackQueryHandler(answer_cb)

# добавляем обработчики в диспетчер
updater <- updater + 
              h_start +
              h_weather +
              h_query_handler

# запускаем бота
updater$start_polling()

Run the code example above, after replacing 'YOUR BOT TOKEN' with the real token you received when you created the bot via Bot Father (I talked about creating a bot in first article).

As a result, our bot will work like this:

Schematically, this bot can be drawn like this:

We have created 3 methods available inside our weather bot:

start — Launching the main keyboard of the bot
weather - Launch Inline keyboard to select a city
answer_cb - The main method that requests the weather in the API for a given city and sends it to the chat.

Method start we are running a team /start, which is implemented by the handler CommandHandler('start', start).

To run a method weather we have created a filter of the same name:

# создаём фильтры
## сообщения с текстом Погода
MessageFilters$weather <- BaseFilter(function(message) {

  # проверяем текст сообщения
  message$text == "Погода"

}
)

And we call this method with the following message handler: MessageHandler(weather, filters = MessageFilters$weather).

And finally, our main method answer_cb responds to pressing Inline buttons, which is implemented by a special handler: CallbackQueryHandler(answer_cb).

Inside a Method answer_cb, we read the data sent from the keyboard and write it to a variable city: city <- update$callback_query$data. After that, we request weather data from the API, form and send a message, and finally use the method answerCallbackQuery in order to inform the bot that we have processed the Inline button click.

An example of a bot that displays a list of the most recent articles with links according to the specified Habu from habr.com.

I bring this bot in order to show you how to display Inline buttons that lead to web pages.

The logic of this bot is similar to the previous one, initially we launch the main keyboard with the command /start. Next, the bot gives us a list of 6 hubs to choose from, we select the hub we are interested in, and get the 5 most recent publications from the selected Hub.

As you understand, in this case we need to get a list of articles, and for this we will use a special package habR, which allows you to request articles from habra and some statistics on them in R.

Install package habR you can only from github, for which you will need an additional package devtools. Use the code below to install.

install.packages('devtools')
devtools::install_github('selesnow/habR')

Now consider the code for building the bot described above:

Code 5: Bot that displays a list of the most recent articles on the selected Hub

library(telegram.bot)
library(habR)

# создаём экземпляр класса Updater
updater <- Updater('ТОКЕН ВАШЕГО БОТА')

# создаём методы
## метод для запуска основной клавиатуры
start <- function(bot, update) {

  # создаём клавиатуру
  RKM <- ReplyKeyboardMarkup(
    keyboard = list(
      list(
        KeyboardButton("Список статей")
      )
    ),
    resize_keyboard = TRUE,
    one_time_keyboard = TRUE
  )

  # отправляем клавиатуру
  bot$sendMessage(update$message$chat_id,
                  text = 'Выберите команду', 
                  reply_markup = RKM)

}

## Метод вызова Inine клавиатуры
habs <- function(bot, update) {

  IKM <- InlineKeyboardMarkup(
    inline_keyboard = list(
      list(
        InlineKeyboardButton(text = 'R', callback_data = 'R'),
        InlineKeyboardButton(text = 'Data Mining', callback_data = 'data_mining'),
        InlineKeyboardButton(text = 'Data Engineering', callback_data = 'data_engineering')
      ),
      list(
        InlineKeyboardButton(text = 'Big Data', callback_data = 'bigdata'),
        InlineKeyboardButton(text = 'Python', callback_data = 'python'),
        InlineKeyboardButton(text = 'Визуализация данных', callback_data = 'data_visualization')
      )
    )
  )

  # Send Inline Keyboard
  bot$sendMessage(chat_id = update$message$chat_id, 
                  text = "Выберите Хаб", 
                  reply_markup = IKM)
}

# метод для сообщения погоды
answer_cb <- function(bot, update) {

  # получаем из сообщения город
  hub <- update$callback_query$data

  # сообщение о том, что данные по кнопке получены
  bot$answerCallbackQuery(callback_query_id = update$callback_query$id, 
                          text = 'Подождите несколько минут, запрос обрабатывается') 

  # сообщение о том, что надо подождать пока бот получит данные
  mid <- bot$sendMessage(chat_id = update$from_chat_id(),
                         text    = "Подождите несколько минут пока, я соберу данные по выбранному Хабу")

  # парсим Хабр
  posts <- head(habr_hub_posts(hub, 1), 5)

  # удаляем сообщение о том, что надо подождать
  bot$deleteMessage(update$from_chat_id(), mid$message_id) 

  # формируем список кнопок
  keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))

  # формируем клавиатуру
  IKM <- InlineKeyboardMarkup(
    inline_keyboard =  keys 
    )

  # отправляем информацию о погоде
  bot$sendMessage(chat_id = update$from_chat_id(),
                  text    = paste0("5 наиболее свежих статей из Хаба ", hub),
                  reply_markup = IKM)

}

# создаём фильтры
## сообщения с текстом Погода
MessageFilters$hubs <- BaseFilter(function(message) {

  # проверяем текст сообщения
  message$text == "Список статей"

}
)

# создаём обработчики
h_start         <- CommandHandler('start', start)
h_hubs          <- MessageHandler(habs, filters = MessageFilters$hubs)
h_query_handler <- CallbackQueryHandler(answer_cb)

# добавляем обработчики в диспетчер
updater <- updater + 
  h_start +
  h_hubs  +
  h_query_handler

# запускаем бота
updater$start_polling()

Run the code example above, after replacing 'YOUR BOT TOKEN' with the real token you received when you created the bot via Bot Father (I talked about creating a bot in first article).

As a result, we will get the following result:

We entered the list of Hubs available for selection with a hardcode, in the method 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)
}

We get the list of articles from the specified Hub with the command habr_hub_posts(), from the package habR. At the same time, we indicate that we do not need a list of articles for all time, but only the first page on which 20 articles are located. From the resulting table using the command head() we leave only the top 5, which are the most recent articles.

  # парсим Хабр
  posts <- head(habr_hub_posts(hub, 1), 5)

The logic is very similar to the previous bot, but in this case we dynamically generate the Inline keyboard with a list of articles using the function lapply().

  # формируем список кнопок
  keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))

  # формируем клавиатуру
  IKM <- InlineKeyboardMarkup(
    inline_keyboard =  keys 
    )

We substitute the title of the article in the button text posts$title[x], and in the argument url link to article: url = posts$link[x].

Next, we create a filter, handlers and run our bot.

Conclusion

Now the bots you write will be much more convenient to use, due to the fact that they will be controlled from the keyboard, and not by entering commands. At least when interacting with the bot through a smartphone, the keyboard will significantly simplify the process of using it.

In the next article, we will figure out how to build a logical dialogue with a bot and work with databases.

Source: habr.com

Writing a telegram bot in R (part 3): How to add keyboard support to a bot

All articles from the series "Writing a telegram bot in R"

Content

What types of keyboards does the telegram bot support?

Reply keyboard

Inline keyboard

An example of a simple bot with support for InLine buttons

An example of a bot that reports the current weather for a selected city

An example of a bot that displays a list of the most recent articles with links according to the specified Habu from habr.com.

Conclusion

Add a comment Отменить ответ