Ky është artikulli i tretë në serinë "Shkruajmë një bot telegram në gjuhën R". Në publikimet e mëparshme ne mësuam se si të krijojmë një bot telegram, të dërgojmë mesazhe përmes tij, shtuam komanda dhe filtre mesazhesh. Prandaj, para se të filloni të lexoni këtë artikull, ju rekomandoj shumë të njihni , pasi këtu unë nuk do të ndalem në bazat e ndërtimit të botëve që janë përshkruar më parë.
Në këtë artikull ne do të përmirësojmë përdorshmërinë e botit tonë përmes shtimit të një tastiere, e cila do ta bëjë ndërfaqen e botit intuitivisht të kuptueshme dhe të thjeshtë për t'u përdorur.
Të gjitha artikujt nga seria "Shkruajmë bota në telegram me gjuhën R"
Përmbajtja
Nëse jeni të interesuar për analizën e të dhënave, ndoshta do t'ju interesojnë kanalet e mia në dhe Shumica e përmbajtjes së të cilave i kushtohet gjuhës R.
3.1.
3.2.
3.3.
Cilat janë llojet e tastierave që mbështet boti telegram
Në momentin që po shkruhet ky artikull telegram.bot u jep mundësinë të krijoni tastiera të dy llojeve:
- Reply — Tastiera kryesore, e zakonshme që ndodhet nën panelin e hyrjes së mesazhit. Kjo tastierë thjesht dërgon një mesazh tekstual në bot, dhe si tekst do të dërgojë atë tekst që është shkruar në butonin e saj.
- Inline — Tastiera e lidhur me një mesazh të caktuar të botit. Kjo tastierë dërgon në bot të dhëna të lidhura me butonin e shtypur, këto të dhëna mund të duken ndryshe nga teksti i shkruar në butonin e saj. Dhe butonat e tillë përpunohen përmes CallbackQueryHandler.
Për të hapur tastierën e botit, është e nevojshme që kur dërgoni një mesazh përmes metodës sendMessage(), të kaloni tastierën e krijuar më parë në argumentin reply_markup.
Më poshtë ne do të shqyrtojmë disa shembuj.
Tastiera Reply
Siç kam shkruar më sipër, kjo është tastiera kryesore për menaxhimin e botit.
Shembulli i krijimit të tastierës Reply nga dokumentimi zyrtar
bot <- Bot(token = "TOKEN")
chat_id <- "CHAT_ID"
# Krijo Tastierën e Personalizuar
text <- "A nuk janë ato tastiera të personalizuara të bukura?"
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Po, padyshim!")),
list(KeyboardButton("Nuk jam shumë i sigurt")),
list(KeyboardButton("Jo..."))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# Dërgo Tastierën e Personalizuar
bot$sendMessage(chat_id, text, reply_markup = RKM)Më sipër është një shembull nga dokumentimi zyrtar i paketës telegram.bot. Për krijimin e tastierës përdoret funksioni ReplyKeyboardMarkup(), i cili nga ana e tij merr një listë listash butonash, të cilat krijohen nga funksioni KeyboardButton().
Pse në ReplyKeyboardMarkup() duhet të transmetoni jo thjesht një listë, por një listë listash? Çështja është se ju po dërgoni listën kryesore, dhe në të jepni listat e veçanta për secilën radhë butoni, sepse në një radhë mund të vendosen disa butona.
Argumenti resize_keyboard lejon përshtatjen automatike të madhësisë optimale të butonave të tastierës, dhe argumenti one_time_keyboard lejon fshehjen e tastierës pas çdo klikimi në buton.
Le të shkruajmë një bot të thjeshtë, i cili do të ketë 3 butona:
- Chat ID — Kërko Chat ID e bisedës me botin
- Emri im — Kërko emrin tënd
- Përdoruesi im — Kërko emrin tënd të përdoruesit në Telegram
Kodi 1: Bot i thjeshtë me tastierën Reply
library(telegram.bot)
# krijojmë një instancë të klasës Updater
updater <- Updater('TOKENI JUAJ I BOTIT')
# krijojmë metodat
## metoda për nisjen e tastierës
start <- function(bot, update) {
# krijojmë tastierën
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Chat ID")),
list(KeyboardButton("Emri im")),
list(KeyboardButton("Përdoruesi im"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
# dërgojmë tastierën
bot$sendMessage(update$message$chat_id,
text = 'Zgjidhni komandën',
reply_markup = RKM)
}
## metoda që kthen id-në e bisedës
chat_id <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Chat id i kësaj bisedë: ", update$message$chat_id),
parse_mode = "Markdown")
}
## metoda që kthen emrin
my_name <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Ju quani ", update$message$from$first_name),
parse_mode = "Markdown")
}
## metoda që kthen përdoruesin
my_username <- function(bot, update) {
bot$sendMessage(update$message$chat_id,
text = paste0("Përdoruesi juaj është ", update$message$from$username),
parse_mode = "Markdown")
}
# krijojmë filtrat
## mesazhet me tekstin Chat ID
MessageFilters$chat_id <- BaseFilter(function(message) {
# kontrollojmë tekstin e mesazhit
message$text == "Chat ID"
}
)
## mesazhet me tekstin Emri im
MessageFilters$name <- BaseFilter(function(message) {
# kontrollojmë tekstin e mesazhit
message$text == "Emri im"
}
)
## mesazhet me tekstin Përdoruesi im
MessageFilters$username <- BaseFilter(function(message) {
# kontrollojmë tekstin e mesazhit
message$text == "Përdoruesi im"
)
# krijojmë menaxherët
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)
# shtojmë menaxherët në dispatcher
updater <- updater +
h_start +
h_chat_id +
h_name +
h_username
# nisemi me botin
updater$start_polling()Ekzekutoni shembullin e kodit të mësipërm duke zëvendësuar ‘TOKENI JUAJ I BOTIT’ me tokenin e vërtetë që keni marrë gjatë krijimit të botit përmes BotFather (për krijimin e botit kam folur në ).
Pas nisjes, caktoni botit një komandë /start, sepse pikërisht atë e kemi përcaktuar për të nisur tastierën.
Nëse për momentin ju duket e vështirë të kuptoni shembullin e dhënë të kodit, me krijimin e metodave, filtrave dhe trajtuesve, duhet të ktheheni te e kaluara , ku e kam përshkruar gjithçka në detaje.
Ne krijuam 4 metoda:
- start — Nisja e tastierës
- chat_id — Kërkimi i identifikuesit të bisedës
- my_name — Kërkimi i emrit tënd
- my_username — Kërkimi i emrit tënd të përdoruesit
Në objekt MessageFilters shtuam 3 filtra mesazhesh, sipas tekstit të tyre:
- chat_id — Mesazhe me tekstin
"Chat ID" - name — Mesazhe me tekstin
"Emri im" - username — Mesazhe me tekstin
"Emri im i përdoruesit"
Dhe krijuam 4 trajtues, që sipas komandave dhe filtrave të vendosura do të ekzekutojnë metodat e specifikuara.
# создаём обработчики
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)Tastiera e vet është krijuar brenda metodës start() nëpërmjet komandës. ReplyKeyboardMarkup().
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Chat ID")),
list(KeyboardButton("Emri im")),
list(KeyboardButton("Emri im i përdoruesit"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)Në rastin tonë, të gjitha butonat i kemi vendosur njëri poshtë tjetrit, por mund t'i vendosim në një rresht, duke bërë ndryshime në listën e listave të butonave. Sepse një rresht brenda tastierës krijohet përmes një liste të brendshme butonash, për të përfaqësuar butonat tanë në një rresht, duhet të rishkruajmë një pjesë të kodit për ndërtimin e tastierës kështu:
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Chat ID"),
KeyboardButton("Emri im"),
KeyboardButton("Emri im i përdoruesit")
)
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
Tastiera dërgohet në bisedë përmes metodës sendMessage(), në argumentin reply_markup.
bot$sendMessage(update$message$chat_id,
text = 'Zgjidhni komandën',
reply_markup = RKM)Tastiera Inline
Siç kam thënë më lart, tastiera Inline është e lidhur me një mesazh specifik. Ajo është pak më e komplikuar për t'u punuar se sa tastiera kryesore.
Në fillim, ju duhet të shtoni në bot metodën për të thirrur tastierën Inline.
Për të përgjigjur në shtypjen e butonit Inline, mund të përdorni gjithashtu metodën e botit answerCallbackQuery(), e cila mund të shfaqë një njoftim në ndërfaqen e telegramit, për përdoruesin që klikon butonin Inline.
Të dhënat e dërguara nga butoni Inline nuk janë tekst, prandaj për përpunimin e tyre është e nevojshme të krijoni një trajtues të veçantë përmes komandës CallbackQueryHandler().
Kodi i ndërtimit të tastierës Inline që jepet në udhëzimet zyrtare të paketës telegram.bot.
Kodi i ndërtimit të tastierës Inline nga udhëzimet zyrtare
# 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)Tastiera Inline duhet të ndërtuar me ndihmën e komandës InlineKeyboardMarkup(), në të njëjtën mënyrë si tastiera Reply. InlineKeyboardMarkup() duhet të kalojmë një listë, listash të butonave Inline, çdo buton i veçantë krijohet nga funksioni InlineKeyboardButton().
Butoni Inline mund të kalojë të dhëna në bot duke përdorur argumentin callback_data, ose të hapë një faqe HTML, e cila caktohet me anë të argumentit. url.
Si rezultat, do të kemi një listë, ku çdo element gjithashtu është një listë butonash Inline, të cilat duhet të kombinohen në një rresht.
Më pas, do të analizojmë disa shembuj botash me butona Inline.
Shembulli i një boti më të thjeshtë me mbështetje për butonat InLine
Fillimisht, do të shkruajmë një bot për testimin e shpejtë ndaj covid-19. Me komandën /test, ai do t'ju dërgojë një tastierë me dy butona, në varësi të butonit të shtypur ai do t'ju dërgojë një mesazh me rezultatet e testit tuaj.
Kodi 2: Një bot i thjeshtë me tastierë Inline
library(telegram.bot)
# krijojmë një instancë të klasës Updater
updater <- Updater('TOKENI JUAJ I BOTIT')
# metode për dërgimin e tastierës InLine
test <- function(bot, update) {
# krijojmë tastierën InLine
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton("Po", callback_data = 'yes'),
InlineKeyboardButton("Jo", callback_data = 'no')
)
)
)
# Dërgojmë tastierën në chat
bot$sendMessage(update$message$chat_id,
text = "A jeni me coronavirus?",
reply_markup = IKM)
}
# metoda për përpunimin e shtypjes së butonit
answer_cb <- function(bot, update) {
# të dhënat e marra nga butoni
data <- update$callback_query$data
# marrim emrin e përdoruesit që shtypi butonin
uname <- update$effective_user()$first_name
# përpunimi i rezultatit
if ( data == 'no' ) {
msg <- paste0(uname, ", përgëzime, testi juaj ndaj covid-19 është negativ.")
} else {
msg <- paste0(uname, ", me keqardhje testi juaj ndaj covid-19 është pozitiv.")
}
# Dërgimi i mesazhit
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# njoftojmë botin që kërkesa nga butoni është pranuar
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# krijojmë menaxherët
inline_h <- CommandHandler('test', test)
query_handler <- CallbackQueryHandler(answer_cb)
# shtojmë menaxherët në dispetcher
updater <- updater + inline_h + query_handler
# nisëm botin
updater$start_polling()Ekzekutoni shembullin e kodit të mësipërm duke zëvendësuar ‘TOKENI JUAJ I BOTIT’ me tokenin e vërtetë që keni marrë gjatë krijimit të botit përmes BotFather (për krijimin e botit kam folur në ).
Rezultati:
Kemi krijuar dy metoda:
- test — Për dërgimin e tastierës Inline në chat.
- answer_cb — Për përpunimin e të dhënave të dërguara nga tastiera.
Të dhënat që do të dërgohen me çdo buton caktohen në argumentin callback_data, gjatë krijimit të butonit. Të dhënat e dërguara nga butoni mund të merren duke përdorur strukturën update$callback_query$data, brenda metodës answer_cb.
Që boti të reagojë ndaj tastierës Inline, metoda answer_cb procesi nga një menaxhues i veçantë: CallbackQueryHandler(answer_cb). I cili aktivizon metodën e specifikuar kur klikohet një buton Inline. Menaxhuesi CallbackQueryHandler pranon dy argumente:
callback— Metoda që duhet të aktivizohetpattern— Filtri për të dhënat që lidhen me butonin përmes argumentitcallback_data.
Prandaj, me ndihmën e argumentit pattern ne mund të shkruajmë një metodë të veçantë për secilin buton të shtypur:
Kodi 3: Ndarja e metodave për secilin buton Inline
library(telegram.bot)
# krijojmë një instancë të klasës Updater
updater <- Updater('TOKENI I BOTE JUAJ')
# metoda për dërgimin e tastierës InLine
test <- function(bot, update) {
# krijojmë tastierën InLine
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton("Po", callback_data = 'yes'),
InlineKeyboardButton("Jo", callback_data = 'no')
)
)
)
# Dërgojmë tastierën në bisedë
bot$sendMessage(update$message$chat_id,
text = "A jeni pozitiv për coronavirus?",
reply_markup = IKM)
}
# metoda për trajtimin e shtypjes së butonit Po
answer_cb_yes <- function(bot, update) {
# marrim emrin e përdoruesit që ka klikuar butonin
uname <- update$effective_user()$first_name
# përpunimin e rezultatit
msg <- paste0(uname, ", më vjen keq, testi juaj për covid-19 është pozitiv.")
# Dërgimi i mesazhit
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# njoftojmë botin se kërkesa nga butoni është pranuar
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# metoda për trajtimin e shtypjes së butonit Jo
answer_cb_no <- function(bot, update) {
# marrim emrin e përdoruesit që ka klikuar butonin
uname <- update$effective_user()$first_name
msg <- paste0(uname, ", përgëzime, testi juaj për covid-19 është negativ.")
# Dërgimi i mesazhit
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
# njoftojmë botin se kërkesa nga butoni është pranuar
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# krijojmë menaxhuesit
inline_h <- CommandHandler('test', test)
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')
# shtojmë menaxhuesit në menaxher
updater <- updater +
inline_h +
query_handler_yes +
query_handler_no
# aktivizojmë botin
updater$start_polling()Ekzekutoni shembullin e kodit të mësipërm duke zëvendësuar ‘TOKENI JUAJ I BOTIT’ me tokenin e vërtetë që keni marrë gjatë krijimit të botit përmes BotFather (për krijimin e botit kam folur në ).
Tani kemi shkruar 2 metoda të veçanta, dmth. një metodë për secilin buton të shtypur, dhe kemi përdorur argumentin pattern, kur krijonim menaxhuesit e tyre:
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')Këtu përfundon kodi i metodës answer_cb nëpërmjet komandës. bot$answerCallbackQuery(callback_query_id = update$callback_query$id), e cila njofton botin se të dhënat nga tastiera inline janë pranuar.
Shembulli i një boti, i cili raporton motin aktual për qytetin e zgjedhur
Le të shkruajmë një bot që kërkon informacion mbi motin.
Logjika e funksionimit do të jetë si vijon. Fillimisht me komandën /start ju thërrisni tastierën kryesore, e cila ka vetëm një buton "Moti". Duke klikuar këtë buton, merrni një mesazh me një tastierë inline për të zgjedhur qytetin për të cilin dëshironi të dini motin aktual. Zgjidhni një nga qytetet dhe merrni motin aktual.
Në këtë shembull kodi do të përdorim disa paketa shtesë:
httr— paketa për punën me kërkesat HTTP, mbi të cilat është ndërtuar funksionimi me çdo API. Në rastin tonë, do të përdorim një API falas .stringr— paketa për punën me tekstin, në rastin tonë do ta përdorim për të formuar mesazhin mbi motin në qytetin e zgjedhur.
Kodi 4: Boti që njofton motin aktual për qytetin e zgjedhur
library(telegram.bot)
library(httr)
library(stringr)
# krijojmë një ekzemplar të klasës Updater
updater <- Updater('TOKENI I BOTIT TUAJ')
# krijojmë metodat
## metoda për të nisur tastierën kryesore
start <- function(bot, update) {
# krijojmë tastierën
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Mot")
)
),
resize_keyboard = TRUE,
one_time_keyboard = TRUE
)
# dërgojmë tastierën
bot$sendMessage(update$message$chat_id,
text = 'Zgjidhni komandën',
reply_markup = RKM)
}
## Metoda për thirrjen e tastierës Inline
weather <- function(bot, update) {
IKM <- InlineKeyboardMarkup(
inline_keyboard = list(
list(
InlineKeyboardButton(text = 'Moskë', callback_data = 'New York,us'),
InlineKeyboardButton(text = 'Shën Petersburg', callback_data = 'Saint Petersburg'),
InlineKeyboardButton(text = 'Nju Jork', callback_data = 'New York')
),
list(
InlineKeyboardButton(text = 'Ekaterinburg', 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 = 'Tokio', callback_data = 'Tokyo'),
InlineKeyboardButton(text = 'Amsterdam', callback_data = 'Amsterdam,nl'),
InlineKeyboardButton(text = 'Uashington', callback_data = 'Washington,us')
)
)
)
# Dërgo tastierën Inline
bot$sendMessage(chat_id = update$message$chat_id,
text = "Zgjidhni qytetin",
reply_markup = IKM)
}
# metoda për mesazhin mbi motin
answer_cb <- function(bot, update) {
# marrim qytetin nga mesazhi
city <- update$callback_query$data
# dërgojmë kërkesën
ans <- GET('https://api.openweathermap.org/data/2.5/weather',
query = list(q = city,
lang = 'sq',
units = 'metric',
appid = '4776568ccea136ffe4cda9f1969af340'))
# analizojmë përgjigjen
result <- content(ans)
# formuojmë mesazhin
msg <- str_glue("{result$name} moti:n",
"Temperatura aktuale: {result$main$temp}n",
"Shpejtësia e erës: {result$wind$speed}n",
"Përshkrimi: {result$weather[[1]]$description}")
# dërgojmë informacionin mbi motin
bot$sendMessage(chat_id = update$from_chat_id(),
text = msg)
bot$answerCallbackQuery(callback_query_id = update$callback_query$id)
}
# krijojmë filtrat
## mesazhet me tekstin Mot
MessageFilters$weather <- BaseFilter(function(message) {
# kontrollojmë tekstin e mesazhit
message$text == "Mot"
}
)
# krijojmë manipulatorët
h_start <- CommandHandler('start', start)
h_weather <- MessageHandler(weather, filters = MessageFilters$weather)
h_query_handler <- CallbackQueryHandler(answer_cb)
# shtojmë manipulatorët në menaxher
updater <- updater +
h_start +
h_weather +
h_query_handler
# nisim botin
updater$start_polling()Ekzekutoni shembullin e kodit të mësipërm duke zëvendësuar ‘TOKENI JUAJ I BOTIT’ me tokenin e vërtetë që keni marrë gjatë krijimit të botit përmes BotFather (për krijimin e botit kam folur në ).
Si rezultat, boti ynë do të funksionojë më shumë kështu:
Schematisht, ky bot mund të duket si më poshtë:
Ne krijuam 3 metoda që janë të aksesueshme brenda botit tonë për motin:
- start — Aktivizimi i tastierës kryesore të botit
- motit — Aktivizimi i tastierës Inline për zgjedhjen e qytetit
- answer_cb — Metoda kryesore, e cila merr motin për qytetin e dhënë nga API dhe e dërgon atë në bisedë.
Sanitizer.replaceElementWithChildren() start në ne aktivizohet me komandën /start, që realizohet nga обработчикот CommandHandler('start', start).
Për të aktivizuar metodën motit ne krijuam një filtrin e njëjtë:
# создаём фильтры
## сообщения с текстом Погода
MessageFilters$weather <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Погода"
}
)Dhe e thërrasim këtë metodë me обработчикот e mesazheve: MessageHandler(moti, filters = MessageFilters$motit).
Dhe në fund, metoda jonë kryesore answer_cb reagon ndaj klikimeve të butonëve Inline, që realizohet nga обработчикот special: CallbackQueryHandler(answer_cb).
Brenda metodës answer_cb, lexojmë të dhënat e dërguara nga tastiera dhe i regjistrojmë ato në variablin qytet: qytet <- update$callback_query$data. Pas kësaj, kërkojmë të dhënat për motin nga API, formojmë dhe dërgojmë mesazhin, dhe në fund përdorim metodën answerCallbackQuery për t'i komunikuar botit se ne kemi përpunuar klikimin e butonit Inline.
Shembulli i botit që tregon listën e artikujve më të rinj me lidhjet për Hubin e dhënë nga .
E jap këtë bot për të treguar si të nxjerrim butonat Inline që dërgojnë në faqet e internetit.
Logjika e këtij boti është e ngjashme me të mëparshmet; fillimisht aktivizojmë tastierën kryesore me komandën /start. Më pas, boti na jep një listë prej 6 hubesh, ne zgjedhim hubin që na intereson dhe marrim 5 publikimet më të reja nga Hubi i zgjedhur.
Siç e kuptoni, në këtë rast ne duhet të marrim listën e artikujve, dhe për këtë do të përdorim paketën speciale habR, e cila lejon të kërkojmë artikuj nga Habra dhe disa statistika mbi ta në R.
Të instalohet paketa habR mund të bëhet vetëm nga github, për të cilin do t'ju nevojitet paketa shtesë devtools. Për instalimin, përdorni kodin e dhënë më poshtë.
install.packages('devtools')
devtools::install_github('selesnow/habR')Tani le të shqyrtojmë kodin për ndërtimin e ditur të boti të përshkruar më sipër:
Kodi 5: Boti që tregon listën e artikujve më të rinj në Hubin e zgjedhur
library(telegram.bot)
library(habR)
# krijo një instancë të klasës Updater
updater <- Updater('TOKENI I BOTS TUAJ')
# krijo metodat
## metoda për të nisur tastierën kryesore
start <- function(bot, update) {
# krijo tastierën
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Lista e artikujve")
)
),
resize_keyboard = TRUE,
one_time_keyboard = TRUE
)
# dërgo tastierën
bot$sendMessage(update$message$chat_id,
text = 'Zgjidhni komandën',
reply_markup = RKM)
}
## Metoda për thirrjen e tastierës Inline
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 = 'Inxhinieria e të Dhënave', callback_data = 'data_engineering')
),
list(
InlineKeyboardButton(text = 'Big Data', callback_data = 'bigdata'),
InlineKeyboardButton(text = 'Python', callback_data = 'python'),
InlineKeyboardButton(text = 'Vizualizimi i të Dhënave', callback_data = 'data_visualization')
)
)
)
# Dërgo tastierën Inline
bot$sendMessage(chat_id = update$message$chat_id,
text = "Zgjidhni Hapin",
reply_markup = IKM)
}
# metoda për mesazhin e motit
answer_cb <- function(bot, update) {
# merrni qytetin nga mesazhi
hub <- update$callback_query$data
# mesazhi që tregon se të dhënat janë marrë nga butoni
bot$answerCallbackQuery(callback_query_id = update$callback_query$id,
text = 'Ju lutem prisni disa minuta, kërkesa po përpunohet')
# mesazhi që tregon se duhet pritur derisa boti të marrë të dhënat
mid <- bot$sendMessage(chat_id = update$from_chat_id(),
text = "Ju lutem prisni disa minuta derisa unë të mbledh të dhënat për hapin e zgjedhur")
# parser Habr
posts <- head(habr_hub_posts(hub, 1), 5)
# fshi mesazhin që tregon se duhet pritur
bot$deleteMessage(update$from_chat_id(), mid$message_id)
# formo listën e butonave
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# formo tastierën
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)
# dërgo informacionin mbi motin
bot$sendMessage(chat_id = update$from_chat_id(),
text = paste0("5 artikujt më të rinj nga Habr ", hub),
reply_markup = IKM)
}
# krijo filtrat
## mesazhet me tekstin Moti
MessageFilters$hubs <- BaseFilter(function(message) {
# kontrollo tekstin e mesazhit
message$text == "Lista e artikujve"
}
)
# krijo trajtuesit
h_start <- CommandHandler('start', start)
h_hubs <- MessageHandler(habs, filters = MessageFilters$hubs)
h_query_handler <- CallbackQueryHandler(answer_cb)
# shto trajtuesit në menaxherin
updater <- updater +
h_start +
h_hubs +
h_query_handler
# nis boti
updater$start_polling()Ekzekutoni shembullin e kodit të mësipërm duke zëvendësuar ‘TOKENI JUAJ I BOTIT’ me tokenin e vërtetë që keni marrë gjatë krijimit të botit përmes BotFather (për krijimin e botit kam folur në ).
Në fund do të kemi një rezultat të tillë:
Lista e Hubeve të disponueshme për zgjedhje e kemi koduar me hardkod në metodën 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)
}Lista e artikujve nga Hubi i cituar e marrim me komandën habr_hub_posts(), nga paketa habR. Në këtë rast, kemi përcaktuar se nuk na nevojitet lista e artikujve për gjithmonë, por vetëm faqja e parë, ku ndodhen 20 artikuj. Nga tabela e marrë, me komandën head() lëmë vetëm 5 artikujt më të rinj, të cilët janë edhe artikujt më të freskët.
# парсим Хабр
posts <- head(habr_hub_posts(hub, 1), 5)Logjika është shumë e ngjashme me botin e mëparshëm, por në këtë rast ne e krijojmë tastierën Inline me listën e artikujve dinamikisht duke përdorur funksionin lapply().
# формируем список кнопок
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# формируем клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)Në tekstin e butonit ne vendosim titullin e artikullit posts$title[x], dhe në argumentin url linkun për artikullin: url = posts$link[x].
Më pas, krijojmë filtrin, trajtuesit dhe aktivizojmë botin tonë.
Përfundim
Tani, botët e shkruara nga ju do të jenë shumë më të lehta për t'u përdorur, për shkak se menaxhimi i tyre do të bëhet përmes tastierës, dhe jo duke futur komanda. Të paktën gjatë ndërveprimit me botin përmes telefonit inteligjent, tastiera do ta thjeshtojë dukshëm procesin e përdorimit.
Në artikullin e ardhshëm, ne do të shohim se si të ndërtojmë një dialog logjik me botin dhe të punojmë me bazat e të dhënave.
Burimi: habr.com
