Hii ni nakala ya tatu katika safu ya "Kuandika bot ya telegraph katika R". Katika machapisho yaliyotangulia, tulijifunza jinsi ya kuunda bot ya telegraph, kutuma ujumbe kupitia hiyo, amri zilizoongezwa na vichungi vya ujumbe kwenye bot. Kwa hiyo, kabla ya kuanza kusoma makala hii, ninapendekeza sana kusoma , kwa sababu Hapa sitakaa tena juu ya misingi iliyoelezwa hapo awali ya jengo la bot.
Katika makala hii, tutaboresha utumiaji wa bot yetu kwa kuongeza kibodi, ambayo itafanya kiolesura cha bot kuwa angavu na rahisi kutumia.
Nakala zote kutoka kwa safu "Kuandika bot ya telegraph katika R"
yaliyomo
Ikiwa una nia ya uchambuzi wa data, unaweza kupendezwa na yangu и njia. Maudhui mengi yamejitolea kwa lugha ya R.
3.1.
3.2.
3.3.
Je, roboti ya telegramu inaauni aina gani za kibodi?
Wakati wa uandishi huu telegram.bot hukuruhusu kuunda aina mbili za kibodi:
- Jibu - Kibodi kuu, ya kawaida, ambayo iko chini ya paneli ya maandishi ya ujumbe. Kibodi kama hicho hutuma tu ujumbe wa maandishi kwa bot, na kama maandishi itatuma maandishi ambayo yameandikwa kwenye kitufe yenyewe.
- Inline - Kibodi inayohusishwa na ujumbe mahususi wa roboti. Kibodi hii hutuma data ya roboti inayohusishwa na kitufe kilichobonyezwa; data hii inaweza kutofautiana na maandishi yaliyoandikwa kwenye kitufe chenyewe. Na vifungo vile vinasindika kupitia CallbackQueryHandler.
Ili bot kufungua kibodi, ni muhimu wakati wa kutuma ujumbe kupitia njia sendMessage(), kupitisha kibodi iliyoundwa hapo awali kama hoja reply_markup.
Hapo chini tutaangalia mifano kadhaa.
Jibu kibodi
Kama nilivyoandika hapo juu, hii ndio kibodi kuu ya kudhibiti bot.
Mfano wa kuunda kibodi ya Jibu kutoka kwa usaidizi rasmi
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)Ya hapo juu ni mfano kutoka kwa usaidizi rasmi wa kifurushi telegram.bot. Ili kuunda kibodi, tumia kazi ReplyKeyboardMarkup(), ambayo kwa hiyo inachukua orodha ya orodha ya vifungo vinavyoundwa na kazi KeyboardButton().
Kwanini ndani ReplyKeyboardMarkup() Je! unahitaji kupitisha sio orodha tu, lakini orodha ya orodha? Ukweli ni kwamba unapitisha orodha kuu, na ndani yake unafafanua kila safu ya vifungo katika orodha tofauti, kwa sababu. Unaweza kuweka vifungo kadhaa kwenye safu moja.
hoja resize_keyboard hukuruhusu kuchagua kiotomati ukubwa bora wa vitufe vya kibodi, na hoja one_time_keyboard hukuruhusu kuficha kibodi baada ya kila kubonyeza kitufe.
Wacha tuandike bot rahisi ambayo itakuwa na vifungo 3:
- Kitambulisho cha Gumzo - Omba kitambulisho cha mazungumzo cha mazungumzo na bot
- Jina langu - Omba jina lako
- Kuingia kwangu - Omba jina lako la mtumiaji katika telegramu
Msimbo wa 1: Boti rahisi yenye kibodi ya Jibu
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()Tekeleza mfano wa msimbo hapo juu, baada ya kubadilisha 'BOT TOKEN YAKO' na tokeni halisi uliyopokea wakati wa kuunda bot kupitia. BotBaba (Nilizungumza juu ya kuunda bot ndani ).
Baada ya kuzindua, toa bot amri /start, kwa sababu Hivi ndivyo tulivyofafanua kuzindua kibodi.
Ikiwa kwa sasa ni ngumu kwako kuchanganua mfano wa nambari uliyopewa, na uundaji wa njia, vichungi na washughulikiaji, basi unapaswa kurudi kwa ile iliyotangulia. , ambamo nilielezea haya yote kwa undani.
Tumeunda njia 4:
- anza - Zindua kibodi
- chat_id - Omba kitambulisho cha gumzo
- my_name - Omba jina lako
- my_username - Omba kuingia kwako
Kupinga Vichungi vya Ujumbe aliongeza vichujio 3 vya ujumbe kulingana na maandishi yao:
- chat_id - Ujumbe wenye maandishi
"Чат ID" - jina — Ujumbe wenye maandishi
"Моё имя" - jina la mtumiaji — Ujumbe wenye maandishi
"Мой логин"
Na tuliunda vidhibiti 4 ambavyo, kulingana na maagizo na vichungi vilivyopewa, vitatekelezea njia zilizoainishwa.
# создаём обработчики
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)Kibodi yenyewe imeundwa ndani ya njia start() timu ReplyKeyboardMarkup().
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Чат ID")),
list(KeyboardButton("Моё имя")),
list(KeyboardButton("Мой логин"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)Kwa upande wetu, tuliweka vifungo vyote chini ya kila mmoja, lakini tunaweza kuzipanga kwa mstari mmoja kwa kufanya mabadiliko kwenye orodha ya orodha ya vifungo. Kwa sababu safu moja ndani ya kibodi huundwa kupitia orodha iliyoorodheshwa ya vifungo, basi ili kuonyesha vitufe vyetu katika safu moja tunahitaji kuandika upya sehemu ya msimbo wa kuunda kibodi kama hii:
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Чат ID"),
KeyboardButton("Моё имя"),
KeyboardButton("Мой логин")
)
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
Kibodi hutumwa kwenye gumzo kwa kutumia mbinu sendMessage(), katika hoja reply_markup.
bot$sendMessage(update$message$chat_id,
text = 'Выберите команду',
reply_markup = RKM)Kibodi ya ndani
Kama nilivyoandika hapo juu, kibodi ya Inline imefungwa kwa ujumbe maalum. Ni ngumu zaidi kufanya kazi nayo kuliko kibodi kuu.
Hapo awali, unahitaji kuongeza njia kwenye bot ili kuita kibodi ya Inline.
Ili kujibu kubofya kitufe cha Inline, unaweza pia kutumia mbinu ya kijibu answerCallbackQuery(), ambayo inaweza kuonyesha arifa katika kiolesura cha telegramu kwa mtumiaji anayebonyeza kitufe cha Inline.
Data iliyotumwa kutoka kwa kifungo cha Inline sio maandishi, kwa hiyo ili kusindika unahitaji kuunda kidhibiti maalum kwa kutumia amri CallbackQueryHandler().
Nambari ya kuunda kibodi ya Inline ambayo imetolewa kwa usaidizi rasmi wa kifurushi telegram.bot.
Msimbo wa kuunda kibodi ya Inline kutoka kwa usaidizi rasmi
# 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)Unahitaji kuunda kibodi ya Inline kwa kutumia amri InlineKeyboardMarkup(), kwa kanuni sawa na kibodi ya Jibu. KATIKA InlineKeyboardMarkup() ni muhimu kupitisha orodha ya orodha ya vifungo vya Inline, kila kifungo cha mtu binafsi kinaundwa na kazi InlineKeyboardButton().
Kitufe cha ndani kinaweza kupitisha data fulani kwa roboti kwa kutumia hoja callback_data, au ufungue ukurasa wowote wa HTML uliobainishwa kwa kutumia hoja url.
Matokeo yake yatakuwa orodha ambayo kila kipengele pia ni orodha ya vitufe vya Inline vinavyohitaji kuunganishwa katika safu mlalo moja.
Ifuatayo tutaangalia mifano kadhaa ya bots na vifungo vya Inline.
Mfano wa bot rahisi na usaidizi wa vifungo vya InLine
Kwanza, tutaandika kijibu kwa majaribio ya moja kwa moja ya covid-19. Kwa amri /test, itakutumia kibodi yenye vitufe viwili, kulingana na kitufe kilichobonyezwa itakutumia ujumbe na matokeo ya majaribio yako.
Msimbo wa 2: Boti rahisi zaidi yenye kibodi ya 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()Tekeleza mfano wa msimbo hapo juu, baada ya kubadilisha 'BOT TOKEN YAKO' na tokeni halisi uliyopokea wakati wa kuunda bot kupitia. BotBaba (Nilizungumza juu ya kuunda bot ndani ).
Matokeo:
Tumeunda njia mbili:
- mtihani — Kutuma kuzungumza kibodi ya ndani
- jibu_cb — Kuchakata data iliyotumwa kutoka kwa kibodi.
Data ambayo itatumwa kutoka kwa kila kitufe imebainishwa kwenye hoja callback_data, wakati wa kuunda kifungo. Unaweza kupokea data iliyotumwa kutoka kwa kitufe kwa kutumia muundo update$callback_query$data, ndani ya mbinu jibu_cb.
Ili kijibu kuguswa na kibodi Inline, mbinu jibu_cb kusindika na kushughulikia maalum: CallbackQueryHandler(answer_cb). Ambayo huendesha njia iliyobainishwa wakati kitufe cha Inline kimebofya. Kishughulikiaji CallbackQueryHandler inachukua hoja mbili:
callback- Njia ambayo inahitaji kuendeshwapattern- Chuja kwa data ambayo imefungwa kwa kitufe kwa kutumia hojacallback_data.
Ipasavyo, kwa kutumia hoja pattern Tunaweza kuandika njia tofauti ya kubonyeza kila kitufe:
Msimbo wa 3: Mbinu tofauti kwa kila kitufe cha 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()Tekeleza mfano wa msimbo hapo juu, baada ya kubadilisha 'BOT TOKEN YAKO' na tokeni halisi uliyopokea wakati wa kuunda bot kupitia. BotBaba (Nilizungumza juu ya kuunda bot ndani ).
Sasa tumeandika njia 2 tofauti i.e. njia moja, kwa kila bonyeza kitufe, na kutumia hoja pattern, wakati wa kuunda washughulikiaji wao:
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')Msimbo wa njia unaisha jibu_cb timu bot$answerCallbackQuery(callback_query_id = update$callback_query$id), ambayo huambia kijibu kwamba data kutoka kwa kibodi ya ndani imepokelewa.
Mfano wa roboti inayoripoti hali ya hewa ya sasa kwa jiji lililochaguliwa
Hebu jaribu kuandika bot ambayo inaomba data ya hali ya hewa.
Mantiki ya kazi yake itakuwa kama ifuatavyo. Awali na timu /start unaita kibodi kuu, ambayo ina kifungo kimoja tu cha "Hali ya hewa". Kwa kubofya kitufe hiki utapokea ujumbe na kibodi ya Inline ili kuchagua jiji ambalo ungependa kujua hali ya hewa ya sasa. Chagua moja ya miji na upate hali ya hewa ya sasa.
Katika mfano huu wa nambari tutatumia vifurushi kadhaa vya ziada:
httr- kifurushi cha kufanya kazi na maombi ya HTTP, kwa msingi ambao kazi na API yoyote imejengwa. Kwa upande wetu tutatumia API ya bure .stringr- kifurushi cha kufanya kazi na maandishi, kwa upande wetu tutatumia kutoa ujumbe kuhusu hali ya hewa katika jiji lililochaguliwa.
Msimbo wa 4: Kijibu kinachoripoti hali ya hewa ya sasa kwa jiji lililochaguliwa
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()Tekeleza mfano wa msimbo hapo juu, baada ya kubadilisha 'BOT TOKEN YAKO' na tokeni halisi uliyopokea wakati wa kuunda bot kupitia. BotBaba (Nilizungumza juu ya kuunda bot ndani ).
Kama matokeo, bot yetu itafanya kazi kama hii:
Kwa utaratibu, bot hii inaweza kuonyeshwa kama hii:
Tumeunda njia 3 zinazopatikana ndani ya roboti yetu ya hali ya hewa:
- Kuanza — Zindua kibodi kuu ya kijibu
- hali ya hewa - Zindua kibodi ya Inline ili kuchagua jiji
- jibu_cb - Njia kuu inayoomba hali ya hewa kutoka kwa API kwa jiji fulani na kuituma kwenye gumzo.
Mbinu Kuanza tunaizindua kwa amri /start, ambayo inatekelezwa na mtoaji CommandHandler('start', start).
Kuendesha mbinu hali ya hewa tuliunda kichungi cha jina moja:
# создаём фильтры
## сообщения с текстом Погода
MessageFilters$weather <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Погода"
}
)Na tunaita njia hii na kidhibiti cha ujumbe kifuatacho: MessageHandler(weather, filters = MessageFilters$weather).
Na mwisho, njia yetu kuu jibu_cb humenyuka kwa kubonyeza vitufe vya Inline, ambayo inatekelezwa na kidhibiti maalum: CallbackQueryHandler(answer_cb).
Ndani ya mbinu jibu_cb, tunasoma data iliyotumwa kutoka kwenye kibodi na kuiandika kwa kutofautiana city: city <- update$callback_query$data. Kisha tunaomba data ya hali ya hewa kutoka kwa API, kuzalisha na kutuma ujumbe, na hatimaye kutumia mbinu answerCallbackQuery ili kufahamisha bot kwamba tulichakata kubofya kwa kitufe cha Inline.
Mfano wa roboti inayoonyesha orodha ya makala ya hivi punde yenye viungo vya Kitovu kilichobainishwa kutoka .
Ninawasilisha bot hii ili kukuonyesha jinsi ya kuonyesha vitufe vya Inline vinavyoongoza kwenye kurasa za wavuti.
Mantiki ya bot hii ni sawa na ile iliyopita; mwanzoni tunazindua kibodi kuu na amri /start. Kisha, kijibu hutupa orodha ya vitovu 6 vya kuchagua kutoka, tunachagua kitovu tunachopenda, na kupokea machapisho 5 ya hivi majuzi zaidi kutoka kwa Hub iliyochaguliwa.
Kama unavyoelewa, katika kesi hii tunahitaji kupata orodha ya vifungu, na kwa hili tutatumia kifurushi maalum habR, ambayo hukuruhusu kuomba nakala kutoka kwa Habra na baadhi ya takwimu juu yake katika R.
Sakinisha kifurushi habR inawezekana tu kutoka kwa github, ambayo utahitaji kifurushi cha ziada devtools. Ili kusakinisha, tumia msimbo ulio hapa chini.
install.packages('devtools')
devtools::install_github('selesnow/habR')Sasa hebu tuangalie nambari ya kujenga bot iliyoelezwa hapo juu:
Msimbo wa 5: Kijibu kinachoonyesha orodha ya makala ya hivi karibuni kwenye Kitovu kilichochaguliwa
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()Tekeleza mfano wa msimbo hapo juu, baada ya kubadilisha 'BOT TOKEN YAKO' na tokeni halisi uliyopokea wakati wa kuunda bot kupitia. BotBaba (Nilizungumza juu ya kuunda bot ndani ).
Kama matokeo, tutapata matokeo haya:
Tuliweka ngumu orodha ya Hubs zinazopatikana kwa uteuzi katika mbinu 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)
}Tunapata orodha ya vifungu kutoka kwa Hub iliyoainishwa na amri habr_hub_posts(), kutoka kwa kifurushi habR. Wakati huo huo, tunasema kwamba hatuhitaji orodha ya makala kwa wakati wote, lakini tu ukurasa wa kwanza ambao makala 20 ziko. Kutoka kwa jedwali linalosababishwa kwa kutumia amri head() Tunaacha 5 tu za juu, ambazo ni nakala za hivi karibuni.
# парсим Хабр
posts <- head(habr_hub_posts(hub, 1), 5)Mantiki ni sawa na roboti iliyotangulia, lakini katika kesi hii tunatoa kibodi ya Inline na orodha ya vifungu kwa kutumia chaguo la kukokotoa. lapply().
# формируем список кнопок
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# формируем клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)Tunaingiza kichwa cha makala kwenye maandishi ya kifungo posts$title[x], na katika hoja url kiungo kwa makala: url = posts$link[x].
Ifuatayo, tunaunda kichungi, vidhibiti na kuzindua bot yetu.
Hitimisho
Sasa roboti unazoandika zitakuwa rahisi zaidi kutumia, kwa sababu ya ukweli kwamba zitadhibitiwa kutoka kwa kibodi, badala ya kuingiza amri. Kwa kiwango cha chini, wakati wa kuingiliana na bot kupitia smartphone, kibodi itarahisisha kwa kiasi kikubwa mchakato wa kuitumia.
Katika makala inayofuata tutajua jinsi ya kujenga mazungumzo ya kimantiki na roboti na kufanya kazi na hifadhidata.
Chanzo: mapenzi.com