Dette er den tredje artikel i serien "Vi skriver en telegram-bot i R". I de tidligere publikationer har vi lært at oprette en telegram-bot, sende beskeder gennem den, og vi har tilføjet kommandoer og beskedfiltre til botten. Derfor anbefaler jeg stærkt at du sætter dig ind i , da jeg her ikke vil stoppe op ved de tidligere grundlæggende begreber inden for bot-udvikling.
I denne artikel vil vi forbedre brugervenligheden af vores bot ved at tilføje et tastatur, som gør bot-interfacet intuitivt og nemt at bruge.
Alle artikler i serien "Vi skriver en telegram-bot i R"
Indhold
Hvis du er interesseret i dataanalyse, kan mine og kanaler være interessante. Størstedelen af indholdet er dedikeret til R-sprog.
3.1.
3.2.
3.3.
Hvilke typer tastaturer understøtter telegram-botten
På tidspunktet for skrivningen af artiklen telegram.bot giver dig mulighed for at oprette tastaturer af to typer:
- Reply — Den primære, standard tastatur, der ligger under tekstindgangspanelet. Dette tastatur sender blot en tekstbesked til botten, og sender som tekst den tekst, der står på knappen.
- Inline — Tastaturet er knyttet til et specifikt besked fra botten. Dette tastatur sender data til botten, der er knyttet til den knap, der trykkes, disse data kan adskille sig fra teksten på selve knappen. Disse knapper behandles via CallbackQueryHandler.
For at botten kan åbne tastaturet, skal den ved afsendelse af beskeder gennem metoden sendMessage(), overføre det tidligere oprettede tastatur som argumentet reply_markup.
Nedenfor vil vi gennemgå flere eksempler.
Reply tastatur
Som jeg nævnte tidligere, er dette det primære kontroltastatur for botten.
Eksempel på oprettelse af et Reply tastatur fra den officielle dokumentation
bot <- Bot(token = "TOKEN")
chat_id <- "CHAT_ID"
# Opret brugerdefineret tastatur
text <- "Er de ikke fede, de brugerdefinerede tastaturer?"
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Ja, de er bestemt!")),
list(KeyboardButton("Jeg er ikke helt sikker")),
list(KeyboardButton("Nej..."))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# Send brugerdefineret tastatur
bot$sendMessage(chat_id, text, reply_markup = RKM)Ovenfor er et eksempel fra den officielle dokumentation for pakken telegram.bot. For at oprette et tastatur benyttes funktionen ReplyKeyboardMarkup(), som igen tager en liste af lister med knapper, der oprettes af funktionen KeyboardButton().
Hvorfor er det ReplyKeyboardMarkup() nødvendigt at sende ikke bare en liste, men en liste af lister? Det skyldes, at du sender den primære liste, og i den angiver du hver række knapper som separate lister, eftersom flere knapper kan være placeret i én række.
Argumentet resize_keyboard tillader automatisk at finde den optimale størrelse på knapperne på tastaturet, mens argumentet one_time_keyboard giver mulighed for at skjule tastaturet efter hvert tryk på en knap.
Lad os skrive en simpel bot, der har 3 knapper:
- Chat ID — Anmod om chat ID for dialogen med botten
- Mit navn — Anmod om dit navn
- Mit brugernavn — Anmod om dit brugernavn i Telegram
Kode 1: Enkel bot med Reply-tastatur
library(telegram.bot)
# opretter en instans af klassen Updater
updater <- Updater('DIN BOT TOKEN')
# opretter metoder
## metode til at starte tastaturet
start <- function(bot, update) {
# opretter tastaturet
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Chat ID")),
list(KeyboardButton("Mit navn")),
list(KeyboardButton("Mit brugernavn"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# sender tastaturet
bot$sendMessage(update$message$chat_id,
text = 'Vælg en kommando',
reply_markup = RKM)
}
## metode til at returnere chat id
chat_id <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Chat id for denne dialog: ", update$message$chat_id),
parse_mode = "Markdown")
}
## metode til at returnere navn
my_name <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Du hedder ", update$message$from$first_name),
parse_mode = "Markdown")
}
## metode til at returnere brugernavn
my_username <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Dit brugernavn er ", update$message$from$username),
parse_mode = "Markdown")
}
# opretter filtre
## beskeder med teksten Chat ID
MessageFilters$chat_id <- BaseFilter(function(message) {
# tjekker beskedens tekst
message$text == "Chat ID"
}
)
## beskeder med teksten Mit navn
MessageFilters$name <- BaseFilter(function(message) {
# tjekker beskedens tekst
message$text == "Mit navn"
}
)
## beskeder med teksten Mit brugernavn
MessageFilters$username <- BaseFilter(function(message) {
# tjekker beskedens tekst
message$text == "Mit brugernavn"
)
# opretter behandlere
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)
# tilføjer behandlere til dispatcher
updater <- updater +
h_start +
h_chat_id +
h_name +
h_username
# starter botten
updater$start_polling()Kør ovenstående kodeeksempel, efter at have erstattet ‘DIN BOTS TOKEN’ med den faktiske token, du fik, da du oprettede botten gennem BotFather (jeg har fortalt om oprettelsen af botten i ).
Efter at have startet, skal du give botten kommandoen /start, da det er den, vi har defineret til at starte tastaturet.
Hvis du i øjeblikket har svært ved at forstå det viste kodeeksempel med oprettelse af metoder, filtre og behandlere, bør du gå tilbage til den tidligere , hvor jeg detaljeret beskrev alt dette.
Vi har oprettet 4 metoder:
- start — Starter tastaturet
- chat_id — Anmoder om chat-id
- my_name — Anmoder om dit navn
- my_username — Anmoder om dit brugernavn
I objektet MessageFilters tilføjede vi 3 beskedfiltre baseret på deres tekst:
- chat_id — Beskeder med teksten
"Chat ID" - name — Beskeder med teksten
"Mit navn" - username — Beskeder med teksten
"Mit brugernavn"
Og vi oprettede 4 behandlere, som vil udføre de angivne metoder baseret på de givne kommandoer og filtre.
# создаём обработчики
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 oprettes inden for metoden start() med kommandoen ReplyKeyboardMarkup().
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Chat ID")),
list(KeyboardButton("Mit navn")),
list(KeyboardButton("Min login"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)I vores tilfælde har vi placeret alle knapperne under hinanden, men vi kan placere dem i ét rækkefølge ved at ændre listen af knapper. Da en række inden for tastaturet oprettes gennem en indlejret liste af knapper, skal vi for at få vores knapper i én række omskrive en del af koden til opbygning af tastaturet således:
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Chat ID"),
KeyboardButton("Mit navn"),
KeyboardButton("Min login")
)
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
Tastaturet sendes til chatten med metoden sendMessage(), i argumentet reply_markup.
bot$sendMessage(update$message$chat_id,
text = 'Vælg en kommando',
reply_markup = RKM)Inline tastatur
Som nævnt tidligere er Inline tastaturet bundet til en bestemt besked. Det er noget mere komplekst at arbejde med end det primære tastatur.
Først skal du tilføje botten metoden til at kalde Inline tastaturet.
For at svare på tryk på Inline knappen kan du også bruge botten metoden answerCallbackQuery(), som kan vise en meddelelse i telegramgrænsefladen til brugeren, der har trykket på Inline knappen.
Data sendt fra Inline knappen er ikke tekst, så for at behandle dem skal du oprette en særlig behandler ved hjælp af kommandoen CallbackQueryHandler().
Koden til opbygning af Inline tastaturet, som findes i den officielle dokumentation for pakken telegram.bot.
Koden til opbygning af Inline tastaturet fra den officielle dokumentation
# 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)Opbyg Inline tastaturet skal gøres med kommandoen InlineKeyboardMarkup(), på samme måde som Reply tastaturet. I InlineKeyboardMarkup() skal en liste over lister med Inline knapper gives, hver enkelt knap oprettes med funktionen InlineKeyboardButton().
En Inline knap kan enten sende nogle data til botten via argumentet callback_data, eller åbne en slags HTML-side angivet med argumentet url.
Som et resultat vil der være en liste, hvor hvert element også er en liste af Inline knapper, som skal samles i én række.
Dernæst vil vi se på nogle eksempler på bots med Inline knapper.
Eksempel på en simpel bot med støtte for Inline-knapper
For at begynde vil vi skrive en bot til hurtig test for covid-19. Ved kommandoen /test, han vil sende dig et tastatur med to knapper, afhængigt af hvilken knap der trykkes, vil han sende dig en besked med resultaterne af din test.
Kode 2: Den simpleste bot med Inline tastatur
library(telegram.bot)
# Opretter en instans af klassen Updater
updater <- Updater('DIN BOTS TOKEN')
# Metode til at sende InLine tastatur
test <- function(bot, update) {
# Opretter InLine tastaturet
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton("Ja", callback_data = 'yes'),
InlineKeyboardButton("Nej", callback_data = 'no')
)
)
)
# Sender tastaturet til chatten
bot$sendMessage(update$message$chat_id,
text = "Har du COVID-19?",
reply_markup = IKM)
}
# Metode til at behandle knaptryk
answer_cb <- function(bot, update) {
# Modtagne data fra knappen
data <- update$callback_query$data
# Få brugerens navn, der trykkede på knappen
uname <- update$effective_user()$first_name
# Behandling af resultat
if (data == 'no') {
msg <- paste0(uname, ", tillykke, din covid-19 test er negativ.")
} else {
msg <- paste0(uname, ", desværre er din covid-19 test positiv.")
}
# Sender besked
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# Informerer botten om, at anmodningen fra knappen er godkendt
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# Opretter håndtere
inline_h <- CommandHandler('test', test)
query_handler <- CallbackQueryHandler(answer_cb)
# Tilføjer håndtere til dispatcher
updater <- updater + inline_h + query_handler
# Starter botten
updater$start_polling()Kør ovenstående kodeeksempel, efter at have erstattet ‘DIN BOTS TOKEN’ med den faktiske token, du fik, da du oprettede botten gennem BotFather (jeg har fortalt om oprettelsen af botten i ).
Resultat:
Vi har oprettet to metoder:
- test — Til at sende Inline tastatur til chatten
- answer_cb — Til at behandle data sendt fra tastaturet.
Dataene, der sendes med hver knap, angives i argumentet callback_data, når knappen oprettes. Data sendt fra knappen kan hentes med konstruktionen update$callback_query$data, inden for metoden answer_cb.
For at botten reagerer på Inline tastaturet, behandles metoden answer_cb af en speciel håndterer: CallbackQueryHandler(answer_cb). Som kører den angivne metode ved tryk på Inline knappen. Håndtereren CallbackQueryHandler modtager to argumenter:
callback— Metoden der skal kørespattern— Filter for data, der er knyttet til knappen via argumentetcallback_data.
Som følge heraf kan vi ved hjælp af argumentet pattern skrive en separat metode for hver knaptryk:
Kode 3: Deler metoderne for hver Inline knap
library(telegram.bot)
# Opretter en instans af klassen Updater
updater <- Updater('DIN BOTS TOKEN')
# Metode til at sende en InLine-tastatur
test <- function(bot, update) {
# Opretter InLine-tastaturet
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton("Ja", callback_data = 'yes'),
InlineKeyboardButton("Nej", callback_data = 'no')
)
)
)
# Sender tastaturet til chatten
bot$sendMessage(update$message$chat_id,
text = "Har du COVID-19?",
reply_markup = IKM)
}
# Metode til at håndtere klik på Ja-knappen
answer_cb_yes <- function(bot, update) {
# Får brugernavnet på den, der trykkede på knappen
uname <- update$effective_user()$first_name
# Behandling af resultatet
msg <- paste0(uname, ", desværre, din test for covid-19 er positiv.")
# Sender besked
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# Informerer botten om, at anmodningen fra knappen er modtaget
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# Metode til at håndtere klik på Nej-knappen
answer_cb_no <- function(bot, update) {
# Får brugernavnet på den, der trykkede på knappen
uname <- update$effective_user()$first_name
msg <- paste0(uname, ", tillykke, din test for covid-19 er negativ.")
# Sender besked
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# Informerer botten om, at anmodningen fra knappen er modtaget
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# Opretter håndterere
inline_h <- CommandHandler('test', test)
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')
# Tilføjer håndterere til dispatcher
updater <- updater +
inline_h +
query_handler_yes +
query_handler_no
# Starter botten
updater$start_polling()Kør ovenstående kodeeksempel, efter at have erstattet ‘DIN BOTS TOKEN’ med den faktiske token, du fik, da du oprettede botten gennem BotFather (jeg har fortalt om oprettelsen af botten i ).
Nu har vi skrevet to separate metoder, dvs. en metode til at håndtere hver knap, og brugt argumentet pattern, da vi oprettede deres håndterere:
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')Koden for metoden slutter answer_cb med kommandoen bot$answerCallbackQuery(callback_query_id = update$callback_query$id), som informerer botten om, at dataene fra inline-tastaturet er modtaget.
Eksempel på en bot, der rapporterer vejret i den valgte by
Lad os prøve at skrive en bot, der anmoder om data om vejret.
Logikken i dens funktion vil være som følger. Oprindeligt kalder du med kommandoen /start hovedtastaturet, hvor der kun er en enkelt knap "Vejr". Når du trykker på denne knap, modtager du en besked med Inline-tastatur til valg af by, hvor du vil vide den aktuelle vejrforhold. Du vælger en af byerne og modtager den aktuelle vejr.
I dette kodeeksempel vil vi bruge flere ekstra pakker:
httr— en pakke til at arbejde med HTTP-anmodninger, som danner grundlaget for arbejdet med enhver API. I vores tilfælde vil vi bruge den gratis API .stringr— en pakke til tekstbehandling, som vi i dette tilfælde vil bruge til at formulere en vejrmelding for den valgte by.
Kode 4: En bot, der rapporterer den aktuelle vejrstatus for den valgte by
library(telegram.bot)
library(httr)
library(stringr)
# Opretter en instans af klassen Updater
updater <- Updater('DIN BOT TOKEN')
# Opretter metoder
## Metode til at starte hovedtastaturet
start <- function(bot, update) {
# Opretter tastaturet
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Vejr")
)
),
resize_keyboard = TRUE,
one_time_keyboard = TRUE
)
# Sender tastaturet
bot$sendMessage(update$message$chat_id,
text = 'Vælg en kommando',
reply_markup = RKM)
}
## Metode til at kalde Inline tastaturet
weather <- function(bot, update) {
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton(text = 'Moskva', callback_data = 'New York,us'),
InlineKeyboardButton(text = 'Sankt Petersborg', callback_data = 'Saint Petersburg'),
InlineKeyboardButton(text = 'New York', callback_data = 'New York')
),
list(
InlineKeyboardButton(text = 'Jekaterinburg', callback_data = 'Yekaterinburg,ru'),
InlineKeyboardButton(text = 'Berlin', callback_data = 'Berlin,de'),
InlineKeyboardButton(text = 'Paris', callback_data = 'Paris,fr')
),
list(
InlineKeyboardButton(text = 'Rom', callback_data = 'Rome,it'),
InlineKeyboardButton(text = 'Odessa', callback_data = 'Odessa,ua'),
InlineKeyboardButton(text = 'Kiev', 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')
)
)
)
# Send Inline Keyboard
bot$sendMessage(chat_id = update$message$chat_id,
text = "Vælg by",
reply_markup = IKM)
}
# Metode til at sende vejrmelding
answer_cb <- function(bot, update) {
# Henter byen fra beskeden
city <- update$callback_query$data
# Sender forespørgsel
ans <- GET('https://api.openweathermap.org/data/2.5/weather',
query = list(q = city,
lang = 'da',
units = 'metric',
appid = '4776568ccea136ffe4cda9f1969af340'))
# Parser svar
result <- content(ans)
# Danner besked
msg <- str_glue("{result$name} vejr:n",
"Aktuel temperatur: {result$main$temp}n",
"Vindhastighed: {result$wind$speed}n",
"Beskrivelse: {result$weather[[1]]$description}")
# Sender vejinformation
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# Opretter filtre
## Beskeder med teksten Vejr
MessageFilters$weather <- BaseFilter(function(message) {
# Tjekker beskedens tekst
message$text == "Vejr"
}
)
# Opretter håndterere
h_start <- CommandHandler('start', start)
h_weather <- MessageHandler(weather, filters = MessageFilters$weather)
h_query_handler <- CallbackQueryHandler(answer_cb)
# Tilføjer håndterere til dispatcher
updater <- updater +
h_start +
h_weather +
h_query_handler
# Starter botten
updater$start_polling()Kør ovenstående kodeeksempel, efter at have erstattet ‘DIN BOTS TOKEN’ med den faktiske token, du fik, da du oprettede botten gennem BotFather (jeg har fortalt om oprettelsen af botten i ).
Som resultat vil vores bot fungere cirka sådan her:
Schematic kan denne bot skitseres sådan her:
Vi har oprettet 3 metoder, der er tilgængelige inden for vores vejrbot:
- start — Start af botens hovedtastatur
- weather — Start af Inline-tastatur til valg af by
- answer_cb — Hovedmetoden, der for den angivne by henter vejret fra API'et og sender det til chatten.
Metoden start Vi starter med kommandoen /start, hvilket er realiseret af håndtereren CommandHandler('start', start).
For at starte metoden weather har vi oprettet en tilsvarende filter:
# создаём фильтры
## сообщения с текстом Погода
MessageFilters$weather <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Погода"
}
)Og vi kalder denne metode med den følgende beskedbehandler: MessageHandler(weather, filters = MessageFilters$weather).
Til slut reagerer vores hovedmetode answer_cb på tryk på Inline-knapperne, hvilket er realiseret af en speciel håndterer: CallbackQueryHandler(answer_cb).
Inde i metoden answer_cb, læser vi de data, der er sendt fra tastaturet, og gemmer dem i variablen city: city <- update$callback_query$data. Derefter anmoder vi API'et om vejrinformation, danner og sender en besked, og til sidst bruger vi metoden answerCallbackQuery for at informere botten om, at vi har behandlet trykket på Inline-knappen.
Et eksempel på en bot, der viser en liste over de nyeste artikler med links til den angivne Hub fra .
Denne bot viser, hvordan man kan vise Inline-knapper, der fører til hjemmesider.
Logikken i denne bot ligner den tidligere; vi starter først hovedtastaturet med kommandoen /start. Derefter giver botten os en liste over 6 hubs at vælge imellem. Vi vælger den relevante hub og får de 5 nyeste indlæg fra den valgte Hub.
Som I forstår, har vi i dette tilfælde brug for at hente en liste over artikler, og for det vil vi bruge den specielle pakke habR, som gør det muligt at anmode om artikler fra Habr og nogle statistikker om dem i R.
Pakken habR kan kun installeres fra github, så I har brug for en ekstra pakke devtools. For installationen kan I bruge den kode, der er nævnt nedenfor.
install.packages('devtools')
devtools::install_github('selesnow/habR')Lad os nu se på koden til opbygningen af den ovenfor beskrevne bot:
Kode 5: Bot der viser en liste over de mest friske artikler fra den valgte Hub
library(telegram.bot)
library(habR)
# Opretter en instans af klassen Updater
updater <- Updater('DIN BOTS TOKEN')
# Opretter metoder
## metode til at starte hovedtastaturet
start <- function(bot, update) {
# Opretter tastatur
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Liste over artikler")
)
),
resize_keyboard = TRUE,
one_time_keyboard = TRUE
)
# Sender tastaturet
bot$sendMessage(update$message$chat_id,
text = 'Vælg en kommando',
reply_markup = RKM)
}
## Metode til at kalde Inline tastaturet
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 = 'Data Visualisering', callback_data = 'data_visualization')
)
)
)
# Send Inline Tastatur
bot$sendMessage(chat_id = update$message$chat_id,
text = "Vælg Hub",
reply_markup = IKM)
}
# Metode til at svare med vejret
answer_cb <- function(bot, update) {
# Henter byen fra beskeden
hub <- update$callback_query$data
# Besked om at data er modtaget via knappen
bot$answerCallbackQuery(callback_query_id = update$callback_query$id,
text = 'Vent et øjeblik, forespørgslen behandles')
# Besked om, at vi skal vente, mens botten får data
mid <- bot$sendMessage(chat_id = update$from_chat_id(),
text = "Vent et par minutter, mens jeg samler data om den valgte Hub")
# Parser Habr
posts <- head(habr_hub_posts(hub, 1), 5)
# Sletter beskeden om, at vi skal vente
bot$deleteMessage(update$from_chat_id(), mid$message_id)
# Udformer listen af knapper
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# Udformer tastaturet
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)
# Sender information om vejret
bot$sendMessage(chat_id = update$from_chat_id(),
text = paste0("5 nyeste artikler fra Huben ", hub),
reply_markup = IKM)
}
# Opretter filtre
## Beskeder med teksten Vejret
MessageFilters$hubs <- BaseFilter(function(message) {
# Tjekker tekstbeskeden
message$text == "Liste over artikler"
}
)
# Opretter håndterere
h_start <- CommandHandler('start', start)
h_hubs <- MessageHandler(habs, filters = MessageFilters$hubs)
h_query_handler <- CallbackQueryHandler(answer_cb)
# Tilføjer håndterere til dispatcher
updater <- updater +
h_start +
h_hubs +
h_query_handler
# Starter botten
updater$start_polling()Kør ovenstående kodeeksempel, efter at have erstattet ‘DIN BOTS TOKEN’ med den faktiske token, du fik, da du oprettede botten gennem BotFather (jeg har fortalt om oprettelsen af botten i ).
Som resultat får vi følgende resultat:
Listen tilgængelige Hub'er, vi har hårdkodet 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)
}Listen over artikler fra den angivne Hub får vi med kommandoen habr_hub_posts(), fra pakken habR. Vi angiver, at vi ikke har brug for listen over artikler fra hele perioden, men kun den første side, hvor der er 20 artikler. Fra den opnåede tabel bruger vi kommandoen head() og beholder kun de 5 øverste, som er de nyeste artikler.
# парсим Хабр
posts <- head(habr_hub_posts(hub, 1), 5)Logikken ligner meget den tidligere bot, men i dette tilfælde genererer vi Inline-tastaturet med listen over artikler dynamisk ved hjælp af funktionen lapply().
# формируем список кнопок
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# формируем клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)Vi indsætter titlen på artiklen i knapteksten posts$title[x], og argumentet url linken til artiklen: url = posts$link[x].
Dernæst opretter vi filter, håndteringsprogrammer og starter vores bot.
Konklusion
Nu vil de bots, du har skrevet, være betydeligt lettere at arbejde med, da styringen af dem vil ske via tastaturet og ikke ved indtastning af kommandoer. I det mindste vil tastaturet i interaktionen med botten via smartphone tydeligt forenkle brugsprocessen.
I den næste artikel vil vi undersøge, hvordan man opbygger en logisk dialog med botten og arbejder med databaser.
Kilde: habr.com
