Ovo je treći članak u seriji “Pisanje telegram bota u R”. U prethodnim publikacijama naučili smo kako stvoriti telegram bot, slati poruke preko njega, dodali naredbe i filtre poruka botu. Stoga, prije nego počnete čitati ovaj članak, toplo vam preporučujem da ga pročitate prethodni, jer Ovdje se više neću zadržavati na prethodno opisanim osnovama izgradnje botova.

U ovom ćemo članku poboljšati upotrebljivost našeg bota dodavanjem tipkovnice, što će sučelje bota učiniti intuitivnim i lakim za korištenje.

Svi članci iz serije “Pisanje telegram bota u R”

sadržaj

Ako vas zanima analiza podataka, možda će vas zanimati moja telegram и youtube kanala. Većina sadržaja posvećena je jeziku R.

Koje vrste tipkovnica podržava telegram bot?
Tipkovnica za odgovore
Inline tipkovnica
3.1. Primjer jednostavnog bota s podrškom za gumbe InLine
3.2. Primjer bota koji javlja trenutno vrijeme za odabrani grad
3.3. Primjer bota koji prikazuje popis najnovijih članaka s poveznicama na navedeni Hub s habr.com
Zaključak

Koje vrste tipkovnica podržava telegram bot?

U vrijeme pisanja ovog teksta telegram.bot omogućuje izradu dvije vrste tipkovnica:

Odgovori - Glavna, obična tipkovnica, koja se nalazi ispod ploče za unos teksta poruke. Takva tipkovnica jednostavno pošalje SMS poruku botu, a kao tekst će poslati tekst koji je ispisan na samom gumbu.
Inline - tipkovnica povezana s određenom porukom bota. Ova tipkovnica šalje podatke bota povezane s pritisnutom tipkom; ti se podaci mogu razlikovati od teksta napisanog na samoj tipki. I takvi se gumbi obrađuju CallbackQueryHandler.

Da bi bot otvorio tipkovnicu potrebno je prilikom slanja poruke putem metode sendMessage(), proslijedite prethodno stvorenu tipkovnicu kao argument reply_markup.

U nastavku ćemo pogledati nekoliko primjera.

Tipkovnica za odgovore

Kao što sam gore napisao, ovo je glavna tipkovnica za upravljanje botom.

Primjer izrade Reply tipkovnice iz službene pomoći

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)

Gore navedeno je primjer iz službene pomoći paketa telegram.bot. Za izradu tipkovnice upotrijebite funkciju ReplyKeyboardMarkup(), koji pak uzima popis popisa gumba koje stvara funkcija KeyboardButton().

Zašto u ReplyKeyboardMarkup() Trebate li proći ne samo popis, već popis popisa? Činjenica je da prolazite glavni popis, au njemu definirate svaki red gumba u posebnim popisima, jer Možete postaviti nekoliko gumba u jedan red.

argument resize_keyboard omogućuje automatski odabir optimalne veličine gumba tipkovnice i argumenta one_time_keyboard omogućuje skrivanje tipkovnice nakon svakog pritiska tipke.

Napišimo jednostavnog bota koji će imati 3 gumba:

Chat ID - Zahtjev za chat ID dijaloga s botom
Moje ime - Zatražite svoje ime
Moja prijava - Zatražite svoje korisničko ime u telegramu

Kod 1: Jednostavan bot s tipkovnicom za odgovore

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

Pokrenite gornji primjer koda, nakon što ste zamijenili 'VAŠ BOT TOKEN' pravim tokenom koji ste primili prilikom stvaranja bota putem BotOtac (Razgovarao sam o stvaranju bota u prvi članak).

Nakon pokretanja, dajte botu naredbu /start, jer To je upravo ono što smo definirali za pokretanje tipkovnice.

Ako vam je trenutno teško analizirati dati primjer koda, uz izradu metoda, filtera i rukovatelja, tada se trebate vratiti na prethodni članak, u kojem sam sve to potanko opisao.

Kreirali smo 4 metode:

start — Pokrenite tipkovnicu
chat_id — Zahtjev za ID chata
my_name — Zatražite svoje ime
my_username — Zatražite svoju prijavu

Prigovoriti MessageFilters dodao 3 filtera poruka na temelju njihovog teksta:

chat_id — Poruke s tekstom "Чат ID"
ime — Poruke s tekstom "Моё имя"
korisničko ime — Poruke s tekstom "Мой логин"

I napravili smo 4 rukovatelja koji će na temelju zadanih naredbi i filtera izvršavati navedene metode.

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

Sama tipkovnica se stvara unutar metode start() Tim ReplyKeyboardMarkup().

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

U našem slučaju smo sve gumbe smjestili jedan ispod drugog, ali ih možemo rasporediti u jedan red mijenjajući popis popisa gumba. Jer jedan redak unutar tipkovnice kreiran je pomoću ugniježđene liste gumba, a zatim da bismo prikazali naše gumbe u jednom redu moramo prepisati dio koda za konstrukciju tipkovnice ovako:

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

Tipkovnica se šalje u chat pomoću metode sendMessage(), u argumentu reply_markup.

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

Inline tipkovnica

Kao što sam gore napisao, Inline tipkovnica vezana je za određenu poruku. S njom je nešto teže raditi nego s glavnom tipkovnicom.

U početku morate botu dodati metodu za pozivanje Inline tipkovnice.

Da biste odgovorili na klik gumba Inline, također možete koristiti metodu bota answerCallbackQuery(), koji može prikazati obavijest u sučelju telegrama korisniku koji pritisne gumb Inline.

Podaci koji se šalju s gumba Inline nisu tekst, pa da biste ih obradili morate stvoriti poseban rukovatelj pomoću naredbe CallbackQueryHandler().

Kod za izgradnju Inline tipkovnice koji je dan u službenoj pomoći paketa telegram.bot.

Kod za izradu Inline tipkovnice iz službene pomoći

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

Morate izgraditi Inline tipkovnicu pomoću naredbe InlineKeyboardMarkup(), na istom principu kao tipkovnica za odgovore. U InlineKeyboardMarkup() potrebno je proslijediti popis popisa Inline gumba, svaki pojedinačni gumb kreira funkcija InlineKeyboardButton().

Ugrađeni gumb može proslijediti neke podatke botu koristeći argument callback_data, ili otvorite bilo koju HTML stranicu navedenu pomoću argumenta url.

Rezultat će biti popis u kojem je svaki element također popis Inline gumba koje je potrebno kombinirati u jedan red.

Zatim ćemo pogledati nekoliko primjera botova s Inline gumbima.

Primjer jednostavnog bota s podrškom za gumbe InLine

Prvo ćemo napisati bota za ekspresno testiranje na covid-19. Po zapovijedi /test, poslat će vam tipkovnicu s dva gumba, ovisno o pritisnutom gumbu poslat će vam poruku s rezultatima vašeg testiranja.

Kod 2: Najjednostavniji bot s Inline tipkovnicom

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

Pokrenite gornji primjer koda, nakon što ste zamijenili 'VAŠ BOT TOKEN' pravim tokenom koji ste primili prilikom stvaranja bota putem BotOtac (Razgovarao sam o stvaranju bota u prvi članak).

Rezultat:

Kreirali smo dvije metode:

test — Za slanje u chat Inline tipkovnica
odgovor_cb — Za obradu podataka poslanih s tipkovnice.

Podaci koji će biti poslani sa svakog gumba navedeni su u argumentu callback_data, prilikom izrade gumba. Pomoću konstrukcije možete primiti podatke poslane s gumba update$callback_query$data, unutar metode odgovor_cb.

Da bi bot reagirao na Inline tipkovnicu, metoda odgovor_cb obrađen posebnim rukovateljem: CallbackQueryHandler(answer_cb). Koji pokreće navedenu metodu kada se klikne gumb Inline. rukovatelj CallbackQueryHandler uzima dva argumenta:

callback — Metoda koju treba pokrenuti
pattern — Filtrirajte prema podacima koji su vezani za gumb pomoću argumenta callback_data.

Sukladno tome, koristeći argument pattern Možemo napisati posebnu metodu za pritiskanje svakog gumba:

Kod 3: Odvojene metode za svaki Inline gumb

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

Pokrenite gornji primjer koda, nakon što ste zamijenili 'VAŠ BOT TOKEN' pravim tokenom koji ste primili prilikom stvaranja bota putem BotOtac (Razgovarao sam o stvaranju bota u prvi članak).

Sada smo napisali 2 odvojene metode, tj. jednu metodu, za svaki pritisak na gumb, i koristi argument pattern, prilikom kreiranja njihovih rukovatelja:

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

Kod metode završava odgovor_cb Tim bot$answerCallbackQuery(callback_query_id = update$callback_query$id), koji govori botu da su podaci s ugrađene tipkovnice primljeni.

Primjer bota koji javlja trenutno vrijeme za odabrani grad

Pokušajmo napisati bota koji traži vremenske podatke.

Logika njegovog rada bit će sljedeća. U početku timski /start pozivate glavnu tipkovnicu koja ima samo jednu tipku "Vrijeme". Klikom na ovaj gumb dobit ćete poruku s Inline tipkovnicom za odabir grada za koji želite saznati trenutno vrijeme. Odaberite jedan od gradova i saznajte trenutno vrijeme.

U ovom primjeru koda koristit ćemo nekoliko dodatnih paketa:

httr — paket za rad s HTTP zahtjevima, na temelju kojeg se gradi rad s bilo kojim API-jem. U našem slučaju koristit ćemo besplatni API openweathermap.org.
stringr — paket za rad s tekstom, u našem slučaju koristit ćemo ga za generiranje poruke o vremenu u odabranom gradu.

Kod 4: Bot koji javlja trenutno vrijeme za odabrani grad

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

Pokrenite gornji primjer koda, nakon što ste zamijenili 'VAŠ BOT TOKEN' pravim tokenom koji ste primili prilikom stvaranja bota putem BotOtac (Razgovarao sam o stvaranju bota u prvi članak).

Kao rezultat toga, naš će bot raditi otprilike ovako:

Shematski se ovaj bot može prikazati ovako:

Stvorili smo 3 dostupne metode unutar našeg vremenskog bota:

početak — Pokrenite glavnu tipkovnicu bota
vrijeme — Pokrenite Inline tipkovnicu za odabir grada
odgovor_cb — Glavna metoda koja traži vremensku prognozu od API-ja za određeni grad i šalje je u chat.

način početak pokrećemo ga naredbom /start, koji implementira rukovatelj CommandHandler('start', start).

Za pokretanje metode vrijeme napravili smo filtar istog naziva:

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

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

}
)

I ovu metodu pozivamo sa sljedećim rukovateljem poruka: MessageHandler(weather, filters = MessageFilters$weather).

I na kraju, naša glavna metoda odgovor_cb reagira na pritiskanje gumba Inline, što je implementirano posebnim rukovateljem: CallbackQueryHandler(answer_cb).

Unutar metode odgovor_cb, čitamo podatke poslane s tipkovnice i upisujemo ih u varijablu city: city <- update$callback_query$data. Zatim tražimo vremenske podatke od API-ja, generiramo i šaljemo poruku i na kraju koristimo metodu answerCallbackQuery kako bismo obavijestili bota da smo obradili klik na gumb Inline.

Primjer bota koji prikazuje popis najnovijih članaka s vezama na navedeno središte iz www.habr.com.

Predstavljam ovog bota da vam pokažem kako prikazati Inline gumbe koji vode do web stranica.

Logika ovog bota slična je prethodnoj, na početku pokrećemo glavnu tipkovnicu s naredbom /start. Zatim nam bot daje popis od 6 hubova na izbor, odabiremo hub koji nas zanima i primamo 5 najnovijih publikacija iz odabranog Huba.

Kao što razumijete, u ovom slučaju moramo dobiti popis članaka, a za to ćemo koristiti poseban paket habR, koji vam omogućuje da tražite članke od Habre i neke statistike o njima u R.

Instalirajte paket habR moguće samo s githuba, za što će vam trebati dodatni paket devtools. Za instalaciju koristite kod u nastavku.

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

Sada pogledajmo kod za izradu gore opisanog bota:

Kod 5: Bot koji prikazuje popis najnovijih članaka na odabranom Hubu

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

Pokrenite gornji primjer koda, nakon što ste zamijenili 'VAŠ BOT TOKEN' pravim tokenom koji ste primili prilikom stvaranja bota putem BotOtac (Razgovarao sam o stvaranju bota u prvi članak).

Kao rezultat, dobit ćemo ovaj rezultat:

Čvrsto smo kodirali popis čvorišta dostupnih za odabir u metodi 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)
}

Naredbom dobivamo popis članaka iz navedenog Huba habr_hub_posts(), iz paketa habR. Pritom napominjemo da nam nije potreban popis članaka za cijelo vrijeme, već samo prva stranica na kojoj se nalazi 20 članaka. Iz dobivene tablice pomoću naredbe head() Ostavljamo samo prvih 5, koji su najnoviji članci.

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

Logika je vrlo slična prethodnom botu, ali u ovom slučaju generiramo Inline tipkovnicu s popisom članaka dinamički pomoću funkcije lapply().

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

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

Naslov članka umetnemo u tekst gumba posts$title[x], i u argument url link na članak: url = posts$link[x].

Zatim stvaramo filtar, rukovatelje i pokrećemo našeg bota.

Zaključak

Sada će botovi koje pišete biti mnogo praktičniji za korištenje, jer će se njima upravljati s tipkovnice, a ne unosom naredbi. U najmanju ruku, kada komunicirate s botom putem pametnog telefona, tipkovnica će značajno pojednostaviti postupak korištenja.

U sljedećem ćemo članku otkriti kako izgraditi logičan dijalog s botom i raditi s bazama podataka.

Izvor: www.habr.com