Ky është artikulli i tretë në serinë "Të shkruajmë një bot telegram në R". Në botimet e mëparshme, ne mësuam se si të krijojmë një bot telegrami, të dërgojmë mesazhe përmes tij, të shtojmë komanda dhe filtra mesazhesh në bot. Prandaj, para se të filloni të lexoni këtë artikull, ju rekomandoj të lexoni , sepse Këtu nuk do të ndalem më në bazat e përshkruara më parë të ndërtimit të boteve.
Në këtë artikull, ne do të përmirësojmë përdorshmërinë e robotit tonë duke shtuar një tastierë, e cila do ta bëjë ndërfaqen e botit intuitive dhe të lehtë për t'u përdorur.
Të gjithë artikujt nga seria "Të shkruajmë një bot telegram në R"
Përmbajtje
Nëse jeni të interesuar për analizën e të dhënave, mund të jeni të interesuar për mua и kanalet. Pjesa më e madhe e përmbajtjes i kushtohet gjuhës R.
3.1.
3.2.
3.3.
Çfarë lloje të tastierave mbështet roboti i telegramit?
Në kohën e këtij shkrimi telegram.bot ju lejon të krijoni dy lloje tastierë:
- Përgjigja - Tastiera kryesore, e rregullt, e cila ndodhet nën panelin e futjes së tekstit të mesazhit. Një tastierë e tillë thjesht i dërgon një mesazh me tekst robotit dhe si tekst do të dërgojë tekstin që është shkruar në vetë butonin.
- Inline - Tastiera e lidhur me një mesazh specifik bot. Kjo tastierë dërgon të dhënat e botit të lidhura me butonin e shtypur; këto të dhëna mund të ndryshojnë nga teksti i shkruar në vetë butonin. Dhe butona të tillë përpunohen përmes CallbackQueryHandler.
Në mënyrë që boti të hapë tastierën, është e nevojshme kur dërgoni një mesazh përmes metodës sendMessage(), kaloni si argument tastierën e krijuar më parë reply_markup.
Më poshtë do të shohim disa shembuj.
Tastiera e përgjigjes
Siç shkrova më lart, kjo është tastiera kryesore e kontrollit të botit.
Një shembull i krijimit të një tastierë Përgjigje nga ndihma zyrtare
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)Sa më sipër është një shembull nga ndihma zyrtare e paketës telegram.bot. Për të krijuar një tastierë, përdorni funksionin ReplyKeyboardMarkup(), i cili nga ana tjetër merr një listë të listave të butonave që krijohen nga funksioni KeyboardButton().
Pse në ReplyKeyboardMarkup() A duhet të kaloni jo vetëm një listë, por një listë me lista? Fakti është që ju kaloni listën kryesore dhe në të përcaktoni çdo rresht butonash në lista të veçanta, sepse Mund të vendosni disa butona në një rresht.
Argument resize_keyboard ju lejon të zgjidhni automatikisht madhësinë optimale të butonave të tastierës dhe argumentin one_time_keyboard ju lejon të fshehni tastierën pas çdo shtypjeje të butonit.
Le të shkruajmë një bot të thjeshtë që do të ketë 3 butona:
- ID-ja e bisedës - Kërko ID-në e bisedës për dialog me bot
- Emri im - Kërkoni emrin tuaj
- Hyrja ime - Kërkoni emrin tuaj të përdoruesit në telegram
Kodi 1: Bot i thjeshtë me tastierë Përgjigje
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()Ekzekutoni shembullin e kodit të mësipërm, pasi të zëvendësoni 'TUAJ BOT TOKEN' me tokenin e vërtetë që keni marrë gjatë krijimit të robotit nëpërmjet BotBabai (Unë fola për krijimin e një roboti në ).
Pas nisjes, jepni një komandë botit /start, sepse Kjo është pikërisht ajo që ne përcaktuam për të nisur tastierën.
Nëse për momentin është e vështirë për ju të analizoni shembullin e kodit të dhënë, me krijimin e metodave, filtrave dhe mbajtësve, atëherë duhet të ktheheni te ai i mëparshmi. , në të cilën i përshkrova të gjitha këto në detaje.
Ne krijuam 4 metoda:
- start — Nis tastierën
- chat_id - Kërko ID e bisedës
- my_name — Kërkoni emrin tuaj
- my_username — Kërkoni hyrjen tuaj
Për të kundërshtuar Filtrat e mesazheve shtoi 3 filtra mesazhesh bazuar në tekstin e tyre:
- chat_id — Mesazhe me tekst
"Чат ID" - emri — Mesazhe me tekst
"Моё имя" - emri i përdoruesit — Mesazhet me tekst
"Мой логин"
Dhe ne krijuam 4 mbajtës që, bazuar në komandat dhe filtrat e dhënë, 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)Vetë tastiera krijohet brenda metodës start() ekipi ReplyKeyboardMarkup().
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Чат ID")),
list(KeyboardButton("Моё имя")),
list(KeyboardButton("Мой логин"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)Në rastin tonë, ne vendosëm të gjithë butonat nën njëri-tjetrin, por mund t'i rregullojmë 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ë mbivendosur butonash, më pas për të shfaqur butonat tanë në një rresht duhet të rishkruajmë një pjesë të kodit për ndërtimin e tastierës si kjo:
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Чат ID"),
KeyboardButton("Моё имя"),
KeyboardButton("Мой логин")
)
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
Tastiera dërgohet në bisedë duke përdorur metodën sendMessage(), në argument reply_markup.
bot$sendMessage(update$message$chat_id,
text = 'Выберите команду',
reply_markup = RKM)Tastierë inline
Siç shkrova më lart, tastiera Inline është e lidhur me një mesazh specifik. Puna me të është disi më e vështirë sesa tastiera kryesore.
Fillimisht, duhet të shtoni një metodë në robot për të thirrur tastierën Inline.
Për t'iu përgjigjur një klikimi të butonit Inline, mund të përdorni gjithashtu metodën bot answerCallbackQuery(), i cili mund të shfaqë një njoftim në ndërfaqen e telegramit për përdoruesin që shtyp butonin Inline.
Të dhënat e dërguara nga butoni Inline nuk janë tekst, kështu që për t'i përpunuar ato duhet të krijoni një mbajtës të veçantë duke përdorur komandën CallbackQueryHandler().
Kodi për ndërtimin e një tastierë Inline i cili jepet në ndihmën zyrtare të paketës telegram.bot.
Kodi për ndërtimin e një tastierë Inline nga ndihma 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)Ju duhet të ndërtoni një tastierë Inline duke përdorur komandën InlineKeyboardMarkup(), në të njëjtin parim si tastiera Reply. NË InlineKeyboardMarkup() është e nevojshme të kaloni një listë të listave të butonave Inline, secili buton individual krijohet nga funksioni InlineKeyboardButton().
Një buton inline ose mund t'i kalojë disa të dhëna robotit duke përdorur një argument callback_data, ose hapni çdo faqe HTML të specifikuar duke përdorur argumentin url.
Rezultati do të jetë një listë në të cilën çdo element është gjithashtu një listë e butonave Inline që duhet të kombinohen në një rresht.
Më pas do të shikojmë disa shembuj të robotëve me butona Inline.
Një shembull i një roboti të thjeshtë me mbështetje për butonat InLine
Së pari, ne do të shkruajmë një bot për testimin ekspres për Covid-19. Me komandë /test, do t'ju dërgojë një tastierë me dy butona, në varësi të butonit të shtypur do t'ju dërgojë një mesazh me rezultatet e testimit tuaj.
Kodi 2: Boti më i thjeshtë me një tastierë Inline
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()Ekzekutoni shembullin e kodit të mësipërm, pasi të zëvendësoni 'TUAJ BOT TOKEN' me tokenin e vërtetë që keni marrë gjatë krijimit të robotit nëpërmjet BotBabai (Unë fola për krijimin e një roboti në ).
Rezultati:
Ne krijuam dy metoda:
- provë — Për të dërguar në chat Tastiera inline
- përgjigje_cb — Për të përpunuar të dhënat e dërguara nga tastiera.
Të dhënat që do të dërgohen nga secili buton janë të specifikuara në argument callback_data, kur krijoni një buton. Ju mund të merrni të dhënat e dërguara nga butoni duke përdorur konstruktin update$callback_query$data, brenda metodës përgjigje_cb.
Që roboti të reagojë ndaj tastierës Inline, metoda përgjigje_cb të përpunuara nga një mbajtës i veçantë: CallbackQueryHandler(answer_cb). E cila ekzekuton metodën e specifikuar kur klikohet butoni Inline. Trajtues CallbackQueryHandler merr dy argumente:
callback— Metoda që duhet të zbatohetpattern— Filtro sipas të dhënave që lidhen me butonin duke përdorur një argumentcallback_data.
Prandaj, duke përdorur argumentin pattern Mund të shkruajmë një metodë të veçantë për shtypjen e secilit buton:
Kodi 3: Metoda të veçanta për çdo buton Inline
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()Ekzekutoni shembullin e kodit të mësipërm, pasi të zëvendësoni 'TUAJ BOT TOKEN' me tokenin e vërtetë që keni marrë gjatë krijimit të robotit nëpërmjet BotBabai (Unë fola për krijimin e një roboti në ).
Tani kemi shkruar 2 metoda të veçanta d.m.th. një metodë, për çdo buton shtypni dhe përdorni argumentin pattern, kur krijoni mbajtësit e tyre:
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')Kodi i metodës përfundon përgjigje_cb ekipi bot$answerCallbackQuery(callback_query_id = update$callback_query$id), i cili i tregon robotit se janë marrë të dhënat nga tastiera inline.
Një shembull i një roboti që raporton motin aktual për një qytet të zgjedhur
Le të përpiqemi të shkruajmë një bot që kërkon të dhëna moti.
Logjika e punës së saj do të jetë si më poshtë. Fillimisht nga ekipi /start ju telefononi tastierën kryesore, e cila ka vetëm një buton "Moti". Duke klikuar në këtë buton do të merrni një mesazh me tastierën Inline për të zgjedhur qytetin për të cilin dëshironi të mësoni motin aktual. Zgjidhni një nga qytetet dhe merrni motin aktual.
Në këtë shembull kodi ne do të përdorim disa paketa shtesë:
httr— një paketë për të punuar me kërkesat HTTP, në bazë të së cilës është ndërtuar puna me çdo API. Në rastin tonë ne do të përdorim API-në falas .stringr— një paketë për të punuar me tekst, në rastin tonë do ta përdorim për të gjeneruar një mesazh në lidhje me motin në qytetin e zgjedhur.
Kodi 4: Një robot që raporton motin aktual për qytetin e zgjedhur
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()Ekzekutoni shembullin e kodit të mësipërm, pasi të zëvendësoni 'TUAJ BOT TOKEN' me tokenin e vërtetë që keni marrë gjatë krijimit të robotit nëpërmjet BotBabai (Unë fola për krijimin e një roboti në ).
Si rezultat, boti ynë do të funksionojë diçka si kjo:
Skematikisht, ky bot mund të përshkruhet kështu:
Ne kemi krijuar 3 metoda të disponueshme brenda robotit tonë të motit:
- Fillimi — Hapni tastierën kryesore të botit
- mot — Hapni tastierën Inline për të zgjedhur një qytet
- përgjigje_cb — Metoda kryesore që kërkon motin nga API për një qytet të caktuar dhe e dërgon atë në chat.
Метод Fillimi e nisim me komandë /start, e cila zbatohet nga mbajtësi CommandHandler('start', start).
Për të ekzekutuar një metodë mot ne krijuam një filtër me të njëjtin emër:
# создаём фильтры
## сообщения с текстом Погода
MessageFilters$weather <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Погода"
}
)Dhe ne e quajmë këtë metodë me mbajtësin e mëposhtëm të mesazheve: MessageHandler(weather, filters = MessageFilters$weather).
Dhe në fund, metoda jonë kryesore përgjigje_cb reagon ndaj shtypjes së butonave Inline, i cili zbatohet nga një mbajtës i veçantë: CallbackQueryHandler(answer_cb).
Brenda një metode përgjigje_cb, lexojmë të dhënat e dërguara nga tastiera dhe i shkruajmë në një variabël city: city <- update$callback_query$data. Më pas kërkojmë të dhëna moti nga API, gjenerojmë dhe dërgojmë një mesazh dhe në fund përdorim metodën answerCallbackQuery në mënyrë që të informojmë botin se kemi përpunuar klikimin e butonit Inline.
Një shembull i një roboti që shfaq një listë të artikujve më të fundit me lidhje me qendrën e specifikuar nga .
Unë e prezantoj këtë bot për t'ju treguar se si të shfaqni butonat Inline që çojnë në faqet e internetit.
Logjika e këtij roboti është e ngjashme me atë të mëparshme; fillimisht ne nisim tastierën kryesore me komandën /start. Më pas, roboti na jep një listë me 6 qendra për të zgjedhur, ne zgjedhim qendrën për të cilën jemi të interesuar dhe marrim 5 publikimet më të fundit nga Qendra e përzgjedhur.
Siç e kuptoni, në këtë rast duhet të marrim një listë artikujsh, dhe për këtë do të përdorim një paketë të veçantë habR, e cila ju lejon të kërkoni artikuj nga Habra dhe disa statistika mbi to në R.
Instaloni paketën habR e mundur vetëm nga github, për të cilën do t'ju duhet një paketë shtesë devtools. Për të instaluar, përdorni kodin më poshtë.
install.packages('devtools')
devtools::install_github('selesnow/habR')Tani le të shohim kodin për ndërtimin e botit të përshkruar më sipër:
Kodi 5: Një robot që shfaq një listë të artikujve më të fundit në Qendrën e zgjedhur
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()Ekzekutoni shembullin e kodit të mësipërm, pasi të zëvendësoni 'TUAJ BOT TOKEN' me tokenin e vërtetë që keni marrë gjatë krijimit të robotit nëpërmjet BotBabai (Unë fola për krijimin e një roboti në ).
Si rezultat, ne do të marrim këtë rezultat:
Ne kemi koduar listën e shpërndarësve të disponueshëm për përzgjedhje në metodë 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)
}Ne marrim një listë artikujsh nga Hub-i i specifikuar me komandën habr_hub_posts(), nga paketa habR. Në të njëjtën kohë, theksojmë se nuk na duhet një listë artikujsh për të gjithë kohën, por vetëm faqja e parë në të cilën ndodhen 20 artikuj. Nga tabela që rezulton duke përdorur komandën head() Ne lëmë vetëm top 5, të cilët janë artikujt më të fundit.
# парсим Хабр
posts <- head(habr_hub_posts(hub, 1), 5)Logjika është shumë e ngjashme me robotin e mëparshëm, por në këtë rast ne gjenerojmë një tastierë Inline me një listë artikujsh në mënyrë dinamike 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
)Ne fusim titullin e artikullit në tekstin e butonit posts$title[x], dhe në argument url lidhje me artikullin: url = posts$link[x].
Më pas, ne krijojmë një filtër, mbajtës dhe lëshojmë botin tonë.
Përfundim
Tani robotët që shkruani do të jenë shumë më të përshtatshëm për t'u përdorur, për faktin se ato do të kontrollohen nga tastiera, sesa duke futur komanda. Në minimum, kur ndërveproni me një bot përmes një smartphone, tastiera do të thjeshtojë ndjeshëm procesin e përdorimit të tij.
Në artikullin tjetër do të kuptojmë se si të ndërtojmë një dialog logjik me një bot dhe të punojmë me bazat e të dhënave.
Burimi: www.habr.com