ProHoster > Blogi > Haldamine > Telegrammiroti kirjutamine R-is (3. osa): kuidas lisada robotile klaviatuuri tuge

Telegrammiroti kirjutamine R-is (3. osa): kuidas lisada robotile klaviatuuri tuge

See on kolmas artikkel sarjast “Telegrammiroti kirjutamine R-is”. Varasemates väljaannetes õppisime telegrammibotit looma, selle kaudu sõnumeid saatma, lisasime robotile käske ja sõnumifiltreid. Seetõttu soovitan teil enne seda artiklit lugema hakata eelmine, sest Siinkohal ei peatu ma enam eelnevalt kirjeldatud robotite ehitamise põhitõdedel.

Selles artiklis parandame oma roboti kasutatavust, lisades klaviatuuri, mis muudab roboti liidese intuitiivseks ja hõlpsasti kasutatavaks.

Telegrammiroti kirjutamine R-is (3. osa): kuidas lisada robotile klaviatuuri tuge

Kõik artiklid sarjast “Telegrammiroti kirjutamine R-is”

  1. Loome roboti ja kasutame seda sõnumite saatmiseks telegrammis
  2. Lisage robotile käsutugi ja sõnumifiltrid
  3. Kuidas lisada robotile klaviatuuri tuge

Sisu

Kui olete huvitatud andmete analüüsist, võite olla huvitatud minu telegramm и youtube kanalid. Suurem osa sisust on pühendatud R-keelele.

  1. Mis tüüpi klaviatuure telegrammi robot toetab?
  2. Vasta klaviatuur
  3. Tekstisisene klaviatuur
    3.1. Näide lihtsast robotist, mis toetab InLine'i nuppe
    3.2. Näide robotist, mis teatab valitud linna hetkeilma
    3.3. Näide robotist, mis kuvab viimaste artiklite loendi koos linkidega veebisaidilt habr.com määratud jaoturile
  4. Järeldus

Mis tüüpi klaviatuure telegrammi robot toetab?

Selle kirjutamise ajal telegram.bot võimaldab teil luua kahte tüüpi klaviatuure:

  • Vastus – põhiline tavaline klaviatuur, mis asub sõnumi tekstisisestuspaneeli all. Selline klaviatuur saadab robotile lihtsalt tekstisõnumi ja tekstina saadab see teksti, mis on nupule ise kirjutatud.
  • Tekstisisene – konkreetse robotisõnumiga seotud klaviatuur. See klaviatuur saadab vajutatud nupuga seotud roboti andmed; need andmed võivad erineda nupule kirjutatud tekstist. Ja selliseid nuppe töödeldakse läbi CallbackQueryHandler.

Selleks, et robot klaviatuuri avaks, on see vajalik meetodi kaudu sõnumi saatmisel sendMessage(), edastage argumendina varem loodud klaviatuur reply_markup.

Allpool vaatleme mitmeid näiteid.

Vasta klaviatuur

Nagu ma eespool kirjutasin, on see peamine roboti juhtimisklaviatuur.

Näide vastusklaviatuuri loomisest ametlikust spikrist

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)

Ülaltoodud näide on paketi ametlikust abist telegram.bot. Klaviatuuri loomiseks kasutage funktsiooni ReplyKeyboardMarkup(), mis omakorda võtab loendi funktsiooniga loodud nuppude loenditest KeyboardButton().

Miks sisse? ReplyKeyboardMarkup() Kas peate edastama mitte ainult nimekirja, vaid loendite loendi? Fakt on see, et läbite põhiloendi ja määrate selles iga nupurea eraldi loendites, kuna Saate paigutada mitu nuppu ühte ritta.

argument resize_keyboard võimaldab automaatselt valida klaviatuuri nuppude optimaalse suuruse ja argumendi one_time_keyboard võimaldab pärast iga nupuvajutust klaviatuuri peita.

Kirjutame lihtsa roboti, millel on 3 nuppu:

  • Vestluse ID – taotlege robotiga dialoogi vestluse ID-d
  • Minu nimi – küsi oma nime
  • Minu sisselogimine – küsi oma kasutajanime telegrammis

Kood 1: lihtne robot koos vastamisklaviatuuriga

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

Käivitage ülaltoodud koodinäide pärast seda, kui olete asendanud "TEIE BOTI MÄRGI" tõelise märgiga, mille saite roboti loomisel BotFather (Ma rääkisin roboti loomisest esimene artikkel).

Pärast käivitamist andke robotile käsk /start, sest See on täpselt see, mida me klaviatuuri käivitamiseks määratlesime.

Telegrammiroti kirjutamine R-is (3. osa): kuidas lisada robotile klaviatuuri tuge

Kui antud koodinäidet koos meetodite, filtrite ja töötlejate loomisega on hetkel keeruline sõeluda, siis tuleks naasta eelmise juurde siit, milles kirjeldasin seda kõike üksikasjalikult.

Oleme loonud 4 meetodit:

  • start — klaviatuuri käivitamine
  • chat_id – taotlege vestluse ID-d
  • minu_nimi – küsige oma nime
  • minu_kasutajanimi — taotlege oma sisselogimist

Vastulause esitamiseks Sõnumifiltrid lisas 3 sõnumifiltrit nende teksti põhjal:

  • chat_id – tekstiga sõnumid "Чат ID"
  • nimi — tekstiga sõnumid "Моё имя"
  • kasutajanimi — tekstiga sõnumid "Мой логин"

Ja me lõime 4 töötlejat, mis antud käskude ja filtrite põhjal täidavad määratud meetodeid.

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

Klaviatuur ise luuakse meetodi sees start() meeskond ReplyKeyboardMarkup().

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

Meie puhul asetasime kõik nupud üksteise alla, kuid nupuloendite loendis muudatusi tehes saame need järjestada ühte ritta. Sest üks rida klaviatuuri sees luuakse pesastatud nuppude loendi kaudu, siis selleks, et meie nuppe ühes reas kuvada, peame osa koodist klaviatuuri koostamiseks ümber kirjutama järgmiselt:

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

Telegrammiroti kirjutamine R-is (3. osa): kuidas lisada robotile klaviatuuri tuge

Klaviatuur saadetakse vestlusesse meetodit kasutades sendMessage(), argumendis reply_markup.

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

Tekstisisene klaviatuur

Nagu ma eespool kirjutasin, on tekstisisene klaviatuur seotud konkreetse sõnumiga. Sellega töötamine on mõnevõrra keerulisem kui põhiklaviatuuriga.

Esialgu peate robotile lisama meetodi sisemise klaviatuuri helistamiseks.

Tekstisisesele nupuklõpsule vastamiseks võite kasutada ka robotmeetodit answerCallbackQuery(), mis suudab telegrammi liideses kuvada teatise kasutajale, kes vajutab Inline nuppu.

Inline nupult saadetavad andmed ei ole tekst, nii et nende töötlemiseks tuleb käsu abil luua spetsiaalne töötleja CallbackQueryHandler().

Inline klaviatuuri ehitamise kood, mis on antud paketi ametlikus spikris telegram.bot.

Kood tekstisisese klaviatuuri koostamiseks ametlikust abist

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

Peate käsu abil koostama tekstisisese klaviatuuri InlineKeyboardMarkup(), samal põhimõttel nagu vastamise klaviatuur. IN InlineKeyboardMarkup() on vaja edastada Inline nuppude loendite loend, iga üksiku nupu loob funktsioon InlineKeyboardButton().

Tekstisisene nupp võib argumendi abil teatud andmeid robotile edastada callback_datavõi avage mis tahes argumendiga määratud HTML-leht url.

Tulemuseks on loend, kus iga element on ka loendis olevatest nuppudest, mis tuleb ühendada üheks reale.

Järgmisena vaatleme mitmeid Inline nuppudega robotite näiteid.

Näide lihtsast robotist, mis toetab InLine'i nuppe

Esiteks kirjutame boti covid-19 kiirtestimiseks. Käsu järgi /test, saadab see teile kahe nupuga klaviatuuri, olenevalt vajutatud nupust saadab see teile sõnumi testimise tulemustega.

Kood 2: Lihtsaim robot, millel on sisemine klaviatuur

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

Käivitage ülaltoodud koodinäide pärast seda, kui olete asendanud "TEIE BOTI MÄRGI" tõelise märgiga, mille saite roboti loomisel BotFather (Ma rääkisin roboti loomisest esimene artikkel).

Tulemus:
Telegrammiroti kirjutamine R-is (3. osa): kuidas lisada robotile klaviatuuri tuge

Oleme loonud kaks meetodit:

  • test — vestlusesse saatmiseks tekstisisene klaviatuur
  • vastus_cb — Klaviatuurilt saadetud andmete töötlemiseks.

Igast nupust saadetavad andmed on täpsustatud argumendis callback_data, nupu loomisel. Nupult saadetud andmed saad vastu võtta konstruktsiooni abil update$callback_query$data, meetodi sees vastus_cb.

Et robot reageeriks tekstisisesele klaviatuurile, meetod vastus_cb spetsiaalse käitleja poolt töödeldud: CallbackQueryHandler(answer_cb). Mis käivitab määratud meetodi, kui klõpsate Inline nuppu. Käitleja CallbackQueryHandler võtab kaks argumenti:

  • callback — Meetod, mida tuleb käivitada
  • pattern — Filtreerige argumendi abil nupuga seotud andmete järgi callback_data.

Sellest lähtuvalt, kasutades argumenti pattern Iga nupu vajutamiseks saame kirjutada eraldi meetodi:

Kood 3: iga tekstisisese nupu jaoks eraldi meetodid

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

Käivitage ülaltoodud koodinäide pärast seda, kui olete asendanud "TEIE BOTI MÄRGI" tõelise märgiga, mille saite roboti loomisel BotFather (Ma rääkisin roboti loomisest esimene artikkel).

Nüüd oleme kirjutanud 2 eraldi meetodit st. üks meetod iga nupuvajutuse jaoks ja kasutas argumenti pattern, nende töötlejate loomisel:

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

Meetodi kood lõpeb vastus_cb meeskond bot$answerCallbackQuery(callback_query_id = update$callback_query$id), mis teatab robotile, et andmed tekstisiseselt klaviatuurilt on vastu võetud.

Näide robotist, mis teatab valitud linna hetkeilma

Proovime kirjutada roboti, mis küsib ilmaandmeid.

Selle töö loogika on järgmine. Esialgu meeskonna poolt /start helistate põhiklaviatuurile, millel on ainult üks nupp "Ilm". Sellel nupul klõpsates saate tekstisisese klaviatuuriga teate, et valida linn, mille kohta soovite hetkeilma teada saada. Valige üks linnadest ja vaadake praegust ilma.

Selles koodinäites kasutame mitmeid lisapakette:

  • httr — HTTP päringutega töötamise pakett, mille alusel ehitatakse üles töö mis tahes API-ga. Meie puhul kasutame tasuta API-d openweathermap.org.
  • stringr — pakett tekstiga töötamiseks, meie puhul kasutame seda valitud linna ilmateate genereerimiseks.

Kood 4: bot, mis teatab valitud linna hetkeilma

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

Käivitage ülaltoodud koodinäide pärast seda, kui olete asendanud "TEIE BOTI MÄRGI" tõelise märgiga, mille saite roboti loomisel BotFather (Ma rääkisin roboti loomisest esimene artikkel).

Selle tulemusel töötab meie robot midagi sellist:
Telegrammiroti kirjutamine R-is (3. osa): kuidas lisada robotile klaviatuuri tuge

Skemaatiliselt saab seda robotit kujutada järgmiselt:
Telegrammiroti kirjutamine R-is (3. osa): kuidas lisada robotile klaviatuuri tuge

Oleme oma ilmarobotis loonud 3 meetodit:

  • algus — Käivitage roboti põhiklaviatuur
  • ilm — Linna valimiseks käivitage tekstisisene klaviatuur
  • vastus_cb — Peamine meetod, mis küsib API-lt ilmateateid antud linna kohta ja saadab selle vestlusesse.

Meetod algus käivitame selle käsuga /start, mille rakendab käitleja CommandHandler('start', start).

Meetodi käivitamiseks ilm lõime samanimelise filtri:

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

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

}
)

Ja me kutsume seda meetodit järgmise sõnumitöötlejaga: MessageHandler(weather, filters = MessageFilters$weather).

Ja lõpuks meie peamine meetod vastus_cb reageerib sisemiste nuppude vajutamisele, mida rakendab spetsiaalne käitleja: CallbackQueryHandler(answer_cb).

Meetodi sees vastus_cb, loeme klaviatuurilt saadetud andmeid ja kirjutame need muutujasse city: city <- update$callback_query$data. Seejärel küsime API-lt ilmaandmeid, genereerime ja saadame sõnumi ning lõpuks kasutame meetodit answerCallbackQuery et teavitada robotit, et töötlesime tekstisisese nupu klõpsamist.

Näide robotist, mis kuvab viimaste artiklite loendi koos linkidega määratud jaoturile www.habr.com.

Esitan seda robotit, et näidata, kuidas kuvada veebilehtedele viivaid tekstisiseseid nuppe.

Selle roboti loogika on sarnane eelmisele, algselt käivitame põhiklaviatuuri käsuga /start. Järgmisena annab bot meile 6 jaoturi loendi, mille hulgast valida, me valime meid huvitava jaoturi ja saame valitud jaoturist 5 viimast väljaannet.

Nagu teate, peame sel juhul hankima artiklite loendi ja selleks kasutame spetsiaalset paketti habR, mis võimaldab teil taotleda Habra artikleid ja nende kohta statistikat R-is.

Paigalda pakett habR võimalik ainult githubist, mille jaoks on vaja lisapaketti devtools. Installimiseks kasutage allolevat koodi.

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

Vaatame nüüd ülalkirjeldatud roboti loomise koodi:

Kood 5: robot, mis kuvab valitud jaoturi kõige värskemate artiklite loendi

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

Käivitage ülaltoodud koodinäide pärast seda, kui olete asendanud "TEIE BOTI MÄRGI" tõelise märgiga, mille saite roboti loomisel BotFather (Ma rääkisin roboti loomisest esimene artikkel).

Selle tulemusena saame järgmise tulemuse:
Telegrammiroti kirjutamine R-is (3. osa): kuidas lisada robotile klaviatuuri tuge

Kodeerisime meetodis valimiseks saadaolevate jaoturite loendi 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)
}

Käsuga saame määratud jaoturist artiklite loendi habr_hub_posts(), pakendist habR. Samas juhime tähelepanu, et me ei vaja kogu aja artiklite nimekirja, vaid ainult esimest lehekülge, millel asub 20 artiklit. Saadud tabelist käsu abil head() Jätame ainult top 5, mis on kõige värskemad artiklid.

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

Loogika on väga sarnane eelmisele robotile, kuid sel juhul genereerime funktsiooni abil dünaamiliselt artiklite loendiga tekstisisese klaviatuuri lapply().

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

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

Nuputeksti sisestame artikli pealkirja posts$title[x], ja argumendis url link artiklile: url = posts$link[x].

Järgmisena loome filtri, käitlejad ja käivitame oma roboti.

Järeldus

Nüüd on teie kirjutatud roboteid palju mugavam kasutada, kuna neid juhitakse klaviatuurilt, mitte käskude sisestamisega. Vähemalt nutitelefoni kaudu robotiga suhtlemisel lihtsustab klaviatuur selle kasutamise protsessi oluliselt.

Järgmises artiklis selgitame välja, kuidas luua loogilist dialoogi robotiga ja töötada andmebaasidega.

Allikas: www.habr.com

Lisa kommentaar