ProHoster > Blog > Administración > Escribir un bot de telegrama en R (parte 3): como engadir soporte de teclado a un bot

Escribir un bot de telegrama en R (parte 3): como engadir soporte de teclado a un bot

Este é o terceiro artigo da serie "Escribir un bot de telegrama en R". En publicacións anteriores, aprendemos a crear un bot de telegram, enviar mensaxes a través del, engadir comandos e filtros de mensaxes ao bot. Polo tanto, antes de comezar a ler este artigo, recoméndoche encarecidamente que o leas anterior, porque Aquí xa non vou determe nos conceptos básicos da construción de bots descritos anteriormente.

Neste artigo, melloraremos a usabilidade do noso bot engadindo un teclado, o que fará que a interface do bot sexa intuitiva e fácil de usar.

Escribir un bot de telegrama en R (parte 3): como engadir soporte de teclado a un bot

Todos os artigos da serie "Escribindo un bot de telegrama en R"

  1. Creamos un bot e usámolo para enviar mensaxes en telegram
  2. Engade soporte de comandos e filtros de mensaxes ao bot
  3. Como engadir soporte de teclado a un bot

Contido

Se estás interesado na análise de datos, podes estar interesado no meu telegrama и youtube canles. A maior parte do contido está dedicado á linguaxe R.

  1. Que tipos de teclado admite o bot de telegram?
  2. Teclado de resposta
  3. Teclado en liña
    3.1. Un exemplo de bot sinxelo con soporte para botóns InLine
    3.2. Un exemplo de bot que informa do tempo actual para unha cidade seleccionada
    3.3. Un exemplo de bot que mostra unha lista dos artigos máis recentes con ligazóns ao Hub especificado de habr.com
  4. Conclusión

Que tipos de teclado admite o bot de telegram?

No momento de escribir este artigo telegram.bot permite crear dous tipos de teclados:

  • Responder: o teclado principal e normal, que se atopa debaixo do panel de entrada de texto da mensaxe. Tal teclado simplemente envía unha mensaxe de texto ao bot e, como texto, enviará o texto que está escrito no propio botón.
  • Inline - Teclado asociado a unha mensaxe de bot específica. Este teclado envía os datos do bot asociados ao botón pulsado; estes datos poden diferir do texto escrito no propio botón. E tales botóns son procesados CallbackQueryHandler.

Para que o bot abra o teclado, é necesario ao enviar unha mensaxe a través do método sendMessage(), pase o teclado creado anteriormente como argumento reply_markup.

A continuación veremos varios exemplos.

Teclado de resposta

Como escribín arriba, este é o teclado principal de control de bots.

Un exemplo de creación dun teclado de resposta desde a axuda oficial

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)

O anterior é un exemplo da axuda oficial do paquete telegram.bot. Para crear un teclado, use a función ReplyKeyboardMarkup(), que á súa vez leva unha lista de listas de botóns que crea a función KeyboardButton().

Por que dentro ReplyKeyboardMarkup() Necesitas pasar non só unha lista, senón unha lista de listas? O caso é que pasas a lista principal, e nela defines cada fila de botóns en listas separadas, porque Podes colocar varios botóns nunha fila.

argumento resize_keyboard permítelle seleccionar automaticamente o tamaño óptimo dos botóns do teclado e o argumento one_time_keyboard permítelle ocultar o teclado despois de premer cada botón.

Escribamos un bot sinxelo que terá 3 botóns:

  • ID do chat: solicita o ID do chat do diálogo co bot
  • O meu nome - Solicita o teu nome
  • O meu inicio de sesión - Solicita o teu nome de usuario en Telegram

Código 1: bot simple con teclado de resposta

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

Execute o exemplo de código anterior, despois de substituír "O TEU TOKEN DE BOT" polo token real que recibiu ao crear o bot mediante Pai Bot (Falei sobre a creación dun bot en primeiro artigo).

Despois de iniciar, dálle un comando ao bot /start, porque Isto é exactamente o que definimos para lanzar o teclado.

Escribir un bot de telegrama en R (parte 3): como engadir soporte de teclado a un bot

Se neste momento é difícil para analizar o exemplo de código dado, coa creación de métodos, filtros e controladores, entón deberías volver ao anterior Artigo, na que describín todo isto polo miúdo.

Creamos 4 métodos:

  • iniciar — Iniciar o teclado
  • chat_id — Solicitar ID de chat
  • my_name — Solicita o teu nome
  • my_username — Solicita o teu inicio de sesión

Obxectar Filtros de mensaxes engadiu 3 filtros de mensaxes segundo o seu texto:

  • chat_id — Mensaxes con texto "Чат ID"
  • nome — Mensaxes con texto "Моё имя"
  • nome de usuario — Mensaxes con texto "Мой логин"

E creamos 4 controladores que, baseados en comandos e filtros dados, executarán os métodos especificados.

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

O propio teclado créase dentro do método start() o equipo ReplyKeyboardMarkup().

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

No noso caso, colocamos todos os botóns uns debaixo dos outros, pero podemos organizalos nunha fila facendo cambios na lista de listas de botóns. Porque unha fila dentro do teclado créase a través dunha lista aniñada de botóns, entón para mostrar os nosos botóns nunha fila necesitamos reescribir parte do código para construír o teclado así:

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

Escribir un bot de telegrama en R (parte 3): como engadir soporte de teclado a un bot

O teclado envíase ao chat mediante o método sendMessage(), no argumento reply_markup.

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

Teclado en liña

Como escribín anteriormente, o teclado en liña está ligado a unha mensaxe específica. É algo máis difícil de traballar que o teclado principal.

Inicialmente, cómpre engadir un método ao bot para chamar ao teclado en liña.

Para responder a un clic de botón Inline, tamén pode usar o método bot answerCallbackQuery(), que pode mostrar unha notificación na interface de telegrama ao usuario que preme o botón Inline.

Os datos enviados desde o botón Inline non son texto, polo que para procesalos, cómpre crear un controlador especial mediante o comando CallbackQueryHandler().

O código para construír un teclado en liña que se dá na axuda oficial do paquete telegram.bot.

Código para construír un teclado en liña desde a axuda oficial

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

Debes construír un teclado en liña usando o comando InlineKeyboardMarkup(), co mesmo principio que o teclado Responder. EN InlineKeyboardMarkup() é necesario pasar unha lista de listas de botóns Inline, cada botón individual é creado pola función InlineKeyboardButton().

Un botón en liña pode pasar algúns datos ao bot mediante un argumento callback_data, ou abra calquera páxina HTML especificada usando o argumento url.

O resultado será unha lista na que cada elemento tamén é unha lista de botóns en liña que deben combinarse nunha soa fila.

A continuación veremos varios exemplos de bots con botóns Inline.

Un exemplo de bot sinxelo con soporte para botóns InLine

En primeiro lugar, escribiremos un bot para probas rápidas para covid-19. Por mando /test, enviarache un teclado con dous botóns, dependendo do botón que premes enviarache unha mensaxe cos resultados das túas probas.

Código 2: o bot máis sinxelo cun teclado en liña

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

Execute o exemplo de código anterior, despois de substituír "O TEU TOKEN DE BOT" polo token real que recibiu ao crear o bot mediante Pai Bot (Falei sobre a creación dun bot en primeiro artigo).

Resultado:
Escribir un bot de telegrama en R (parte 3): como engadir soporte de teclado a un bot

Creamos dous métodos:

  • proba — Para enviar ao chat Teclado en liña
  • resposta_cb — Para procesar datos enviados desde o teclado.

Os datos que se enviarán desde cada botón especifícanse no argumento callback_data, ao crear un botón. Podes recibir os datos enviados desde o botón usando a construción update$callback_query$data, dentro do método resposta_cb.

Para que o bot reaccione ao teclado en liña, método resposta_cb procesado por un controlador especial: CallbackQueryHandler(answer_cb). Que executa o método especificado cando se fai clic no botón Inline. Manexador CallbackQueryHandler toma dous argumentos:

  • callback - O método que se debe executar
  • pattern — Filtra polos datos que están ligados ao botón mediante un argumento callback_data.

En consecuencia, utilizando o argumento pattern Podemos escribir un método separado para premer cada botón:

Código 3: métodos separados para cada botón Inline

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

Execute o exemplo de código anterior, despois de substituír "O TEU TOKEN DE BOT" polo token real que recibiu ao crear o bot mediante Pai Bot (Falei sobre a creación dun bot en primeiro artigo).

Agora escribimos 2 métodos separados, i.e. un método, por cada pulsación de botón, e utilizou o argumento pattern, ao crear os seus controladores:

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

O código do método remata resposta_cb o equipo bot$answerCallbackQuery(callback_query_id = update$callback_query$id), que lle indica ao bot que se recibiron datos do teclado en liña.

Un exemplo de bot que informa do tempo actual para unha cidade seleccionada

Tentemos escribir un bot que solicite datos meteorolóxicos.

A lóxica do seu traballo será a seguinte. Inicialmente polo equipo /start chamas ao teclado principal, que só ten un botón "O tempo". Ao facer clic neste botón, recibirá unha mensaxe co teclado en liña para seleccionar a cidade para a que desexa coñecer o tempo actual. Selecciona unha das cidades e obtén o tempo actual.

Neste exemplo de código usaremos varios paquetes adicionais:

  • httr — un paquete para traballar con solicitudes HTTP, sobre a base do cal se constrúe o traballo con calquera API. No noso caso usaremos a API gratuíta openweathermap.org.
  • stringr — un paquete para traballar con texto, no noso caso utilizarémolo para xerar unha mensaxe sobre o tempo na cidade seleccionada.

Código 4: un bot que informa do tempo actual para a cidade seleccionada

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

Execute o exemplo de código anterior, despois de substituír "O TEU TOKEN DE BOT" polo token real que recibiu ao crear o bot mediante Pai Bot (Falei sobre a creación dun bot en primeiro artigo).

Como resultado, o noso bot funcionará algo así:
Escribir un bot de telegrama en R (parte 3): como engadir soporte de teclado a un bot

Esquemáticamente, este bot pódese representar así:
Escribir un bot de telegrama en R (parte 3): como engadir soporte de teclado a un bot

Creamos 3 métodos dispoñibles dentro do noso bot meteorolóxico:

  • Comezar — Inicia o teclado principal do bot
  • tempo — Inicia o teclado en liña para seleccionar unha cidade
  • resposta_cb — O método principal que solicita o tempo da API para unha determinada cidade e o envía ao chat.

Método Comezar lanzámolo co comando /start, que é implementado polo manejador CommandHandler('start', start).

Para executar un método tempo creamos un filtro co mesmo nome:

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

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

}
)

E chamamos a este método co seguinte manejador de mensaxes: MessageHandler(weather, filters = MessageFilters$weather).

E ao final, o noso principal método resposta_cb reacciona ao premer os botóns Inline, que é implementado por un controlador especial: CallbackQueryHandler(answer_cb).

Dentro dun método resposta_cb, lemos os datos enviados desde o teclado e escribimos nunha variable city: city <- update$callback_query$data. Despois solicitamos datos meteorolóxicos da API, xeramos e enviamos unha mensaxe e, finalmente, utilizamos o método answerCallbackQuery para informar ao bot de que procesamos o clic do botón Inline.

Un exemplo de bot que mostra unha lista dos artigos máis recentes con ligazóns ao Hub especificado desde www.habr.com.

Presento este bot para mostrarche como mostrar os botóns en liña que conducen a páxinas web.

A lóxica deste bot é semellante á anterior; inicialmente iniciamos o teclado principal co comando /start. A continuación, o bot ofrécenos unha lista de 6 hubs para escoller, seleccionamos o hub que nos interesa e recibimos as 5 publicacións máis recentes do Hub seleccionado.

Como entendes, neste caso necesitamos obter unha lista de artigos, e para iso usaremos un paquete especial habR, que permite solicitar artigos de Habra e algunhas estatísticas sobre eles en R.

Instalar paquete habR só é posible desde github, para o que necesitarás un paquete adicional devtools. Para instalar, use o código a continuación.

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

Agora vexamos o código para construír o bot descrito anteriormente:

Código 5: un bot que mostra unha lista dos artigos máis recentes no Hub seleccionado

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

Execute o exemplo de código anterior, despois de substituír "O TEU TOKEN DE BOT" polo token real que recibiu ao crear o bot mediante Pai Bot (Falei sobre a creación dun bot en primeiro artigo).

Como resultado, obteremos este resultado:
Escribir un bot de telegrama en R (parte 3): como engadir soporte de teclado a un bot

Codificamos a lista de concentradores dispoñibles para a selección no método 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)
}

Recibimos unha lista de artigos do Hub especificado co comando habr_hub_posts(), do paquete habR. Ao mesmo tempo, sinalamos que non necesitamos unha lista de artigos para todo o tempo, senón só a primeira páxina na que se atopan 20 artigos. A partir da táboa resultante usando o comando head() Deixamos só os 5 primeiros, que son os artigos máis recentes.

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

A lóxica é moi semellante ao bot anterior, pero neste caso xeramos un teclado Inline cunha lista de artigos de forma dinámica usando a función lapply().

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

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

Inserimos o título do artigo no texto do botón posts$title[x], e no argumento url ligazón ao artigo: url = posts$link[x].

A continuación, creamos un filtro, controladores e iniciamos o noso bot.

Conclusión

Agora os bots que escribas serán moito máis cómodos de usar, debido ao feito de que se controlarán desde o teclado, en lugar de introducir comandos. Como mínimo, ao interactuar cun bot a través dun teléfono intelixente, o teclado simplificará significativamente o proceso de usalo.

No seguinte artigo descubriremos como construír un diálogo lóxico cun bot e traballar con bases de datos.

Fonte: www.habr.com

Engadir un comentario