See on kolmas artikkel seerias "Kirjutame telegrammi boti R keeles". Eelnevates väljaannetes õppisime, kuidas luua telegrammi bot, saata selle kaudu sõnumeid ning lisada botile käske ja sõnumifiltreid. Seetõttu soovitan tungivalt enne käesoleva artikli lugemist tutvuda eelnevatega, kuna ma ei puuduta siin juba varem kirjeldatud botide loomise aluseid.

Selles artiklis parandame meie boti kasutatavust, lisades klaviatuuri, mis muudab boti liidese intuitiivsemaks ja lihtsamaks kasutada.

Kõik artiklid seeriast "Kirjutame telegrammi boti R keeles"

Sisu

Kui teid huvitab andmeanalüüs, siis võivad teile huvi pakkuda minu telegram ja youtube kanalid, mille suurem osa sisust on pühendatud R keelele.

Milliseid klaviatuuride tüüpe toetab telegrammibot
Reply klaviatuur
Inline klaviatuur
3.1. Näide lihtsaimast botist, mis toetab InLine nuppe
3.2. Näide botist, mis edastab valitud linna hetke ilmateate
3.3. Näide botist, mis kuvab nimekirja kõige värskematest artiklitest linkidega määratud Habrist habr.com
Kokkuvõte

Milliseid klaviatuuride tüüpe toetab telegrammibot

Artikli kirjutamise hetkel telegram.bot lubab teil luua kahte tüüpi klaviatuure:

Reply — Peamine, tavaline klaviatuur, mis asub sõnumi sisestamise paneeli all. See klaviatuur saadab boti tekstisõnumi ning saadab tekstina selle, mis on kirjutatud nupul endal.
Inline — Klaviatuur, mis on seotud konkreetse boti sõnumiga. See klaviatuur saadab botile andmeid, mis on seotud vajutatud nupuga, need andmed võivad erineda nupul kirjutatud tekstist. Selliseid nuppe töödeldakse läbi CallbackQueryHandler.

Et bot avaks klaviatuuri, tuleb sõnumi saatmisel kasutada meetodit sendMessage(), ning edastada varem loodud klaviatuur argumendiks reply_markup.

Allpool vaatame mitmeid näiteid.

Reply klaviatuur

Nagu ma juba varem mainisin, on see boti haldamise peamine klaviatuur.

Näide Reply klaviatuuri loomisest ametlikust dokumentatsioonist

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

# Loo kohandatud klaviatuur
text <- "Kas need kohandatud klaviatuurid pole mitte ägedad?"
RKM <- ReplyKeyboardMarkup(
  keyboard = list(
    list(KeyboardButton("Jah, need on kindlasti ägedad!")),
    list(KeyboardButton("Ma pole päris kindel")),
    list(KeyboardButton("Ei..."))
  ),
  resize_keyboard = FALSE,
  one_time_keyboard = TRUE
)

# Saada kohandatud klaviatuur
bot$sendMessage(chat_id, text, reply_markup = RKM)

Ülaltoodud näide on võetud paketi ametlikust dokumentatsioonist telegram.bot. Klaviatuuri loomiseks kasutatakse funktsiooni ReplyKeyboardMarkup(), mis omakorda võtab vastu loendi loenditest nuppudest, mille loomiseks kasutatakse funktsiooni KeyboardButton().

Miks on vaja ReplyKeyboardMarkup() edastada mitte lihtsalt loendi, vaid loendite loendi? Asjaolu on selles, et edastate peamise loendi ja selles määrate eraldi loendites iga nupu rea, kuna ühte ritta saab paigutada mitu nuppu.

Argument resize_keyboard lubab automaatselt kohandada klaviatuuri nuppude optimaalset suurust, samas kui argument one_time_keyboard lubab peita klaviatuuri pärast iga nupu vajutamist.

Kirjutame lihtsaimat boti, millel on 3 nuppu:

Vestluse ID — Kutsu vestluse ID-d boti dialoogis
Minu nimi — Kutsu oma nime
Minu kasutajanimi — Kutsu oma kasutajanime Telegramis

Kood 1: Lihtne bot, millel on Reply klaviatuur

library(telegram.bot)

# loome Updater klassi eksemplar
updater <- Updater('TEIE BOTA TOKEN')

# loome meetodid
## klaviatuuri käivitamise meetod
start <- function(bot, update) {

  # loome klaviatuuri
  RKM <- ReplyKeyboardMarkup(
    keyboard = list(
      list(KeyboardButton("Chat ID")),
      list(KeyboardButton("Minu nimi")),
      list(KeyboardButton("Minu kasutajanimi"))
    ),
    resize_keyboard = FALSE,
    one_time_keyboard = TRUE
  )

  # saadame klaviatuuri
  bot$sendMessage(update$message$chat_id,
                  text = 'Valige käsk', 
                  reply_markup = RKM)

}

## meetod, mis tagastab chati id
chat_id <- function(bot, update) {

  bot$sendMessage(update$message$chat_id, 
                  text = paste0("Selle dialooge Chat id: ", update$message$chat_id),
                  parse_mode = "Markdown")

}

## meetod, mis tagastab nime
my_name <- function(bot, update) {

  bot$sendMessage(update$message$chat_id, 
                  text = paste0("Teid kutsutakse ", update$message$from$first_name),
                  parse_mode = "Markdown")

}

## meetod, mis tagastab kasutajanime
my_username <- function(bot, update) {

  bot$sendMessage(update$message$chat_id, 
                  text = paste0("Teie kasutajanimi ", update$message$from$username),
                  parse_mode = "Markdown")

}

# loome filtrid
## sõnumid, mille tekst on Chat ID
MessageFilters$chat_id <- BaseFilter(function(message) {

  # kontrollime sõnumi teksti
  message$text == "Chat ID"

}
)

## sõnumid, mille tekst on Minu nimi
MessageFilters$name <- BaseFilter(function(message) {

  # kontrollime sõnumi teksti
  message$text == "Minu nimi"

}
)

## sõnumid, mille tekst on Minu kasutajanimi
MessageFilters$username <- BaseFilter(function(message) {

  # kontrollime sõnumi teksti
  message$text == "Minu kasutajanimi"
)

# loome töötlejad
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)

# lisame töötlejad haldurisse
updater <- updater + 
            h_start +
            h_chat_id +
            h_name +
            h_username

# käivitame boti 
updater$start_polling()

Käivitage ülaltoodud koodinäide, asendades ‘TEIE BOTE TOKEN’ tegeliku tokeniga, mille said, kui lõite boti läbi BotFather (boti loomise kohta rääkisin ma esimesest artiklist).

Pärast käivitamist andke botile käsk /start, kuna just seda me määratlesime klaviatuuri käivitamiseks.

Kui hetkel on teil keeruline arusaada antud koodinäitest, mis käsitleb meetodite, filtrite ja häälestajate loomist, tuleks naasta eelneva artiklis, kus ma kõik selle detailselt selgitasin.

Loomi 4 meetodit:

start — Klaviatuuri käivitamine
chat_id — Chat'i identifikaatori pärimine
my_name — Oma nime pärimine
my_username — Oma kasutajanime pärimine

Objekti MessageFilters oleme lisanud 3 sõnumifiltrit, vastavalt nende tekstile:

chat_id — Sõnumid, mille tekst on "Chat ID"
name — Sõnumid, mille tekst on "Minu nimi"
username — Sõnumid, mille tekst on "Minu kasutajanimi"

Ja loodi 4 häälestajat, mis määratletud käskude ja filtrite alusel viivad ellu 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 luuakse meetodi raames start() käsku ReplyKeyboardMarkup().

RKM <- ReplyKeyboardMarkup(
    keyboard = list(
      list(KeyboardButton("Chat ID")),
      list(KeyboardButton("Minu nimi")),
      list(KeyboardButton("Minu kasutajanimi"))
    ),
    resize_keyboard = FALSE,
    one_time_keyboard = TRUE
)

Meie puhul oleme kõik nupud järjestanud üksteise alla, kuid vajalike muudatuste tegemisel saame need paigutada ka ühte ritta. Kuna ühes reas klaviatuuril luuakse nutika nuppude loendi kaudu, tuleb meie nuppude ühte ritta kuvamiseks ümber kirjutada osa koodist klaviatuuri ehitamiseks järgmiselt:

RKM <- ReplyKeyboardMarkup(
    keyboard = list(
      list(
          KeyboardButton("Chati ID"),
          KeyboardButton("Minu nimi"),
          KeyboardButton("Minu kasutajanimi")
     )
    ),
    resize_keyboard = FALSE,
    one_time_keyboard = TRUE
)

Klaviatuur saadetakse vestlusesse meetodi kaudu sendMessage(), argumendina reply_markup.

  bot$sendMessage(update$message$chat_id,
                  text = 'Valige käsk', 
                  reply_markup = RKM)

Inline klaviatuur

Kuidas ma juba varem ütlesin, on Inline klaviatuur seotud konkreetse sõnumiga. Sellega töötamine on veidi keerulisem kui peamise klaviatuuriga.

Esialgu peate botile lisama meetodi Inline klaviatuuri kutsumiseks.

Inline nupu vajutustele vastamiseks saab samuti kasutada boti meetodit answerCallbackQuery(), mis võib kuvada teate telegrami kasutajaliideses kasutajale, kes vajutab Inline nuppu.

Inline nupuli kaudu edastatud andmed ei ole tekst, seega on nende töötlemiseks vajalik luua spetsiaalne töötleja käsu abil CallbackQueryHandler().

Inline klaviatuuri loomise kood, mis on toodud paketiga seotud ametlikus dokumentatsioonis telegram.bot.

Inline klaviatuuri loomise kood ametlikust dokumentatsioonist

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

Inline klaviatuuri tuleb luua käsu abil InlineKeyboardMarkup(), samamoodi nagu Reply klaviatuuri puhul. V InlineKeyboardMarkup() on vaja edastada loetelu, Inline nuppude loetelud, iga eraldi nupp luuakse funktsiooni abil InlineKeyboardButton().

Inline nupp võib kas edastada botile mingisuguseid andmeid argumendi abil callback_data, või avada mingi HTML lehe, mille on määranud argument url.

Tulemuseks on loetelu, kus iga element on samuti Inline nuppude loetelu, mis tuleb ühendada ühte ritta.

Edasi vaatame mitmeid näiteid botidest, millel on Inline nupud.

Näide lihtsaimast botist, mis toetab InLine nuppe

Esialgu kirjutame boti COVID-19 kiireks testimiseks. Käsu abil /test, saadab ta teile klaviatuuri, kus on kaks nuppu, sõltuvalt vajutatud nupust, saadab ta teile sõnumi teie testimisresultaatidega.

Kood 2: Lihtne bot Inline klaviatuuriga

library(telegram.bot)

# loome Updater klassi eksemplari
updater <- Updater('TEIE BOTA TOKEN')

# meetod InLine klaviatuuri saatmiseks
test <- function(bot, update) {

  # loome InLine klaviatuuri
  IKM <- InlineKeyboardMarkup(
    inline_keyboard = list(
      list(
        InlineKeyboardButton("Jah", callback_data = 'yes'),
        InlineKeyboardButton("Ei", callback_data = 'no')
      )
    )
  )

  # Saatke klaviatuur vestlusesse
  bot$sendMessage(update$message$chat_id, 
                  text = "Kas olete nakatunud koronaviirusega?", 
                  reply_markup = IKM)
}

# meetod nupu vajutamise töötlemiseks
answer_cb <- function(bot, update) {

  # nupult saadud andmed
  data <- update$callback_query$data

  # saame nupule vajutanud kasutaja nime
  uname <- update$effective_user()$first_name

  # tulemuse töötlemine
  if ( data == 'no' ) {

    msg <- paste0(uname, ", õnnitleme, teie covid-19 test on negatiivne.")

  } else {

    msg <- paste0(uname, ", kahjuks on teie covid-19 test positiivne.")

  }

  # Saada sõnum
  bot$sendMessage(chat_id = update$from_chat_id(),
                  text = msg)

  # teatame botile, et nupu päring on vastu võetud
  bot$answerCallbackQuery(callback_query_id = update$callback_query$id) 
}

# loome töötlejad
inline_h      <- CommandHandler('test', test)
query_handler <- CallbackQueryHandler(answer_cb)

# lisame töötlejad juhendisse
updater <- updater + inline_h + query_handler

# käivitame boti
updater$start_polling()

Käivitage ülaltoodud koodinäide, asendades ‘TEIE BOTE TOKEN’ tegeliku tokeniga, mille said, kui lõite boti läbi BotFather (boti loomise kohta rääkisin ma esimesest artiklist).

Tulemus:

Loomulikult oleme loonud kaks meetodit:

test — Inline klaviatuuri kaudu vestlusse saatmiseks
answer_cb — Klaviatuuri kaudu saadetud andmete töötlemiseks.

Iga nupu kaudu saadetavad andmed määratakse argumentides callback_data, nupu loomisel. Nupi saadetud andmeid saab kätte konstruktsiooni kaudu update$callback_query$data, meetodi sees answer_cb.

Kuna bot reageerimiseks Inline klaviatuurile, peab meetod answer_cb olema spetsiaalse töötleja kaudu: CallbackQueryHandler(answer_cb). Mis käivitab määratud meetodi Inline nupu vajutamisel. Töötleja CallbackQueryHandler võtab vastu kaks argumenti:

callback — Meetod, mida tuleb käivitada
pattern — Filtreerimine andmete järgi, mis on seotud nupuga argumentide kaudu callback_data.

Seega arvestades argumenti pattern saame iga nupu vajutamise jaoks kirjutada eraldi meetodi:

Kood 3: Jagame meetodid iga Inline nupu jaoks

library(telegram.bot)

# loome Updater klassi eksemplar
updater <- Updater('TEIE BOTA TOKEN')

# meetod InLine klaviatuuri saatmiseks
test <- function(bot, update) {  

  # loome InLine klaviatuuri
  IKM <- InlineKeyboardMarkup(
    inline_keyboard = list(
      list(
        InlineKeyboardButton("Jah", callback_data = 'yes'),
        InlineKeyboardButton("Ei", callback_data = 'no')
      )
    )
  )

  # Saame klaviatuuri vestlusse
  bot$sendMessage(update$message$chat_id, 
                  text = "Kas oled haigestunud koronaviirusesse?", 
                  reply_markup = IKM)
}

# meetod Ja nupu vajutuse töötlemiseks
answer_cb_yes <- function(bot, update) {

  # saame kasutaja nime, kes nuppu vajutas
  uname <- update$effective_user()$first_name

  # tulemuse töötlemine
  msg <- paste0(uname, ", kahjuks on teie test covid-19 osas positiivne.")

  # Sõnumi saatmine
  bot$sendMessage(chat_id = update$from_chat_id(),
                  text = msg)

  # teatame botile, et nuppu vajutuse päring on vastu võetud
  bot$answerCallbackQuery(callback_query_id = update$callback_query$id) 
}

# meetod Ei nupu vajutuse töötlemiseks
answer_cb_no <- function(bot, update) {

  # saame kasutaja nime, kes nuppu vajutas
  uname <- update$effective_user()$first_name

  msg <- paste0(uname, ", õnnitleme, teie test covid-19 osas on negatiivne.")

  # Sõnumi saatmine
  bot$sendMessage(chat_id = update$from_chat_id(),
                  text = msg)

  # teatame botile, et nuppu vajutuse päring on vastu võetud
  bot$answerCallbackQuery(callback_query_id = update$callback_query$id) 
}

# loome töötlejad
inline_h          <- CommandHandler('test', test)
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no  <- CallbackQueryHandler(answer_cb_no, pattern = 'no')

# lisame töötlejad dispatcherisse
updater <- updater + 
            inline_h + 
            query_handler_yes +
            query_handler_no

# käivitame boti
updater$start_polling()

Käivitage ülaltoodud koodinäide, asendades ‘TEIE BOTE TOKEN’ tegeliku tokeniga, mille said, kui lõite boti läbi BotFather (boti loomise kohta rääkisin ma esimesest artiklist).

Nüüd oleme kirjutanud kaks eraldi meetodit, st ühe meetodi iga nupu vajutamiseks, ja kasutasime 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õppeb answer_cb käsku bot$answerCallbackQuery(callback_query_id = update$callback_query$id), mis teavitab boti, et andmed inline klaviatuurilt on saadud.

Näide botist, mis edastab valitud linna hetke ilmateate

Proovime kirjutada boti, mis küsib ilmastikuandmeid.

Selle töö loogika on järgmine. Alguses käsuga /start kutsute välja põhiklaviatuuri, kus on ainult üks nupp „Ilm”. Kui vajutate sellele nupule, saate sõnumi Inline klaviatuuriga, et valida linna, mille kohta soovite teada praegust ilma. Valite ühe linnadest ja saate praeguse ilma.

Selles koodinäites kasutame mitmeid täiendavaid pakette:

httr — pakett HTTP päringute töötlemiseks, mille põhjal on üles ehitatud töö iga API-ga. Meie puhul kasutame tasuta API-d openweathermap.org.
stringr — pakett teksti töötlemiseks, meie puhul kasutame seda valitud linna ilma sõnumi koostamiseks.

Kood 4: Bot, mis teatab valitud linna praegust ilma.

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

# loome Updater klassi eksemplar
updater <- Updater('TEIE BOTS TÕEND')

# loome meetodid
## meetod põhi klaviatuuri aktiveerimiseks
start <- function(bot, update) {

  # loome klaviatuuri
  RKM <- ReplyKeyboardMarkup(
    keyboard = list(
      list(
        KeyboardButton("Ilm")
      )
    ),
    resize_keyboard = TRUE,
    one_time_keyboard = TRUE
  )

  # saadame klaviatuuri
  bot$sendMessage(update$message$chat_id,
                  text = 'Valige käsk', 
                  reply_markup = RKM)

}

## Meetod Inine klaviatuuri aktiveerimiseks
weather <- function(bot, update) {

  IKM <- InlineKeyboardMarkup(
    inline_keyboard = list(
      list(
        InlineKeyboardButton(text = 'Moskv', callback_data = 'New York,us'),
        InlineKeyboardButton(text = 'Peterburi', callback_data = 'Saint Petersburg'),
        InlineKeyboardButton(text = 'New Yorg', callback_data = 'New York')
      ),
      list(
        InlineKeyboardButton(text = 'Jekaterinburg', callback_data = 'Yekaterinburg,ru'),
        InlineKeyboardButton(text = 'Berliin', callback_data = 'Berlin,de'),
        InlineKeyboardButton(text = 'Pariis', callback_data = 'Paris,fr')
      ),
      list(
        InlineKeyboardButton(text = 'Rooma', callback_data = 'Rome,it'),
        InlineKeyboardButton(text = 'Odessa', callback_data = 'Odessa,ua'),
        InlineKeyboardButton(text = 'Kiiev', callback_data = 'Kyiv,fr')
      ),
      list(
        InlineKeyboardButton(text = 'Tokyo', callback_data = 'Tokyo'),
        InlineKeyboardButton(text = 'Amsterdam', callback_data = 'Amsterdam,nl'),
        InlineKeyboardButton(text = 'Washington', callback_data = 'Washington,us')
      )
    )
  )

  # Saada Inline Klaviatuur
  bot$sendMessage(chat_id = update$message$chat_id, 
                  text = "Valige linn", 
                  reply_markup = IKM)
}

# meetod ilma teadetamiseks
answer_cb <- function(bot, update) {

  # saame linn, mis tuli sõnumist
  city <- update$callback_query$data

  # saadame päringu
  ans <- GET('https://api.openweathermap.org/data/2.5/weather', 
             query = list(q     = city,
                          lang  = 'et',
                          units = 'metric',
                          appid = '4776568ccea136ffe4cda9f1969af340')) 

  # parsime vastuse
  result <- content(ans)

  # vormime sõnumi
  msg <- str_glue("{result$name} ilm:n",
                  "Praegune temperatuur: {result$main$temp}n",
                  "Tuule kiirus: {result$wind$speed}n",
                  "Kirjeldus: {result$weather[[1]]$description}")

  # saadame ilma teavet
  bot$sendMessage(chat_id = update$from_chat_id(),
                  text    = msg)

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

# loome filtrid
## sõnumid koos tekstiga Ilm
MessageFilters$weather <- BaseFilter(function(message) {

  # kontrollime sõnumi teksti
  message$text == "Ilm"

}
)

# loome töötlejad
h_start         <- CommandHandler('start', start)
h_weather       <- MessageHandler(weather, filters = MessageFilters$weather)
h_query_handler <- CallbackQueryHandler(answer_cb)

# lisame töötlejad jaoturi
updater <- updater + 
              h_start +
              h_weather +
              h_query_handler

# käivitame boti
updater$start_polling()

Käivitage ülaltoodud koodinäide, asendades ‘TEIE BOTE TOKEN’ tegeliku tokeniga, mille said, kui lõite boti läbi BotFather (boti loomise kohta rääkisin ma esimesest artiklist).

Seetõttu töötab meie bot umbes nii:

Skeemiliselt võiks seda bot'i kujundada nii:

Oleme loonud 3 meetodit, mis on saadaval meie ilmateate bot'is:

start — Peamise bot'i klaviatuuri käivitamine
ilm — Inline klaviatuuri käivitamine linna valimiseks
answer_cb — Peamine meetod, mis küsib API-st ilmastikuandmeid antud linna kohta ja saadab need vestlusesse.

Meetod start meie käivitame käsuga /start, mis on teostatud töötlejaga CommandHandler('start', start).

Meetodi käivitamiseks ilm oleme loonud sama nime filtri:

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

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

}
)

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

Ja lõpuks, meie peamine meetod answer_cb reaktseereerib Inline nuppude vajutustele, mis on teostatud spetsiaalse töötlejaga: CallbackQueryHandler(answer_cb).

Meetodi sees answer_cb, loeme klaviatuurilt saadetud andmed ja salvestame need muutuja linn: linn <- update$callback_query$data. Seejärel küsime API-st ilmade andmeid, koostame ja saadame sõnumi ning lõpuks kasutame meetodit answerCallbackQuery et teavitada bot'i, et oleme Inline nupu vajutuse töötlenud.

Bot'i näide, mis väljastab nimekirja kõige värskematest artiklitest lingi kaudu määratud Hubi kohta habr.com.

Seda boti näitan ma teile, kuidas luua veebilehtedele viitavaid Inline-nuppe.

Selle boti loogika sarnaneb eelnevale, kõigepealt käivitame peamise klaviatuuri käsuga /start. Järgmiseks annab bot meile valida 6 hubi vahel, valime huvipakkuva hubi ning saame 5 kõige värskemat publikatsiooni valitud hubist.

Nagu mõistate, peame me saama artiklite nimekirja ning selleks kasutame spetsiaalset paketti habR, mis võimaldab küsida Hubralt artikleid ja teatud statistikat nende kohta R-is.

Paketti habR saab installida ainult GitHubist, mille jaoks on vaja täiendavat paketti devtools. Paigaldamiseks kasutage allolevat koodi.

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

Nüüd vaatame üle koodi, mis loob ülalpool kirjeldatud boti:

Kood 5: Bot, mis toob välja nimekirja kõige värskematest artiklitest valitud hubi kohta

library(telegram.bot)
library(habR)

# loome Updater klassi eksemplari
updater <- Updater('TEIE BOTS TOKEN')

# loome meetodid
## meetod peamise klaviatuuri käivitamiseks
start <- function(bot, update) {

  # loome klaviatuuri
  RKM <- ReplyKeyboardMarkup(
    keyboard = list(
      list(
        KeyboardButton("Artiklite nimekiri")
      )
    ),
    resize_keyboard = TRUE,
    one_time_keyboard = TRUE
  )

  # saadame klaviatuuri
  bot$sendMessage(update$message$chat_id,
                  text = 'Valige käsk', 
                  reply_markup = RKM)

}

## Meetod Inline klaviatuuri kutsumiseks
habs <- function(bot, update) {

  IKM <- InlineKeyboardMarkup(
    inline_keyboard = list(
      list(
        InlineKeyboardButton(text = 'R', callback_data = 'R'),
        InlineKeyboardButton(text = 'Andmete kaevandamine', callback_data = 'data_mining'),
        InlineKeyboardButton(text = 'Andmete inseneeria', callback_data = 'data_engineering')
      ),
      list(
        InlineKeyboardButton(text = 'Suured andmed', callback_data = 'bigdata'),
        InlineKeyboardButton(text = 'Python', callback_data = 'python'),
        InlineKeyboardButton(text = 'Andmete visualiseerimine', callback_data = 'data_visualization')
      )
    )
  )

  # Saada Inline Klaviatuur
  bot$sendMessage(chat_id = update$message$chat_id, 
                  text = "Valige Hub", 
                  reply_markup = IKM)
}

# meetod ilmailmade teadaandmiseks
answer_cb <- function(bot, update) {

  # saame sõnumist linna
  hub <- update$callback_query$data

  # sõnum, et andmed on nuppu vajutades saadud
  bot$answerCallbackQuery(callback_query_id = update$callback_query$id, 
                          text = 'Palun oodake paar minutit, päringut töödeldakse') 

  # sõnum, et tuleb oodata, kuni bot andmed saab
  mid <- bot$sendMessage(chat_id = update$from_chat_id(),
                         text    = "Palun oodake paar minutit, kuni kogun andmed valitud Hubi kohta")

  # parse hub
  posts <- head(habr_hub_posts(hub, 1), 5)

  # kustutame sõnumi, et oodata
  bot$deleteMessage(update$from_chat_id(), mid$message_id) 

  # loome nupud
  keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))

  # loome klaviatuuri
  IKM <- InlineKeyboardMarkup(
    inline_keyboard = keys 
    )

  # saadame ilmastiku teavet
  bot$sendMessage(chat_id = update$from_chat_id(),
                  text    = paste0("5 kõige värskemat artiklit Hubist ", hub),
                  reply_markup = IKM)

}

# loome filtrid
## sõnumid, milles on tekst Ilm
MessageFilters$hubs <- BaseFilter(function(message) {

  # kontrollime sõnumi teksti
  message$text == "Artiklite nimekiri"

}
)

# loome käsitlejad
h_start         <- CommandHandler('start', start)
h_hubs          <- MessageHandler(habs, filters = MessageFilters$hubs)
h_query_handler <- CallbackQueryHandler(answer_cb)

# lisame käsitlejad haldurisse
updater <- updater + 
  h_start +
  h_hubs  +
  h_query_handler

# käivitame boti
updater$start_polling()

Käivitage ülaltoodud koodinäide, asendades ‘TEIE BOTE TOKEN’ tegeliku tokeniga, mille said, kui lõite boti läbi BotFather (boti loomise kohta rääkisin ma esimesest artiklist).

Lõpuks saame sellise tulemuse:

Valitavade Hubide nimekiri on kõvaketast sisse kirjutatud meetodis 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)
}

Kohustuslikud artiklid valitud Hubist saame käsuga habr_hub_posts(), paketist habR. Sel juhul näitame, et meil ei ole vaja saada artiklite loendit kogu ajalt, vaid ainult esimest lehte, millel on 20 artiklit. Saadud tabelist jäävad meil üle head() ainult 5 kõige ülemist, mis on ka kõige värskemad artiklid.

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

Loogika on väga sarnane eelmise robotiga, kuid antud juhul genereerime Inline klaviatuuri artiklite nimekirja dünaamiliselt funktsiooni lapply().

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

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

Nupu tekstiks paneme artikli pealkirja posts$title[x], ja argumendiks url artiklile viitamise: url = posts$link[x].

Edasi loome filtri, käitlejad ja käivitame meie roboti.

Kokkuvõte

Nüüd on teie kirjutatud robotid oluliselt mugavamad, kuna nende juhtimine toimub klaviatuuri kaudu, mitte käskude sisestamisega. Eriti interaktsioonides robotiga nutitelefoni kaudu kergendab klaviatuur oluliselt selle kasutamist.

Järgmises artiklis vaatame, kuidas luua loogilisi dialooge robotiga ja töötada andmebaasidega.

Allikas: habr.com