ProHoster > Blog > Pangangasiwa > Pagsusulat ng telegram bot sa R ​​(bahagi 3): Paano magdagdag ng suporta sa keyboard sa isang bot

Pagsusulat ng telegram bot sa R ​​(bahagi 3): Paano magdagdag ng suporta sa keyboard sa isang bot

Ito ang pangatlong artikulo sa seryeng "Pagsusulat ng telegram bot sa R". Sa mga nakaraang publikasyon, natutunan namin kung paano lumikha ng isang telegram bot, magpadala ng mga mensahe sa pamamagitan nito, magdagdag ng mga utos at mga filter ng mensahe sa bot. Samakatuwid, bago mo simulan ang pagbabasa ng artikulong ito, lubos kong inirerekumenda na basahin mo dati, dahil Dito hindi na ako magtatagal sa naunang inilarawan na mga pangunahing kaalaman sa pagbuo ng bot.

Sa artikulong ito, pagbutihin namin ang kakayahang magamit ng aming bot sa pamamagitan ng pagdaragdag ng keyboard, na gagawing intuitive at madaling gamitin ang interface ng bot.

Pagsusulat ng telegram bot sa R ​​(bahagi 3): Paano magdagdag ng suporta sa keyboard sa isang bot

Lahat ng mga artikulo mula sa seryeng "Pagsusulat ng telegram bot sa R"

  1. Lumilikha kami ng bot at ginagamit ito upang magpadala ng mga mensahe sa telegrama
  2. Magdagdag ng suporta sa command at mga filter ng mensahe sa bot
  3. Paano magdagdag ng suporta sa keyboard sa isang bot

nilalaman

Kung interesado ka sa pagsusuri ng data, maaaring interesado ka sa aking telegram и youtube mga channel. Karamihan sa nilalaman ay nakatuon sa wikang R.

  1. Anong mga uri ng keyboard ang sinusuportahan ng telegram bot?
  2. Tumugon sa keyboard
  3. Inline na keyboard
    3.1. Isang halimbawa ng isang simpleng bot na may suporta para sa mga pindutan ng InLine
    3.2. Isang halimbawa ng bot na nag-uulat ng kasalukuyang panahon para sa isang napiling lungsod
    3.3. Isang halimbawa ng bot na nagpapakita ng listahan ng mga pinakabagong artikulo na may mga link sa tinukoy na Hub mula sa habr.com
  4. Konklusyon

Anong mga uri ng keyboard ang sinusuportahan ng telegram bot?

Sa oras ng pagsulat na ito telegram.bot nagbibigay-daan sa iyo na lumikha ng dalawang uri ng mga keyboard:

  • Tumugon - Ang pangunahing, regular na keyboard, na matatagpuan sa ilalim ng panel ng input ng text ng mensahe. Ang ganitong keyboard ay nagpapadala lamang ng isang text message sa bot, at bilang ang teksto ay ipapadala nito ang teksto na nakasulat sa mismong button.
  • Inline - Keyboard na nauugnay sa isang partikular na mensahe ng bot. Ipinapadala ng keyboard na ito ang data ng bot na nauugnay sa pagpindot sa pindutan; maaaring iba ang data na ito sa tekstong nakasulat sa mismong button. At ang mga naturang pindutan ay pinoproseso sa pamamagitan ng CallbackQueryHandler.

Upang mabuksan ng bot ang keyboard, kinakailangan kapag nagpapadala ng mensahe sa pamamagitan ng pamamaraan sendMessage(), ipasa ang dating ginawang keyboard bilang argumento reply_markup.

Sa ibaba ay titingnan natin ang ilang mga halimbawa.

Tumugon sa keyboard

Tulad ng isinulat ko sa itaas, ito ang pangunahing bot control keyboard.

Isang halimbawa ng paglikha ng isang Reply keyboard mula sa opisyal na tulong

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)

Ang nasa itaas ay isang halimbawa mula sa opisyal na tulong ng package telegram.bot. Para gumawa ng keyboard, gamitin ang function ReplyKeyboardMarkup(), na kumukuha naman ng listahan ng mga listahan ng mga button na nilikha ng function KeyboardButton().

Bakit sa ReplyKeyboardMarkup() Kailangan mo bang pumasa hindi lamang isang listahan, ngunit isang listahan ng mga listahan? Ang katotohanan ay ipinasa mo ang pangunahing listahan, at dito ay tinukoy mo ang bawat hilera ng mga pindutan sa magkahiwalay na mga listahan, dahil Maaari kang maglagay ng ilang mga pindutan sa isang hilera.

argumento resize_keyboard nagbibigay-daan sa iyo na awtomatikong piliin ang pinakamainam na laki ng mga pindutan ng keyboard, at ang argumento one_time_keyboard nagbibigay-daan sa iyo na itago ang keyboard pagkatapos ng bawat pagpindot sa pindutan.

Sumulat tayo ng isang simpleng bot na magkakaroon ng 3 mga pindutan:

  • Chat ID - Humiling ng chat ID ng dialogue sa bot
  • Pangalan ko - Hilingin ang iyong pangalan
  • Aking login - Hilingin ang iyong username sa telegram

Code 1: Simpleng bot na may 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()

Patakbuhin ang halimbawa ng code sa itaas, pagkatapos palitan ang 'YOUR BOT TOKEN' ng totoong token na natanggap mo noong nilikha ang bot sa pamamagitan ng BotAma (Napag-usapan ko ang paggawa ng bot sa unang artikulo).

Pagkatapos ilunsad, bigyan ang bot ng utos /start, dahil Ito mismo ang tinukoy namin upang ilunsad ang keyboard.

Pagsusulat ng telegram bot sa R ​​(bahagi 3): Paano magdagdag ng suporta sa keyboard sa isang bot

Kung sa sandaling ito ay mahirap para sa iyo na i-parse ang ibinigay na halimbawa ng code, sa paglikha ng mga pamamaraan, mga filter at mga humahawak, pagkatapos ay dapat kang bumalik sa nauna. Artikulo, kung saan inilarawan ko ang lahat ng ito nang detalyado.

Gumawa kami ng 4 na pamamaraan:

  • simulan — Ilunsad ang keyboard
  • chat_id — Humiling ng chat ID
  • my_name — Hilingin ang iyong pangalan
  • my_username — Hilingin ang iyong pag-login

Upang tumutol MessageFilters nagdagdag ng 3 filter ng mensahe batay sa kanilang teksto:

  • chat_id — Mga mensaheng may text "Чат ID"
  • pangalan — Mga mensaheng may teksto "Моё имя"
  • username — Mga mensaheng may text "Мой логин"

At lumikha kami ng 4 na tagapangasiwa na, batay sa ibinigay na mga utos at mga filter, ay isasagawa ang mga tinukoy na pamamaraan.

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

Ang keyboard mismo ay nilikha sa loob ng pamamaraan start() koponan ReplyKeyboardMarkup().

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

Sa aming kaso, inilagay namin ang lahat ng mga pindutan sa ilalim ng bawat isa, ngunit maaari naming ayusin ang mga ito sa isang hilera sa pamamagitan ng paggawa ng mga pagbabago sa listahan ng mga listahan ng mga pindutan. kasi Ang isang hilera sa loob ng keyboard ay nilikha sa pamamagitan ng isang nested na listahan ng mga pindutan, pagkatapos ay upang maipakita ang aming mga pindutan sa isang hilera kailangan naming muling isulat ang bahagi ng code para sa pagbuo ng keyboard tulad nito:

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

Pagsusulat ng telegram bot sa R ​​(bahagi 3): Paano magdagdag ng suporta sa keyboard sa isang bot

Ang keyboard ay ipinadala sa chat gamit ang pamamaraan sendMessage(), sa argumento reply_markup.

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

Inline na keyboard

Tulad ng isinulat ko sa itaas, ang Inline na keyboard ay nakatali sa isang partikular na mensahe. Ito ay medyo mas mahirap gamitin kaysa sa pangunahing keyboard.

Sa una, kailangan mong magdagdag ng paraan sa bot para tawagan ang Inline na keyboard.

Upang tumugon sa isang pag-click sa Inline na button, maaari mo ring gamitin ang paraan ng bot answerCallbackQuery(), na maaaring magpakita ng notification sa interface ng telegrama sa user na pinindot ang Inline na button.

Ang data na ipinadala mula sa Inline na pindutan ay hindi teksto, kaya upang maproseso ito kailangan mong lumikha ng isang espesyal na handler gamit ang command CallbackQueryHandler().

Ang code para sa pagbuo ng isang Inline na keyboard na ibinibigay sa opisyal na tulong ng package telegram.bot.

Code para sa pagbuo ng isang Inline na keyboard mula sa opisyal na tulong

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

Kailangan mong bumuo ng isang Inline na keyboard gamit ang command InlineKeyboardMarkup(), sa parehong prinsipyo gaya ng keyboard ng Reply. SA InlineKeyboardMarkup() kinakailangang magpasa ng listahan ng mga Inline na button, ang bawat indibidwal na button ay nilikha ng function InlineKeyboardButton().

Ang isang inline na button ay maaaring magpasa ng ilang data sa bot gamit ang isang argumento callback_data, o buksan ang anumang HTML na pahina na tinukoy gamit ang argumento url.

Ang resulta ay isang listahan kung saan ang bawat elemento ay isa ring listahan ng mga Inline na button na kailangang pagsamahin sa isang row.

Susunod ay titingnan natin ang ilang halimbawa ng mga bot na may mga Inline na pindutan.

Isang halimbawa ng isang simpleng bot na may suporta para sa mga pindutan ng InLine

Una, susulat tayo ng bot para sa express testing para sa covid-19. Sa pamamagitan ng utos /test, padadalhan ka nito ng keyboard na may dalawang button, depende sa pinindot na button magpapadala ito sa iyo ng mensahe kasama ang mga resulta ng iyong pagsubok.

Code 2: Ang pinakasimpleng bot na may Inline na 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()

Patakbuhin ang halimbawa ng code sa itaas, pagkatapos palitan ang 'YOUR BOT TOKEN' ng totoong token na natanggap mo noong nilikha ang bot sa pamamagitan ng BotAma (Napag-usapan ko ang paggawa ng bot sa unang artikulo).

Resulta:
Pagsusulat ng telegram bot sa R ​​(bahagi 3): Paano magdagdag ng suporta sa keyboard sa isang bot

Gumawa kami ng dalawang pamamaraan:

  • pagsusulit — Upang ipadala sa chat Inline na keyboard
  • answer_cb — Upang iproseso ang data na ipinadala mula sa keyboard.

Ang data na ipapadala mula sa bawat pindutan ay tinukoy sa argumento callback_data, kapag gumagawa ng isang button. Maaari mong matanggap ang data na ipinadala mula sa pindutan gamit ang construct update$callback_query$data, sa loob ng pamamaraan answer_cb.

Para makapag-react ang bot sa Inline na keyboard, paraan answer_cb naproseso ng isang espesyal na tagapangasiwa: CallbackQueryHandler(answer_cb). Na nagpapatakbo ng tinukoy na paraan kapag na-click ang Inline na button. Handler CallbackQueryHandler tumatagal ng dalawang argumento:

  • callback — Ang pamamaraan na kailangang patakbuhin
  • pattern — I-filter ayon sa data na nakatali sa button gamit ang isang argumento callback_data.

Alinsunod dito, gamit ang argumento pattern Maaari kaming magsulat ng isang hiwalay na paraan para sa pagpindot sa bawat pindutan:

Code 3: Paghiwalayin ang mga pamamaraan para sa bawat Inline na 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()

Patakbuhin ang halimbawa ng code sa itaas, pagkatapos palitan ang 'YOUR BOT TOKEN' ng totoong token na natanggap mo noong nilikha ang bot sa pamamagitan ng BotAma (Napag-usapan ko ang paggawa ng bot sa unang artikulo).

Ngayon ay nagsulat kami ng 2 magkahiwalay na pamamaraan i.e. isang paraan, para sa bawat pagpindot sa pindutan, at ginamit ang argumento pattern, kapag lumilikha ng kanilang mga humahawak:

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

Nagtatapos ang code ng pamamaraan answer_cb koponan bot$answerCallbackQuery(callback_query_id = update$callback_query$id), na nagsasabi sa bot na ang data mula sa inline na keyboard ay natanggap na.

Isang halimbawa ng bot na nag-uulat ng kasalukuyang panahon para sa isang napiling lungsod

Subukan nating magsulat ng bot na humihiling ng data ng lagay ng panahon.

Ang lohika ng gawain nito ay ang mga sumusunod. Sa una sa pamamagitan ng koponan /start tatawagin mo ang pangunahing keyboard, na mayroon lamang isang "Weather" na button. Sa pamamagitan ng pag-click sa button na ito makakatanggap ka ng mensahe na may Inline na keyboard upang piliin ang lungsod kung saan mo gustong malaman ang kasalukuyang panahon. Pumili ng isa sa mga lungsod at kunin ang kasalukuyang panahon.

Sa halimbawa ng code na ito, gagamit kami ng ilang karagdagang mga pakete:

  • httr — isang pakete para sa pagtatrabaho sa mga kahilingan sa HTTP, batay sa kung saan gumagana sa anumang API ay binuo. Sa aming kaso gagamitin namin ang libreng API openweathermap.org.
  • stringr — isang pakete para sa pagtatrabaho sa text, sa aming kaso ay gagamitin namin ito upang makabuo ng mensahe tungkol sa lagay ng panahon sa napiling lungsod.

Code 4: Isang bot na nag-uulat ng kasalukuyang panahon para sa napiling lungsod

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

Patakbuhin ang halimbawa ng code sa itaas, pagkatapos palitan ang 'YOUR BOT TOKEN' ng totoong token na natanggap mo noong nilikha ang bot sa pamamagitan ng BotAma (Napag-usapan ko ang paggawa ng bot sa unang artikulo).

Bilang resulta, gagana ang aming bot ng ganito:
Pagsusulat ng telegram bot sa R ​​(bahagi 3): Paano magdagdag ng suporta sa keyboard sa isang bot

Sa eskematiko, ang bot na ito ay maaaring ilarawan nang ganito:
Pagsusulat ng telegram bot sa R ​​(bahagi 3): Paano magdagdag ng suporta sa keyboard sa isang bot

Gumawa kami ng 3 paraan na magagamit sa loob ng aming weather bot:

  • simula — Ilunsad ang pangunahing bot keyboard
  • panahon — Ilunsad ang Inline na keyboard upang pumili ng lungsod
  • answer_cb — Ang pangunahing paraan na humihiling ng lagay ng panahon mula sa API para sa isang partikular na lungsod at ipinapadala ito sa chat.

pamamaraan simula inilunsad namin ito gamit ang utos /start, na ipinatupad ng handler CommandHandler('start', start).

Upang magpatakbo ng isang pamamaraan panahon gumawa kami ng filter na may parehong pangalan:

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

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

}
)

At tinatawag namin ang pamamaraang ito sa sumusunod na tagapangasiwa ng mensahe: MessageHandler(weather, filters = MessageFilters$weather).

At sa huli, ang aming pangunahing pamamaraan answer_cb tumutugon sa pagpindot sa mga Inline na pindutan, na ipinatupad ng isang espesyal na handler: CallbackQueryHandler(answer_cb).

Sa loob ng isang pamamaraan answer_cb, binabasa namin ang data na ipinadala mula sa keyboard at isulat ito sa isang variable city: city <- update$callback_query$data. Pagkatapos ay humihiling kami ng data ng lagay ng panahon mula sa API, bumuo at magpadala ng mensahe, at sa wakas ay gamitin ang paraan answerCallbackQuery upang ipaalam sa bot na naproseso namin ang pag-click ng Inline na button.

Isang halimbawa ng bot na nagpapakita ng listahan ng mga pinakabagong artikulo na may mga link sa tinukoy na Hub mula sa www.habr.com.

Ipinakita ko ang bot na ito upang ipakita sa iyo kung paano ipakita ang mga Inline na button na humahantong sa mga web page.

Ang lohika ng bot na ito ay katulad ng nauna; sa simula ay inilunsad namin ang pangunahing keyboard na may utos /start. Susunod, binibigyan kami ng bot ng listahan ng 6 na hub na mapagpipilian, pipiliin namin ang hub kung saan kami interesado, at natatanggap ang 5 pinakabagong publikasyon mula sa napiling Hub.

Tulad ng naiintindihan mo, sa kasong ito kailangan naming makakuha ng isang listahan ng mga artikulo, at para dito gagamit kami ng isang espesyal na pakete habR, na nagbibigay-daan sa iyong humiling ng mga artikulo mula kay Habra at ilang istatistika sa mga ito sa R.

I-install ang package habR posible lamang mula sa github, kung saan kakailanganin mo ng karagdagang pakete devtools. Upang i-install, gamitin ang code sa ibaba.

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

Ngayon tingnan natin ang code para sa pagbuo ng bot na inilarawan sa itaas:

Code 5: Isang bot na nagpapakita ng listahan ng mga pinakabagong artikulo sa napiling 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()

Patakbuhin ang halimbawa ng code sa itaas, pagkatapos palitan ang 'YOUR BOT TOKEN' ng totoong token na natanggap mo noong nilikha ang bot sa pamamagitan ng BotAma (Napag-usapan ko ang paggawa ng bot sa unang artikulo).

Bilang resulta, makukuha natin ang resultang ito:
Pagsusulat ng telegram bot sa R ​​(bahagi 3): Paano magdagdag ng suporta sa keyboard sa isang bot

Na-hardcode namin ang listahan ng mga Hub na magagamit para sa pagpili sa pamamaraan 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)
}

Kumuha kami ng listahan ng mga artikulo mula sa tinukoy na Hub na may utos habr_hub_posts(), mula sa pakete habR. Kasabay nito, itinuturo namin na hindi namin kailangan ng isang listahan ng mga artikulo sa buong panahon, ngunit ang unang pahina lamang kung saan matatagpuan ang 20 mga artikulo. Mula sa resultang talahanayan gamit ang command head() Iniiwan lang namin ang nangungunang 5, na siyang mga pinakabagong artikulo.

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

Ang logic ay halos kapareho sa nakaraang bot, ngunit sa kasong ito ay bumubuo kami ng isang Inline na keyboard na may listahan ng mga artikulo na dynamic na gumagamit ng function. lapply().

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

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

Ipinasok namin ang pamagat ng artikulo sa teksto ng pindutan posts$title[x], at sa argumento url link sa artikulo: url = posts$link[x].

Susunod, gumawa kami ng filter, mga humahawak at inilunsad ang aming bot.

Konklusyon

Ngayon ang mga bot na iyong isusulat ay magiging mas maginhawang gamitin, dahil sa katotohanan na sila ay makokontrol mula sa keyboard, sa halip na sa pamamagitan ng pagpasok ng mga utos. Sa pinakamababa, kapag nakikipag-ugnayan sa isang bot sa pamamagitan ng isang smartphone, ang keyboard ay makabuluhang pasimplehin ang proseso ng paggamit nito.

Sa susunod na artikulo ay malalaman natin kung paano bumuo ng isang lohikal na diyalogo sa isang bot at magtrabaho kasama ang mga database.

Pinagmulan: www.habr.com

Magdagdag ng komento