Detta Àr den tredje artikeln i serien "Skriver en Telegram-bot pÄ R". I tidigare inlÀgg lÀrde vi oss att skapa en Telegram-bot, skicka meddelanden genom den, lÀgga till kommandon och meddelandefilter. Innan du börjar lÀsa denna artikel rekommenderar jag starkt att du bekantar dig med , eftersom jag inte kommer att stanna vid de tidigare grunderna för botutveckling.
I den hÀr artikeln ökar vi anvÀndarvÀnligheten för vÄr bot genom att lÀgga till ett tangentbord, vilket gör botens grÀnssnitt intuitivt och enkelt att anvÀnda.
Alla artiklar i serien "Skriver en Telegram-bot pÄ R"
InnehÄll
Om du Àr intresserad av dataanalys kan du vara intresserad av mina och kanaler. Största delen av innehÄllet handlar om R-sprÄket.
3.1.
3.2.
3.3.
Vilka typer av tangentbord stöder Telegram-boten
Vid tidpunkten för skrivandet av artikeln telegram.bot lÄter dig skapa tangentbord av tvÄ typer:
- Reply â Huvud-, vanlig tangentbord som ligger under textrutan för meddelanden. Detta tangentbord skickar helt enkelt ett textmeddelande till boten, och texten som skickas Ă€r den text som stĂ„r pĂ„ knappen.
- Inline â Tangentbord kopplat till ett specifikt meddelande frĂ„n boten. Detta tangentbord skickar data kopplad till den tryckta knappen till boten, och dessa data kan skilja sig frĂ„n texten som stĂ„r pĂ„ knappen. Och sĂ„dana knappar hanteras genom CallbackQueryHandler.
För att boten ska öppna tangentbordet mÄste du vid sÀndning av meddelande genom metoden sendMessage(), skicka det tidigare skapade tangentbordet som ett argument reply_markup.
Nedan gÄr vi igenom nÄgra exempel.
Reply-tangentbord
Som jag nÀmnde tidigare Àr detta huvudtangentbordet för att styra boten.
Exempel pÄ hur man skapar ett Reply-tangentbord frÄn den officiella dokumentationen
bot <- Bot(token = "TOKEN")
chat_id <- "CHAT_ID"
# Skapa anpassat tangentbord
text <- "Ăr inte de dĂ€r anpassade tangentborden hĂ€ftiga?"
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Ja, det Àr de verkligen!")),
list(KeyboardButton("Jag Àr inte helt sÀker")),
list(KeyboardButton("Nej..."))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# Skicka anpassat tangentbord
bot$sendMessage(chat_id, text, reply_markup = RKM)Ovan Àr ett exempel frÄn den officiella dokumentationen för paketet telegram.bot. För att skapa tangentbordet anvÀnds funktionen ReplyKeyboardMarkup(), som i sin tur tar en lista av listor av knappar som skapas av funktionen KeyboardButton().
Varför i ReplyKeyboardMarkup() mÄste man skicka en lista av listor och inte bara en lista? Anledningen Àr att du skickar huvudlistan, och i den anger du varje rad av knappar som separata listor, eftersom flera knappar kan placeras i en rad.
Argumentet resize_keyboard möjliggör automatiskt val av optimal storlek pÄ knapparna pÄ tangentbordet, medan argumentet one_time_keyboard gör att tangentbordet döljs efter varje knapptryckning.
LĂ„t oss skriva en enkel bot med 3 knappar:
- Chatt ID â Be om chatt-ID för dialogen med botten
- Mitt namn â Be om mitt namn
- Mitt anvĂ€ndarnamn â Be om mitt anvĂ€ndarnamn i Telegram
Kod 1: Enkel bot med svarstangentbord
library(telegram.bot)
# Skapa en instans av klassen Updater
updater <- Updater('DINA BOT TOKEN')
# Skapa metoder
## metod för att starta tangentbordet
start <- function(bot, update) {
# Skapa tangentbordet
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Chat ID")),
list(KeyboardButton("Mitt namn")),
list(KeyboardButton("Min anvÀndarnamn"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# Skicka tangentbordet
bot$sendMessage(update$message$chat_id,
text = 'VĂ€lj ett kommando',
reply_markup = RKM)
}
## metod som returnerar chat-id
chat_id <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Chat id för denna dialog: ", update$message$chat_id),
parse_mode = "Markdown")
}
## metod som returnerar namn
my_name <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Ditt namn Àr ", update$message$from$first_name),
parse_mode = "Markdown")
}
## metod som returnerar anvÀndarnamn
my_username <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Ditt anvÀndarnamn ", update$message$from$username),
parse_mode = "Markdown")
}
# Skapa filter
## meddelanden med texten Chat ID
MessageFilters$chat_id <- BaseFilter(function(message) {
# Kontrollera meddelandets text
message$text == "Chat ID"
}
)
## meddelanden med texten Mitt namn
MessageFilters$name <- BaseFilter(function(message) {
# Kontrollera meddelandets text
message$text == "Mitt namn"
}
)
## meddelanden med texten Min anvÀndarnamn
MessageFilters$username <- BaseFilter(function(message) {
# Kontrollera meddelandets text
message$text == "Min anvÀndarnamn"
)
# Skapa hanterare
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)
# LĂ€gg till hanterare i uppdateraren
updater <- updater +
h_start +
h_chat_id +
h_name +
h_username
# Starta boten
updater$start_polling()Kör koden ovan efter att ha bytt ut âDINA BOT TOKENâ mot den verkliga token som du fick nĂ€r du skapade boten via BotFather (jag beskrev hur man skapar en bot i ).
NÀr boten har startat, ge den kommandot /start, eftersom det Àr det vi definierade för att starta tangentbordet.
Om du har svÄrt att förstÄ det givna kodexemplet med att skapa metoder, filter och hanterare, bör du ÄtergÄ till den tidigare , dÀr jag beskrev allt detta i detalj.
Vi har skapat 4 metoder:
- start â Starta tangentbordet
- chat_id â BegĂ€r chat-id
- my_name â BegĂ€r ditt namn
- my_username â BegĂ€r ditt anvĂ€ndarnamn
I objektet MessageFilters la vi till 3 meddelandefilter, baserat pÄ deras text:
- chat_id â Meddelanden med text
"Chatt-ID" - name â Meddelanden med text
"Mitt namn" - username â Meddelanden med text
"Mitt anvÀndarnamn"
Och fyra hanterare har skapats som kommer att utföra de angivna metoderna baserat pÄ givna kommandon och filter.
# ŃĐŸĐ·ĐŽĐ°ŃĐŒ ĐŸĐ±ŃĐ°Đ±ĐŸŃŃĐžĐșĐž
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)SjÀlva tangentbordet skapas inuti metoden start() med kommandot ReplyKeyboardMarkup().
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Chatt-ID")),
list(KeyboardButton("Mitt namn")),
list(KeyboardButton("Mitt anvÀndarnamn"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)I vÄrt fall har vi placerat alla knappar under varandra, men vi kan ocksÄ placera dem i en rad genom att Àndra listan av listor med knappar. Eftersom en rad i tangentbordet skapas genom en inre lista med knappar, mÄste vi skriva om en del av koden för att bygga tangentbordet pÄ följande sÀtt:
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Chatt-ID"),
KeyboardButton("Mitt namn"),
KeyboardButton("Mitt anvÀndarnamn")
)
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
Tangentbordet skickas till chatten med metoden sendMessage(), i argumentet reply_markup.
bot$sendMessage(update$message$chat_id,
text = 'VĂ€lj kommando',
reply_markup = RKM)Inline-tangentbord
Som jag nÀmnde tidigare Àr Inline-tangentbordet kopplat till ett specifikt meddelande. Att arbeta med det Àr lite mer komplicerat Àn med huvudtangentbordet.
Först mÄste du lÀgga till en metod i boten för att anropa Inline-tangentbordet.
För att svara pÄ tryckningen av Inline-knappen kan du ocksÄ anvÀnda botens metod answerCallbackQuery(), som kan visa ett meddelande i grÀnsnittet pÄ telegram till anvÀndaren som tryckte pÄ Inline-knappen.
Data som skickas med Inline-knappen Àr inte text, sÄ för att bearbeta dem mÄste du skapa en speciell hanterare med hjÀlp av kommandot CallbackQueryHandler().
Koden för att bygga Inline-tangentbordet som ges i den officiella dokumentationen för paketet telegram.bot.
Koden för att bygga Inline-tangentbordet frÄn den officiella dokumentationen
# 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-tangentbordet mÄste byggas med hjÀlp av kommandot InlineKeyboardMarkup(), pÄ samma sÀtt som Reply-tangentbordet. I InlineKeyboardMarkup() mÄste en lista av listor med Inline-knappar överlÀmnas, varje enskild knapp skapas med hjÀlp av funktionen InlineKeyboardButton().
Inline-knappen kan antingen skicka data till boten med hjÀlp av argumentet callback_data, eller öppna en HTML-sida som angivits med hjÀlp av argumentet url.
Som ett resultat kommer det att bli en lista, dÀr varje element ocksÄ Àr en lista av Inline-knappar som behöver sammanfoga i en rad.
Vi kommer nu att titta pÄ nÄgra exempel pÄ bots med inline-knappar.
Exempel pÄ den enklaste boten med stöd för inline-knappar
Först kommer vi att skriva en bot för express-testning av covid-19. Vid kommandot /test, kommer den att skicka en tangentbord med tvÄ knappar, beroende pÄ vilken knapp som trycks pÄ kommer den att skicka ett meddelande med resultaten frÄn ditt test.
Kod 2: Enkelt bot med inline-tangentbord
library(telegram.bot)
# skapar en instans av klassen Updater
updater <- Updater('DIN BOTS TOKEN')
# metod för att skicka Inline-tangentbord
test <- function(bot, update) {
# skapar Inline-tangentbord
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton("Ja", callback_data = 'yes'),
InlineKeyboardButton("Nej", callback_data = 'no')
)
)
)
# Skicka tangentbordet till chatten
bot$sendMessage(update$message$chat_id,
text = "Ăr du sjuk i coronaviruset?",
reply_markup = IKM)
}
# metod för att hantera knapptryckning
answer_cb <- function(bot, update) {
# de mottagna data frÄn knappen
data <- update$callback_query$data
# fÄ anvÀndarnamnet för den som tryckte pÄ knappen
uname <- update$effective_user()$first_name
# bearbetning av resultatet
if ( data == 'no' ) {
msg <- paste0(uname, ", grattis, ditt covid-19-test Àr negativt.")
} else {
msg <- paste0(uname, ", tyvÀrr, ditt covid-19-test Àr positivt.")
}
# Skicka meddelande
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# informera boten att begÀran frÄn knappen har tagits emot
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# skapar handlÀggare
inline_h <- CommandHandler('test', test)
query_handler <- CallbackQueryHandler(answer_cb)
# lÀgg till handlÀggare i dispatcher
updater <- updater + inline_h + query_handler
# starta boten
updater$start_polling()Kör koden ovan efter att ha bytt ut âDINA BOT TOKENâ mot den verkliga token som du fick nĂ€r du skapade boten via BotFather (jag beskrev hur man skapar en bot i ).
Resultatet:
Vi har skapat tvÄ metoder:
- test â För att skicka Inline-tangentbord till chatten
- answer_cb â För att bearbeta data skickade frĂ„n tangentbordet.
Data som skickas frÄn varje knapp anges i argumentet callback_data, nÀr knappen skapas. De data som skickas frÄn knappen kan erhÄllas med hjÀlp av konstruktionen update$callback_query$data, inuti metoden answer_cb.
För att boten ska reagera pÄ Inline-tangentbordet, hanteras metoden answer_cb av en speciell handlÀggare: CallbackQueryHandler(answer_cb). Den kör den angivna metoden vid tryckning pÄ Inline-knappen. HandlÀggaren CallbackQueryHandler tar emot tvÄ argument:
callbackâ Metod som mĂ„ste körasmönsterâ Filter för data som Ă€r kopplade till knappen med hjĂ€lp av argumentetcallback_data.
DÀrför kan vi med hjÀlp av argumentet mönster skriva en separat metod för varje knapptryckning:
Kod 3: Dela upp metoder för varje Inline-knapp
library(telegram.bot)
# skapar en instans av klassen Updater
updater <- Updater('DIN BOTS TOKEN')
# metod för att skicka InLine tangentbord
test <- function(bot, update) {
# skapar InLine tangentbord
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton("Ja", callback_data = 'yes'),
InlineKeyboardButton("Nej", callback_data = 'no')
)
)
)
# skickar tangentbordet till chatten
bot$sendMessage(update$message$chat_id,
text = "Har du covid-19?",
reply_markup = IKM)
}
# metod för att hantera tryck pÄ knappen Ja
answer_cb_yes <- function(bot, update) {
# fÄr anvÀndarnamnet frÄn den som tryckte pÄ knappen
uname <- update$effective_user()$first_name
# hantera resultatet
msg <- paste0(uname, ", tyvÀrr Àr ditt test för covid-19 positivt.")
# skicka meddelande
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# meddelar botten att förfrÄgan frÄn knappen har mottagits
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# metod för att hantera tryck pÄ knappen Nej
answer_cb_no <- function(bot, update) {
# fÄr anvÀndarnamnet frÄn den som tryckte pÄ knappen
uname <- update$effective_user()$first_name
msg <- paste0(uname, ", grattis, ditt test för covid-19 Àr negativt.")
# skicka meddelande
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# meddelar botten att förfrÄgan frÄn knappen har mottagits
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# skapar hanterare
inline_h <- CommandHandler('test', test)
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')
# lÀgger till hanterare i dispatchern
updater <- updater +
inline_h +
query_handler_yes +
query_handler_no
# startar botten
updater$start_polling()Kör koden ovan efter att ha bytt ut âDINA BOT TOKENâ mot den verkliga token som du fick nĂ€r du skapade boten via BotFather (jag beskrev hur man skapar en bot i ).
Nu har vi skrivit 2 separata metoder, det vill sÀga en metod för varje knapptryckning, och vi har anvÀnt argument mönster, nÀr vi skapade deras hanterare:
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')Koden för metoden avslutas answer_cb med kommandot bot$answerCallbackQuery(callback_query_id = update$callback_query$id), som meddelar botten att data frÄn inline-tangentbordet har mottagits.
Exempel pÄ en bot som rapporterar aktuellt vÀder för en vald stad
LÄt oss försöka skriva en bot som begÀr vÀderinformation.
Logiken för dess funktionssÀtt kommer att vara följande. Ursprungligen med kommandot /start Äker du till den huvudsakliga tangentbordet, dÀr det bara finns en knapp "VÀder". NÀr du trycker pÄ denna knapp fÄr du ett meddelande med ett Inline tangentbord för att vÀlja en stad vars aktuella vÀder du vill veta. Du vÀljer en av stÀderna och fÄr den aktuella vÀdret.
I det hÀr kodexemplet kommer vi att anvÀnda nÄgra ytterligare paket:
httrâ ett paket för att arbeta med HTTP-förfrĂ„gningar, pĂ„ vilka all API-funktionalitet bygger. I vĂ„rt fall kommer vi att anvĂ€nda det gratis API:et .stringrâ ett paket för att arbeta med text, i vĂ„rt fall kommer vi att anvĂ€nda det för att skapa ett meddelande om vĂ€dret i den valda staden.
Kod 4: En bot som rapporterar om det aktuella vÀdret i den valda staden
library(telegram.bot)
library(httr)
library(stringr)
# Skapa en instans av Updater-klassen
updater <- Updater('DIN BOTS TOKEN')
# Skapa metoder
## Metod för att starta huvudknappen
start <- function(bot, update) {
# Skapa tangentbordet
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("VĂ€der")
)
),
resize_keyboard = TRUE,
one_time_keyboard = TRUE
)
# Skicka tangentbordet
bot$sendMessage(update$message$chat_id,
text = 'VĂ€lj ett kommando',
reply_markup = RKM)
}
## Metod för att kalla Inline-tangentbordet
weather <- function(bot, update) {
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton(text = 'Moskva', callback_data = 'New York,us'),
InlineKeyboardButton(text = 'Sankt Petersburg', 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')
)
)
)
# Skicka Inline-tangentbord
bot$sendMessage(chat_id = update$message$chat_id,
text = "VĂ€lj en stad",
reply_markup = IKM)
}
# Metod för att skicka vÀdret
answer_cb <- function(bot, update) {
# HÀmta staden frÄn meddelandet
city <- update$callback_query$data
# Skicka begÀran
ans <- GET('https://api.openweathermap.org/data/2.5/weather',
query = list(q = city,
lang = 'ru',
units = 'metric',
appid = '4776568ccea136ffe4cda9f1969af340'))
# Parsar svaret
result <- content(ans)
# Skapa meddelandet
msg <- str_glue("{result$name} vÀder:n",
"Aktuell temperatur: {result$main$temp}n",
"Vindhastighet: {result$wind$speed}n",
"Beskrivning: {result$weather[[1]]$description}")
# Skicka vÀderinformationen
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# Skapa filter
## Meddelanden med texten VĂ€der
MessageFilters$weather <- BaseFilter(function(message) {
# Kontrollera meddelandets text
message$text == "VĂ€der"
})
# Skapa handhavare
h_start <- CommandHandler('start', start)
h_weather <- MessageHandler(weather, filters = MessageFilters$weather)
h_query_handler <- CallbackQueryHandler(answer_cb)
# LÀgg till handhavare till förvaltaren
updater <- updater +
h_start +
h_weather +
h_query_handler
# Starta boten
updater$start_polling()Kör koden ovan efter att ha bytt ut âDINA BOT TOKENâ mot den verkliga token som du fick nĂ€r du skapade boten via BotFather (jag beskrev hur man skapar en bot i ).
Som ett resultat kommer vÄr bot att fungera ungefÀr sÄ hÀr:
Schematiskt kan denna bot representeras sÄ hÀr:
Vi har skapat 3 metoder som Àr tillgÀngliga inom vÄr vÀderbot:
- start â Starta botens huvudmeny
- weather â Starta Inline-menyn för att vĂ€lja stad
- answer_cb â Huvudmetoden som för den angivna staden begĂ€r vĂ€dret frĂ„n API:et och skickar det till chatten.
Metod start startas av kommandot /start, vilket realiseras av handhavaren CommandHandler('start', start).
För att köra metoden weather har vi skapat en med samma namn filter:
# ŃĐŸĐ·ĐŽĐ°ŃĐŒ ŃОлŃŃŃŃ
## ŃĐŸĐŸĐ±ŃĐ”ĐœĐžŃ Ń ŃĐ”ĐșŃŃĐŸĐŒ ĐĐŸĐłĐŸĐŽĐ°
MessageFilters$weather <- BaseFilter(function(message) {
# ĐżŃĐŸĐČĐ”ŃŃĐ”ĐŒ ŃĐ”ĐșŃŃ ŃĐŸĐŸĐ±ŃĐ”ĐœĐžŃ
message$text == "ĐĐŸĐłĐŸĐŽĐ°"
}
)Och vi anropar denna metod med följande meddelandehandhavare: MessageHandler(weather, filters = MessageFilters$weather).
Och till sist, vÄr huvudmetod answer_cb reagerar pÄ tryckningar pÄ Inline-knappar, vilket realiseras av en speciell handhavare: CallbackQueryHandler(answer_cb).
Inom metoden answer_cb, lÀser vi de uppgifter som skickats frÄn tangentbordet och sparar dem i variabeln city: city <- update$callback_query$data. Efter det begÀr vi API-data om vÀdret, formar och skickar meddelande, och slutligen anvÀnder vi metoden answerCallbackQuery för att meddela boten att vi har behandlat tryckningen pÄ Inline-knappen.
Exempel pÄ en bot som visar en lista med de nyaste artiklarna med lÀnkar till den angivna Huben frÄn .
Jag ger detta exempel för att visa er hur man visar Inline-knappar som leder till webbsidor.
Logiken för denna bot liknar den tidigare, först startar vi huvudmenyn med kommandot /start. DÀrefter ger boten oss en lista med 6 hubar att vÀlja mellan, vi vÀljer den hub som intresserar oss, och fÄr de 5 nyaste publikationerna frÄn den valda Huben.
Som ni förstÄr Àr det i detta fall nödvÀndigt att fÄ en lista med artiklar, och för detta kommer vi att anvÀnda det speciella paketet habR, vilket gör det möjligt att begÀra artiklar frÄn Habr och viss statistik om dem i R.
Paketet habR kan endast installeras frÄn github, för vilket ni behöver det extra paketet devtools. För installation, anvÀnd koden nedan.
install.packages('devtools')
devtools::install_github('selesnow/habR')Nu ska vi titta pÄ koden för den ovan beskrivna boten:
Kod 5: En bot som visar en lista med de nyaste artiklarna för den valda Huben
library(telegram.bot)
library(habR)
# Skapar en instans av klassen Updater
updater <- Updater('DIN BOT-TOKEN')
# Skapar metoder
## Metod för att aktivera huvudknappsatsen
start <- function(bot, update) {
# Skapar knappsatsen
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Lista över artiklar")
)
),
resize_keyboard = TRUE,
one_time_keyboard = TRUE
)
# Skickar knappsatsen
bot$sendMessage(update$message$chat_id,
text = 'VĂ€lj kommando',
reply_markup = RKM)
}
## Metod för att aktivera Inline-knappsatsen
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 = 'Datavisualisering', callback_data = 'data_visualization')
)
)
)
# Skicka Inline-knappsats
bot$sendMessage(chat_id = update$message$chat_id,
text = "VĂ€lj Hubs",
reply_markup = IKM)
}
# Metod för vÀdermeddelande
answer_cb <- function(bot, update) {
# HÀmtar staden frÄn meddelandet
hub <- update$callback_query$data
# Meddelande om att data har mottagits genom knappen
bot$answerCallbackQuery(callback_query_id = update$callback_query$id,
text = 'VÀnta nÄgra minuter, förfrÄgan bearbetas')
# Meddelande om att vÀnta medan boten hÀmtar data
mid <- bot$sendMessage(chat_id = update$from_chat_id(),
text = "VÀnta nÄgra minuter medan jag samlar data om den valda Hubben")
# Parsar Habr
posts <- head(habr_hub_posts(hub, 1), 5)
# Tar bort meddelandet om att vÀnta
bot$deleteMessage(update$from_chat_id(), mid$message_id)
# Skapar lista med knappar
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# Skapar knappsats
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)
# Skickar information om vÀdret
bot$sendMessage(chat_id = update$from_chat_id(),
text = paste0("5 senaste artiklar frÄn Hubben ", hub),
reply_markup = IKM)
}
# Skapar filter
## Meddelande med texten VĂ€der
MessageFilters$hubs <- BaseFilter(function(message) {
# Kontrollerar meddelandets text
message$text == "Lista över artiklar"
}
)
# Skapar handlÀggare
h_start <- CommandHandler('start', start)
h_hubs <- MessageHandler(habs, filters = MessageFilters$hubs)
h_query_handler <- CallbackQueryHandler(answer_cb)
# LÀgger till handlÀggarna i förvaltaren
updater <- updater +
h_start +
h_hubs +
h_query_handler
# Startar boten
updater$start_polling()Kör koden ovan efter att ha bytt ut âDINA BOT TOKENâ mot den verkliga token som du fick nĂ€r du skapade boten via BotFather (jag beskrev hur man skapar en bot i ).
Resultatet vi fÄr kommer att se ut sÄ hÀr:
Listan över tillgÀngliga hubbar har vi hÄrdkodad 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)
}Listan över artiklar frÄn den angivna hubben fÄr vi med kommandot habr_hub_posts(), frÄn paketet habR. Vi anger att vi inte behöver listan över artiklar frÄn hela tiden, utan bara första sidan som innehÄller 20 artiklar. FrÄn den resulterande tabellen anvÀnder vi kommandot head() och behÄller endast de 5 högst placerade, som Àr de nyaste artiklarna.
# паŃŃĐžĐŒ ЄабŃ
posts <- head(habr_hub_posts(hub, 1), 5)Logiken Àr vÀldigt lik den tidigare boten, men i det hÀr fallet genererar vi inline-tangentbordet med artikelnumren dynamiskt med funktionen lapply().
# ŃĐŸŃĐŒĐžŃŃĐ”ĐŒ ŃпОŃĐŸĐș ĐșĐœĐŸĐżĐŸĐș
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# ŃĐŸŃĐŒĐžŃŃĐ”ĐŒ ĐșлаĐČОаŃŃŃŃ
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)I texten pÄ knappen sÀtter vi namnet pÄ artikeln posts$title[x], och som argument url lÀnken till artikeln: url = posts$link[x].
DÀrefter skapar vi en filter, hÀndelsehanterare och startar vÄr bot.
Slutsats
Nu kommer de bots som du har skrivit att vara mycket mer anvÀndarvÀnliga, eftersom de kommer att styras med tangentbordet snarare Àn genom att skriva kommandon. à tminstone vid interaktion med boten via smartphone kommer tangentbordet att förenkla anvÀndningen avsevÀrt.
I nÀsta artikel kommer vi att förstÄ hur man bygger en logisk dialog med boten och arbetar med databaser.
KĂ€lla: habr.com
