Tertius articulus hic est in serie "Scribere telegraphum in R". In superioribus publicationibus didicimus automati telegraphum creare, nuntios per eam mittere, mandata et nuntios columellas in automati adiecisse. Priusquam igitur hunc articulum legere incipias, te magnopere suadeo ut legas , quod Hic non diutius immorabor in fundamentis praefatis autocineti aedificii.
In hoc articulo, usabilitatem automatis nostri emendabimus addito claviaturae, quae automati intuitivam et facilem uti faciet.
Articuli omnes ex serie "Scribere telegraphum bot in R"
contentus
Si vos es interested in Analysis analysi, fortasse interesse in my и rivos. Pleraque contenti r lingua dedicata est.
3.1.
3.2.
3.3.
Quibus generibus Claviaturae telegraphum automati auxilium facit?
In tempore scripturae huius telegram.bot permittit vos creare duo genera Claviaturae:
- Respondere - Praecipua, tincidunt regularis, quae sub nuntium text input panel sita est. Talis claviatura simpliciter mittit textum ad automati, et sicut textus mittet textum qui in ipsa conjunctione scriptus est.
- Inline - Compendia cum certis autocinetis coniungitur nuntius. Hoc claviaturae notitias autocineticas coniunctas cum globulo expressas mittit, haec notitia a textu ipso in ipso puga scripto differre potest. Et huiusmodi globuli discursum sunt CallbackQueryHandler.
Ut automati tincidunt aperiat, nuntium per modum mittendo necessarium est sendMessage()transi prius creatus tincidunt ut argumentum reply_markup.
Plura exempla infra videbimus.
Respondeo tincidunt
Sicut supra scripsi, haec est praecipuae potestates claviaturae.
Exemplum creandi Responsum tincidunt a officiali auxilio
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)Exemplum est superius de auxilio officialis sarcina telegram.bot. Ut tincidunt creare, munere utere ReplyKeyboardMarkup(), qui vicissim indicem praecipuorum globuli accipit ab officio creati KeyboardButton().
Cur in? ReplyKeyboardMarkup() Non indicem tantum, sed indicem tabularum transire debes? Ita res est, ut indicem principalem transeas, et in eo singulos ordines fibularum in tabulis distinctis definias, quoniam Plures globulis uno ordine ponere potes.
ratio resize_keyboard sino te statim eligere meliorem magnitudinem bullarum claviaturarum ac argumentum one_time_keyboard sino vos celare tincidunt post sulum puga pyga.
Scribamus simplices bot qui III fibulas habebunt:
- Chat ID - Request chat ID dialogi cum bot
- Nomen meum - Request nomen tuum
- My login - Request your username in telegram
Code I: Simple bot cum Reply tincidunt
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()Exemplum supra codicem currite, postquam reposuit 'BOT SIGNUM VERUM' cum signo reali quod accepistis cum creando bot via BotFather (Locutus sum de creando bot in ).
His deductis, da imperium bot /start, quod Hoc ipsum est quod definivimus tincidunt mittere.
Si nunc difficile est tibi exemplum datam codicem dividere, cum methodorum, filorum et tractorum creationis, ad priorem redire debes. in quibus haec omnia singillatim descripsi.
IV modos creavimus:
- satus - Duc tincidunt
- chat_id - Request chat ID
- my_name - Request nomen tuum
- my_username - Request login
Objicere MessageFilters additae III nuntius filters fundatur in textu:
- chat_id - Messages with text
"Чат ID" - name - Messages with text
"Моё имя" - username - Messages with text
"Мой логин"
Et 4 tractores creavimus quod, datis mandatis et filters, certos modos exequemur.
# создаём обработчики
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)tincidunt ipsum intra modum creatur start() bigas ReplyKeyboardMarkup().
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(KeyboardButton("Чат ID")),
list(KeyboardButton("Моё имя")),
list(KeyboardButton("Мой логин"))
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)In casu nostro, omnes globulis sub se invicem collocavimus, sed eas uno ordine disponere possumus mutando ad indicem globuli. Quod unus ordo intra claviaturae per globulum insertum creatur, deinde ut in uno ordine tesserae nostrae exhibeantur necesse est partem codicis rescribere ad claviaturam sic construendam:
RKM <- ReplyKeyboardMarkup(
keyboard = list(
list(
KeyboardButton("Чат ID"),
KeyboardButton("Моё имя"),
KeyboardButton("Мой логин")
)
),
resize_keyboard = FALSE,
one_time_keyboard = TRUE
)
tincidunt mittitur ad chat per modum utendi sendMessage()In argumento reply_markup.
bot$sendMessage(update$message$chat_id,
text = 'Выберите команду',
reply_markup = RKM)Inline tincidunt
Sicut supra scripsi, claviaturae Inline ad certum nuntium ligatur. Aliquanto difficilius est elaborare quam tincidunt consectetur.
Initio, methodum addere debes automati ut claviaturas Inline vocant.
Ut respondeas deprime bullam Inline, methodo autocineto uti potes answerCallbackQuery(), quae notificationem in interface telegraphi prae se ferre potest ad utentis qui bullam Inline pressit.
Data e bullis Inline missis non est textus, ita ut processum sit debes creare specialem tracto uti mandato CallbackQueryHandler().
Codex in claviaturae Inline aedificandae quae in officiali ope sarcinae datur telegram.bot.
Code ad aedificationem Inline tincidunt a officiali auxilium
# 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 tincidunt utens imperio opus est facere InlineKeyboardMarkup()hac eadem ratione ac tincidunt. IN' InlineKeyboardMarkup() necesse est indices bullarum Inlinearum notarum tradere, singulas singulas bullarum functione creantur InlineKeyboardButton().
An conjunctionem inline potest vel aliqua notitia ad bot uti argumento transire callback_data, vel aliquam HTML paginam aperi url.
Ita fiet index in quo unumquodque elementum est etiam index bullarum Inlinerum quae in unum ordinem componi debent.
Deinde plura exempla autocinetorum cum globulis Inline videbimus.
Exemplum simplicis autocineti cum auxilio pro Bullae Inline
Primum scribemus autocinetum ad exprimendam probationem pro covid-19. per mandatum /testclaviaturum tibi mittet cum duabus globulis, pendens e prementibus, nuntium tibi mittet cum exitu probationis tuae.
Code II: Simplicissima bot cum Inline keyboard
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()Exemplum supra codicem currite, postquam reposuit 'BOT SIGNUM VERUM' cum signo reali quod accepistis cum creando bot via BotFather (Locutus sum de creando bot in ).
effectus:
Duo modi creavimus:
- Test - Ad mittere ad chat Inline tincidunt
- answer_cb - Ad processum notitia missa ex tincidunt.
Notitia quae ex singulis bullis mittetur in argumento specificatur callback_datacreando puga. Notitia ex puga pyga uti potes accipere constructio update$callback_query$data, intra modum answer_cb.
Pro bot agere in Inline tincidunt, methodo answer_cb processionaliter per specialem tracto: CallbackQueryHandler(answer_cb). Quod certum modum decurrit cum Bulla Inline clicked. Handler CallbackQueryHandler duas rationes accipit;
callback- Modus qui debet currerepattern- Filter ex notitia quod tenetur ad puga pyga utens argumentocallback_data.
Quocirca utens argument! pattern Modum separatum scribere possumus ad exprimendum singulas conjunctiones:
Code III: Singula modi ad invicem Inline button
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()Exemplum supra codicem currite, postquam reposuit 'BOT SIGNUM VERUM' cum signo reali quod accepistis cum creando bot via BotFather (Locutus sum de creando bot in ).
2 singulas autem rationes scripsimus i.e. una methodus, pro qualibet conjunctione prelo, et argumento utebatur patterncum eorum tracto;
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no <- CallbackQueryHandler(answer_cb_no, pattern = 'no')Modus code terminos answer_cb bigas bot$answerCallbackQuery(callback_query_id = update$callback_query$id)qui narrat bot notitias claviaturarum inlinearum receptas esse.
Exemplum autocineti refert tempestatem hodiernam in civitate delectae
Experiamur scribere automati quod petit tempestatum data.
Ratio operis sui sic erit. Initio per bigas /start tincidunt principale vocas, quod unum tantum "Tempestas" conjunctionem habet. Deprimendo in hac conjunctione nuntium accipies cum claviaturae Inline urbis eligere pro qua tempestate hodiernam invenire vis. Unam ex urbibus et tempestatem hodiernam obtine.
In hoc codice exemplis aliquot fasciculis adiectis utemur:
httr- sarcina operandi cum petitionibus HTTP, cuius fundamentum opus cum aliquo API aedificatur. In casu nostro libera API utemur .stringr- sarcina ad operandum cum textu, in casu nostro, ea utemur ad nuntium generandum de tempestate in urbe electa.
Code 4: Bot that report the current weather for the selected city
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()Exemplum supra codicem currite, postquam reposuit 'BOT SIGNUM VERUM' cum signo reali quod accepistis cum creando bot via BotFather (Locutus sum de creando bot in ).
Quam ob rem noster automati simile hoc opus faciet:
Schematically hoc automati sic depingi potest:
III modos praesto creavimus intra tempestatem nostram autocineticam;
- principium - Duc pelagus keyboard bot
- tempus - Duc Inline tincidunt eligere civitatem
- answer_cb — Methodus principalis quae tempestatem petit ab API civitate data et eam ad chat mittit.
modum principium demittimus cum imperio /start, quod fit per tracto CommandHandler('start', start).
Ad modum currere tempus eiusdem nominis filtrum creavimus;
# создаём фильтры
## сообщения с текстом Погода
MessageFilters$weather <- BaseFilter(function(message) {
# проверяем текст сообщения
message$text == "Погода"
}
)Et hunc modum appellamus cum tractatore sequenti: MessageHandler(weather, filters = MessageFilters$weather).
Et in fine, methodus principalis noster answer_cb reagit ad instar globuli Inline, quae peculiari tracto ad effectum deducitur; CallbackQueryHandler(answer_cb).
Intra modum answer_cb, notitia ex claviaturae missae legimus et variabili scribemus city: city <- update$callback_query$data. Tunc postulamus notitias tempestatis ex API, generare et nuntium mittere, ac tandem methodo utere answerCallbackQuery ut bot informarent nos emissarium inlinei pugionis discursum.
Exemplum autocineti quod ostendit indicem articulorum novissimarum cum nexus ad Hub determinatum e .
Hoc autocinetum exhibeo ut ostendam tibi quomodo tesserae Inlineae quae ad paginas ducunt ostendas.
Logica huius automati similis priori est, initio tincidunt principale cum imperio deducimus /start. Deinde automati nobis dat elenchum 6 axium ad eligendum, centrum quem interest eligimus, et 5 recentissimas publicationes ex selectis Hub accipimus.
Ut intellegis, in hoc casu opus est ut indices articulorum accipiamus, eoque speciali sarcina utemur habR, quod permittit tibi ut petas articulos ex Habra et aliquas statisticas de eis in R.
Install sarcina habR tantum fieri potest ex github, cui addita sarcina opus erit devtools. Inaugurari, codice infra utere.
install.packages('devtools')
devtools::install_github('selesnow/habR')Nunc inspiciamus codicem construendi automati de quo supra:
Codex V: Bot quod album ostendit recentissimorum articulorum in delectis Hub
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()Exemplum supra codicem currite, postquam reposuit 'BOT SIGNUM VERUM' cum signo reali quod accepistis cum creando bot via BotFather (Locutus sum de creando bot in ).
Quam ob rem hoc eventum habebimus:
Nos indicem Hubs in modum electionis available 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)
}Convenimus indicem articulorum ex certo Hub cum mandato habr_hub_posts()Ex sarcina habR. Eodem tempore demonstramus nos non toto tempore indicem articulorum indigere, sed primam tantum paginam in qua 20 articuli collocantur. Ex mensa inde per mandatum head() Solum cacumen 5 relinquimus, qui sunt recentissimi articuli.
# парсим Хабр
posts <- head(habr_hub_posts(hub, 1), 5)Logica priori automati simillima est, sed in hoc casu claviaturas Inlineas generamus cum indice articulorum munere dynamice utendo. lapply().
# формируем список кнопок
keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))
# формируем клавиатуру
IKM <- InlineKeyboardMarkup(
inline_keyboard = keys
)Titulum articuli in textu button inserimus posts$title[x]et in argumento url ad articulum: url = posts$link[x].
Deinde filtrum, tracto et botones creamus.
conclusio,
Automata, quae scribis, multo commodius erunt usui, ex eo quod a claviaturis continebuntur, quam per intrando imperata. Ad minimum, cum inter se cum autocineto per Mauris quis felis, tincidunt significanter simpliciorem faciet processum utendi eo.
In proximo articulo figurabimus quomodo dialogum logicum cum autocineto et cum databases operando condere debebimus.
Source: www.habr.com