Dette er den tredje artikkelen i serien "Å skrive en telegram-bot i R". I tidligere publikasjoner lærte vi å lage en telegram-bot, sende meldinger gjennom den, legge til kommandoer og meldingsfiltre til boten. Derfor, før du begynner å lese denne artikkelen, anbefaler jeg på det sterkeste at du leser tidligere, fordi Her skal jeg ikke lenger dvele ved det tidligere beskrevne grunnleggende om botbygging.

I denne artikkelen vil vi forbedre brukervennligheten til boten vår ved å legge til et tastatur, som vil gjøre botgrensesnittet intuitivt og enkelt å bruke.

Alle artikler fra serien "Skrive en telegram-bot i R"

Innhold

Hvis du er interessert i dataanalyse, kan du være interessert i min telegram и youtube kanaler. Det meste av innholdet er dedikert til R-språket.

Hvilke typer tastaturer støtter telegramboten?
Svartastatur
Innebygd tastatur
3.1. Et eksempel på en enkel bot med støtte for InLine-knapper
3.2. Et eksempel på en bot som rapporterer gjeldende vær for en valgt by
3.3. Et eksempel på en bot som viser en liste over de nyeste artiklene med lenker til den angitte Hub fra habr.com
Konklusjon

Hvilke typer tastaturer støtter telegramboten?

I skrivende stund telegram.bot lar deg lage to typer tastaturer:

Svar - Det vanlige hovedtastaturet, som er plassert under inntastingspanelet for meldingstekst. Et slikt tastatur sender rett og slett en tekstmelding til boten, og som teksten vil det sende teksten som er skrevet på selve knappen.
Inline - Tastatur knyttet til en spesifikk bot-melding. Dette tastaturet sender botdataene knyttet til knappen som er trykket; disse dataene kan avvike fra teksten som er skrevet på selve knappen. Og slike knapper behandles gjennom CallbackQueryHandler.

For at boten skal åpne tastaturet, er det nødvendig når du sender en melding gjennom metoden sendMessage(), send det tidligere opprettede tastaturet som et argument reply_markup.

Nedenfor skal vi se på flere eksempler.

Svartastatur

Som jeg skrev ovenfor, er dette det viktigste botkontrolltastaturet.

Et eksempel på å lage et svartastatur fra den offisielle hjelpen

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)

Ovennevnte er et eksempel fra den offisielle hjelpen til pakken telegram.bot. For å lage et tastatur, bruk funksjonen ReplyKeyboardMarkup(), som igjen tar en liste over lister over knapper som er opprettet av funksjonen KeyboardButton().

Hvorfor i ReplyKeyboardMarkup() Trenger du å bestå ikke bare en liste, men en liste over lister? Faktum er at du passerer hovedlisten, og i den definerer du hver rad med knapper i separate lister, fordi Du kan plassere flere knapper på én rad.

argument resize_keyboard lar deg automatisk velge den optimale størrelsen på tastaturknappene og argumentet one_time_keyboard lar deg skjule tastaturet etter hvert knappetrykk.

La oss skrive en enkel bot som vil ha 3 knapper:

Chat-ID - Be om chat-ID for dialog med bot
Mitt navn - Be om navnet ditt
Min pålogging - Be om brukernavnet ditt i telegram

Kode 1: Enkel bot med svartastatur

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

Kjør kodeeksemplet ovenfor, etter å ha erstattet 'DIN BOTTOKEN' med den virkelige tokenen du mottok da du opprettet boten via BotFader (Jeg snakket om å lage en bot i første artikkel).

Etter oppstart, gi boten en kommando /start, fordi Dette er nøyaktig hva vi definerte for å starte tastaturet.

Hvis det for øyeblikket er vanskelig for deg å analysere det gitte kodeeksemplet, med å lage metoder, filtre og behandlere, bør du gå tilbake til den forrige artikkel, hvor jeg beskrev alt dette i detalj.

Vi har laget 4 metoder:

start — Start tastaturet
chat_id — Be om chat-ID
mitt_navn — Be om navnet ditt
mitt_brukernavn — Be om pålogging

Å protestere Meldingsfiltre la til 3 meldingsfiltre basert på teksten deres:

chat_id — Meldinger med tekst "Чат ID"
navn — Meldinger med tekst "Моё имя"
brukernavn — Meldinger med tekst "Мой логин"

Og vi opprettet 4 behandlere som, basert på gitte kommandoer og filtre, vil utføre de spesifiserte metodene.

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

Selve tastaturet er laget inne i metoden start() team ReplyKeyboardMarkup().

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

I vårt tilfelle plasserte vi alle knappene under hverandre, men vi kan ordne dem på én rad ved å gjøre endringer i listen over knappelister. Fordi en rad inne i tastaturet lages gjennom en nestet liste med knapper, og for å vise knappene våre i en rad må vi omskrive en del av koden for å konstruere tastaturet slik:

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

Tastaturet sendes til chatten ved hjelp av metoden sendMessage(), i argumentasjonen reply_markup.

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

Innebygd tastatur

Som jeg skrev ovenfor, er Inline-tastaturet knyttet til en bestemt melding. Det er noe vanskeligere å jobbe med enn hovedtastaturet.

Til å begynne med må du legge til en metode til boten for å kalle det innebygde tastaturet.

For å svare på et Inline-knappklikk kan du også bruke bot-metoden answerCallbackQuery(), som kan vise et varsel i telegramgrensesnittet til brukeren som trykker på Inline-knappen.

Dataene som sendes fra Inline-knappen er ikke tekst, så for å behandle dem må du opprette en spesiell behandler ved å bruke kommandoen CallbackQueryHandler().

Koden for å bygge et Inline-tastatur som er gitt i den offisielle hjelpen til pakken telegram.bot.

Kode for å bygge et innebygd tastatur fra den offisielle hjelpen

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

Du må bygge et innebygd tastatur ved å bruke kommandoen InlineKeyboardMarkup(), på samme prinsipp som Svar-tastaturet. I InlineKeyboardMarkup() det er nødvendig å sende en liste over lister over innebygde knapper, hver enkelt knapp opprettes av funksjonen InlineKeyboardButton().

En innebygd knapp kan enten sende noen data til boten ved hjelp av et argument callback_data, eller åpne en hvilken som helst HTML-side spesifisert med argumentet url.

Resultatet vil være en liste der hvert element også er en liste over innebygde knapper som må kombineres til én rad.

Deretter skal vi se på flere eksempler på roboter med innebygde knapper.

Et eksempel på en enkel bot med støtte for InLine-knapper

Først skal vi skrive en bot for ekspresstesting for covid-19. Etter kommando /test, vil den sende deg et tastatur med to knapper, avhengig av hvilken knapp du trykker på, vil den sende deg en melding med resultatene av testen din.

Kode 2: Den enkleste roboten med et innebygd tastatur

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

Kjør kodeeksemplet ovenfor, etter å ha erstattet 'DIN BOTTOKEN' med den virkelige tokenen du mottok da du opprettet boten via BotFader (Jeg snakket om å lage en bot i første artikkel).

Resultat:

Vi har laget to metoder:

test — For å sende til chat Inline-tastatur
svar_cb — For å behandle data sendt fra tastaturet.

Dataene som skal sendes fra hver knapp er spesifisert i argumentet callback_data, når du oppretter en knapp. Du kan motta dataene sendt fra knappen ved å bruke konstruksjonen update$callback_query$data, inne i metoden svar_cb.

For at roboten skal reagere på det innebygde tastaturet, metode svar_cb behandlet av en spesiell behandler: CallbackQueryHandler(answer_cb). Som kjører den angitte metoden når Inline-knappen klikkes. Handler CallbackQueryHandler tar to argumenter:

callback — Metoden som må kjøres
pattern — Filtrer etter data som er bundet til knappen ved hjelp av et argument callback_data.

Følgelig bruker argumentet pattern Vi kan skrive en egen metode for å trykke på hver knapp:

Kode 3: Separate metoder for hver innebygd knapp

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

Kjør kodeeksemplet ovenfor, etter å ha erstattet 'DIN BOTTOKEN' med den virkelige tokenen du mottok da du opprettet boten via BotFader (Jeg snakket om å lage en bot i første artikkel).

Nå har vi skrevet 2 separate metoder dvs. én metode, for hvert knappetrykk, og brukte argumentet pattern, når de oppretter behandlere:

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

Metodekoden avsluttes svar_cb team bot$answerCallbackQuery(callback_query_id = update$callback_query$id), som forteller boten at data fra det innebygde tastaturet er mottatt.

Et eksempel på en bot som rapporterer gjeldende vær for en valgt by

La oss prøve å skrive en bot som ber om værdata.

Logikken i arbeidet vil være som følger. I utgangspunktet av teamet /start du kaller hovedtastaturet, som bare har én "Vær"-knapp. Ved å klikke på denne knappen vil du motta en melding med det innebygde tastaturet for å velge byen du vil finne ut gjeldende vær for. Velg en av byene og få gjeldende vær.

I dette kodeeksemplet vil vi bruke flere tilleggspakker:

httr — en pakke for arbeid med HTTP-forespørsler, på grunnlag av hvilken arbeid med ethvert API bygges. I vårt tilfelle vil vi bruke gratis API openweathermap.org.
stringr — en pakke for arbeid med tekst, i vårt tilfelle vil vi bruke den til å generere en melding om været i den valgte byen.

Kode 4: En robot som rapporterer gjeldende vær for den valgte byen

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

Kjør kodeeksemplet ovenfor, etter å ha erstattet 'DIN BOTTOKEN' med den virkelige tokenen du mottok da du opprettet boten via BotFader (Jeg snakket om å lage en bot i første artikkel).

Som et resultat vil boten vår fungere omtrent slik:

Skjematisk kan denne boten avbildes slik:

Vi har laget 3 metoder tilgjengelig i værboten vår:

Begynn — Start bot-tastaturet
vær — Start innebygd tastatur for å velge en by
svar_cb — Hovedmetoden som ber om været fra API for en gitt by og sender det til chatten.

metode Begynn vi starter den med kommandoen /start, som implementeres av behandleren CommandHandler('start', start).

Å kjøre en metode vær vi laget et filter med samme navn:

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

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

}
)

Og vi kaller denne metoden med følgende meldingsbehandler: MessageHandler(weather, filters = MessageFilters$weather).

Og til slutt, vår hovedmetode svar_cb reagerer på å trykke på innebygde knapper, som implementeres av en spesiell behandler: CallbackQueryHandler(answer_cb).

Inne i en metode svar_cb, leser vi dataene sendt fra tastaturet og skriver dem til en variabel city: city <- update$callback_query$data. Deretter ber vi om værdata fra API, genererer og sender en melding, og til slutt bruker vi metoden answerCallbackQuery for å informere boten om at vi behandlet klikket på Inline-knappen.

Et eksempel på en bot som viser en liste over de nyeste artiklene med lenker til den angitte Hub fra www.habr.com.

Jeg presenterer denne boten for å vise deg hvordan du viser innebygde knapper som fører til nettsider.

Logikken til denne boten er lik den forrige; til å begynne med starter vi hovedtastaturet med kommandoen /start. Deretter gir boten oss en liste over 6 huber å velge mellom, vi velger huben vi er interessert i, og mottar de 5 siste publikasjonene fra den valgte Huben.

Som du forstår, i dette tilfellet må vi få en liste over artikler, og for dette vil vi bruke en spesiell pakke habR, som lar deg be om artikler fra Habra og litt statistikk om dem i R.

Installer pakken habR kun mulig fra github, som du trenger en ekstra pakke for devtools. For å installere, bruk koden nedenfor.

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

La oss nå se på koden for å bygge boten beskrevet ovenfor:

Kode 5: En bot som viser en liste over de nyeste artiklene på den valgte 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()

Kjør kodeeksemplet ovenfor, etter å ha erstattet 'DIN BOTTOKEN' med den virkelige tokenen du mottok da du opprettet boten via BotFader (Jeg snakket om å lage en bot i første artikkel).

Som et resultat vil vi få dette resultatet:

Vi har hardkodet listen over Hubs tilgjengelig for valg i metoden 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)
}

Vi får en liste over artikler fra den angitte Hub med kommandoen habr_hub_posts(), fra pakken habR. Samtidig gjør vi oppmerksom på at vi ikke trenger en artikkelliste for hele tiden, men kun den første siden som 20 artikler ligger på. Fra den resulterende tabellen ved å bruke kommandoen head() Vi forlater bare topp 5, som er de nyeste artiklene.

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

Logikken er veldig lik den forrige boten, men i dette tilfellet genererer vi et innebygd tastatur med en liste over artikler dynamisk ved å bruke funksjonen lapply().

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

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

Vi setter inn tittelen på artikkelen i knappeteksten posts$title[x], og i argumentasjonen url link til artikkelen: url = posts$link[x].

Deretter lager vi et filter, behandlere og starter vår bot.

Konklusjon

Nå vil robotene du skriver være mye mer praktisk å bruke, på grunn av det faktum at de vil bli kontrollert fra tastaturet, i stedet for ved å skrive inn kommandoer. Som et minimum, når du samhandler med en bot via en smarttelefon, vil tastaturet forenkle prosessen med å bruke det betydelig.

I den neste artikkelen vil vi finne ut hvordan du bygger en logisk dialog med en bot og jobber med databaser.

Kilde: www.habr.com

Skrive en telegram-bot i R (del 3): Hvordan legge til tastaturstøtte til en bot

Alle artikler fra serien "Skrive en telegram-bot i R"

Innhold

Hvilke typer tastaturer støtter telegramboten?

Svartastatur

Innebygd tastatur

Et eksempel på en enkel bot med støtte for InLine-knapper

Et eksempel på en bot som rapporterer gjeldende vær for en valgt by

Et eksempel på en bot som viser en liste over de nyeste artiklene med lenker til den angitte Hub fra www.habr.com.

Konklusjon

Legg til en kommentar Avbryt svar