זהו המאמר השלישי בסדרה "כתיבת בוט טלגרם ב-R". בפרסומים קודמים למדנו איך יוצרים בוט טלגרם, שולחים דרכו הודעות, הוספנו פקודות ומסנני הודעות לבוט. לכן, לפני שאתם מתחילים לקרוא את המאמר הזה, אני ממליץ בחום לקרוא קודם, כי כאן לא אתעכב עוד על היסודות שתוארו קודם לכן של בניית בוטים.

במאמר זה נשפר את השימושיות של הבוט שלנו על ידי הוספת מקלדת, שתהפוך את ממשק הבוט לאינטואטיבי וקל לשימוש.

כל הכתבות מהסדרה "כתיבת בוט טלגרם ב-R"

תוכן

אם אתה מעוניין בניתוח נתונים, אולי אתה מעוניין ב- שלי מברק и YouTube ערוצים. רוב התוכן מוקדש לשפת R.

באילו סוגי מקלדות תומך בוט הטלגרם?
מקלדת תשובה
מקלדת מוטבעת
3.1. דוגמה לבוט פשוט עם תמיכה בכפתורי InLine
3.2. דוגמה לבוט המדווח על מזג האוויר הנוכחי עבור עיר נבחרת
3.3. דוגמה לבוט שמציג רשימה של המאמרים העדכניים ביותר עם קישורים ל-Hub שצוין מ-habr.com
מסקנה

באילו סוגי מקלדות תומך בוט הטלגרם?

בזמן כתיבת שורות אלה telegram.bot מאפשר לך ליצור שני סוגים של מקלדות:

תשובה - המקלדת הראשית, הרגילה, שנמצאת מתחת ללוח הזנת טקסט ההודעה. מקלדת כזו פשוט שולחת הודעת טקסט לבוט, וכטקסט היא תשלח את הטקסט שכתוב על הכפתור עצמו.
Inline - מקלדת המשויכת להודעת בוט ספציפית. מקלדת זו שולחת את נתוני הבוט המשויכים לכפתור הנלחץ; נתונים אלו עשויים להיות שונים מהטקסט שנכתב על הכפתור עצמו. וכפתורים כאלה מעובדים דרך CallbackQueryHandler.

על מנת שהבוט יפתח את המקלדת, יש צורך בעת שליחת הודעה באמצעות השיטה sendMessage(), העבר את המקלדת שנוצרה קודם לכן כארגומנט reply_markup.

להלן נסתכל על מספר דוגמאות.

מקלדת תשובה

כפי שכתבתי למעלה, זוהי מקלדת השליטה הראשית של הבוט.

דוגמה ליצירת מקלדת תשובה מהעזרה הרשמית

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)

האמור לעיל הוא דוגמה מהעזרה הרשמית של החבילה telegram.bot. כדי ליצור מקלדת, השתמש בפונקציה ReplyKeyboardMarkup(), אשר בתורו לוקח רשימה של רשימות של לחצנים שנוצרו על ידי הפונקציה KeyboardButton().

למה ב ReplyKeyboardMarkup() האם אתה צריך לעבור לא רק רשימה, אלא רשימה של רשימות? העובדה היא שאתה עובר את הרשימה הראשית, ובה אתה מגדיר כל שורת כפתורים ברשימות נפרדות, כי ניתן למקם מספר כפתורים בשורה אחת.

טיעון resize_keyboard מאפשר לך לבחור אוטומטית את הגודל האופטימלי של לחצני המקלדת, ואת הארגומנט one_time_keyboard מאפשר לך להסתיר את המקלדת לאחר כל לחיצה על כפתור.

בוא נכתוב בוט פשוט שיהיו לו 3 כפתורים:

מזהה צ'אט - בקש מזהה צ'אט של דיאלוג עם בוט
השם שלי - בקש את שמך
הכניסה שלי - בקש את שם המשתמש שלך בטלגרם

קוד 1: בוט פשוט עם מקלדת תשובה

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()

הפעל את דוגמת הקוד למעלה, לאחר החלפת 'YOUR BOT TOKEN' באסימון האמיתי שקיבלת בעת יצירת הבוט באמצעות BotFather (דיברתי על יצירת בוט ב מאמר ראשון).

לאחר ההשקה, תן לבוט פקודה /start, כי זה בדיוק מה שהגדרנו להפעלת המקלדת.

אם כרגע קשה לך לנתח את דוגמת הקוד הנתונה, עם יצירת שיטות, מסננים ומטפלים, עליך לחזור לקודמתה статье, שבו תיארתי את כל זה בהרחבה.

יצרנו 4 שיטות:

התחל - הפעל את המקלדת
chat_id - בקש מזהה צ'אט
my_name - בקש את שמך
my_username - בקש את הכניסה שלך

להתנגד מסנני הודעות הוסיפו 3 מסנני הודעות על סמך הטקסט שלהם:

chat_id - הודעות עם טקסט "Чат ID"
שם — הודעות עם טקסט "Моё имя"
שם משתמש — הודעות עם טקסט "Мой логин"

ויצרנו 4 מטפלים אשר בהתבסס על פקודות ומסננים נתונים יבצעו את השיטות שצוינו.

# создаём обработчики
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)

המקלדת עצמה נוצרת בתוך השיטה start() על ידי צוות ReplyKeyboardMarkup().

RKM <- ReplyKeyboardMarkup(
    keyboard = list(
      list(KeyboardButton("Чат ID")),
      list(KeyboardButton("Моё имя")),
      list(KeyboardButton("Мой логин"))
    ),
    resize_keyboard = FALSE,
    one_time_keyboard = TRUE
)

במקרה שלנו, שמנו את כל הכפתורים אחד מתחת לשני, אבל אנחנו יכולים לסדר אותם בשורה אחת על ידי ביצוע שינויים ברשימת רשימות הכפתורים. כי שורה אחת בתוך המקלדת נוצרת דרך רשימה מקוננת של כפתורים, ואז כדי להציג את הכפתורים שלנו בשורה אחת אנחנו צריכים לשכתב חלק מהקוד לבניית המקלדת כך:

RKM <- ReplyKeyboardMarkup(
    keyboard = list(
      list(
          KeyboardButton("Чат ID"),
          KeyboardButton("Моё имя"),
          KeyboardButton("Мой логин")
     )
    ),
    resize_keyboard = FALSE,
    one_time_keyboard = TRUE
)

המקלדת נשלחת לצ'אט בשיטה sendMessage(), בטיעון reply_markup.

  bot$sendMessage(update$message$chat_id,
                  text = 'Выберите команду', 
                  reply_markup = RKM)

מקלדת מוטבעת

כפי שכתבתי למעלה, המקלדת המוטבעת קשורה להודעה ספציפית. זה קצת יותר קשה לעבוד עם המקלדת הראשית.

בתחילה, עליך להוסיף שיטה לבוט כדי לקרוא למקלדת המוטבעת.

כדי להגיב ללחיצת כפתור מוטבע, אתה יכול גם להשתמש בשיטת הבוט answerCallbackQuery(), שיכול להציג התראה בממשק הטלגרם למשתמש שלוחץ על כפתור Inline.

הנתונים הנשלחים מהלחצן המוטבע אינם טקסט, אז כדי לעבד אותם אתה צריך ליצור מטפל מיוחד באמצעות הפקודה CallbackQueryHandler().

הקוד לבניית מקלדת Inline אשר ניתן בעזרה הרשמית של החבילה telegram.bot.

קוד לבניית מקלדת מוטבעת מהעזרה הרשמית

# 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)

אתה צריך לבנות מקלדת מוטבעת באמצעות הפקודה InlineKeyboardMarkup(), על אותו עיקרון כמו מקלדת התשובות. IN InlineKeyboardMarkup() יש צורך להעביר רשימה של רשימות של לחצנים מוטבעים, כל כפתור בודד נוצר על ידי הפונקציה InlineKeyboardButton().

כפתור מוטבע יכול להעביר נתונים מסוימים לבוט באמצעות ארגומנט callback_data, או פתח כל דף HTML שצוין באמצעות הארגומנט url.

התוצאה תהיה רשימה שבה כל אלמנט הוא גם רשימה של כפתורי Inline שצריך לשלב לשורה אחת.

בשלב הבא נסתכל על מספר דוגמאות של בוטים עם כפתורי Inline.

דוגמה לבוט פשוט עם תמיכה בכפתורי InLine

ראשית, נכתוב בוט לבדיקות אקספרס לקוביד-19. לפי פקודה /test, זה ישלח לך מקלדת עם שני כפתורים, בהתאם לכפתור שנלחץ זה ישלח לך הודעה עם תוצאות הבדיקה שלך.

קוד 2: הבוט הפשוט ביותר עם מקלדת מוטבעת

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()

הפעל את דוגמת הקוד למעלה, לאחר החלפת 'YOUR BOT TOKEN' באסימון האמיתי שקיבלת בעת יצירת הבוט באמצעות BotFather (דיברתי על יצירת בוט ב מאמר ראשון).

תוצאה:

יצרנו שתי שיטות:

מבחן — כדי לשלוח לצ'אט מקלדת מוטבעת
answer_cb — לעיבוד נתונים שנשלחו מהמקלדת.

הנתונים שיישלחו מכל כפתור מצוינים בארגומנט callback_data, בעת יצירת כפתור. אתה יכול לקבל את הנתונים שנשלחו מהכפתור באמצעות המבנה update$callback_query$data, בתוך השיטה answer_cb.

כדי שהבוט יגיב למקלדת המוטבעת, שיטה answer_cb מעובד על ידי מטפל מיוחד: CallbackQueryHandler(answer_cb). אשר מריץ את השיטה שצוינה כאשר לוחצים על הלחצן Inline. מטפל CallbackQueryHandler לוקח שני טיעונים:

callback — השיטה שצריך להפעיל
pattern - סנן לפי נתונים המחוברים ללחצן באמצעות ארגומנט callback_data.

לפיכך, תוך שימוש בטיעון pattern נוכל לכתוב שיטה נפרדת ללחיצה על כל כפתור:

קוד 3: שיטות נפרדות לכל כפתור מוטבע

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()

הפעל את דוגמת הקוד למעלה, לאחר החלפת 'YOUR BOT TOKEN' באסימון האמיתי שקיבלת בעת יצירת הבוט באמצעות BotFather (דיברתי על יצירת בוט ב מאמר ראשון).

עכשיו כתבנו 2 שיטות נפרדות כלומר. שיטה אחת, כל כפתור נלחץ והשתמש בארגומנט pattern, בעת יצירת המטפלים שלהם:

query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no  <- CallbackQueryHandler(answer_cb_no, pattern = 'no')

קוד השיטה מסתיים answer_cb על ידי צוות bot$answerCallbackQuery(callback_query_id = update$callback_query$id), שאומר לבוט שהתקבלו נתונים מהמקלדת המוטבעת.

דוגמה לבוט המדווח על מזג האוויר הנוכחי עבור עיר נבחרת

בואו ננסה לכתוב בוט שמבקש נתוני מזג אוויר.

ההיגיון של עבודתו יהיה כדלקמן. בתחילה על ידי הצוות /start אתה קורא למקלדת הראשית, שיש לה רק כפתור "מזג אוויר" אחד. בלחיצה על כפתור זה תקבל הודעה עם המקלדת המוטבעת לבחירת העיר שעבורה תרצה לברר את מזג האוויר הנוכחי. בחר אחת מהערים וקבל את מזג האוויר הנוכחי.

בדוגמה זו נשתמש במספר חבילות נוספות:

httr — חבילה לעבודה עם בקשות HTTP, שעל בסיסה נבנית עבודה עם כל API. במקרה שלנו נשתמש ב-API החינמי openweathermap.org.
stringr — חבילה לעבודה עם טקסט, במקרה שלנו נשתמש בה כדי ליצור הודעה על מזג האוויר בעיר שנבחרה.

קוד 4: בוט שמדווח על מזג האוויר הנוכחי עבור העיר שנבחרה

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()

הפעל את דוגמת הקוד למעלה, לאחר החלפת 'YOUR BOT TOKEN' באסימון האמיתי שקיבלת בעת יצירת הבוט באמצעות BotFather (דיברתי על יצירת בוט ב מאמר ראשון).

כתוצאה מכך, הבוט שלנו יעבוד בערך כך:

באופן סכמטי, ניתן לתאר את הבוט הזה כך:

יצרנו 3 שיטות זמינות בתוך בוט מזג האוויר שלנו:

התחלה - הפעל את מקלדת הבוט הראשית
מזג אוויר — הפעל את המקלדת המוטבעת כדי לבחור עיר
answer_cb - השיטה העיקרית המבקשת את מזג האוויר מה-API עבור עיר נתונה ושולחת אותו לצ'אט.

שיטה התחלה אנו מפעילים אותו עם הפקודה /start, אשר מיושם על ידי המטפל CommandHandler('start', start).

להפעיל שיטה מזג אוויר יצרנו מסנן באותו שם:

# создаём фильтры
## сообщения с текстом Погода
MessageFilters$weather <- BaseFilter(function(message) {

  # проверяем текст сообщения
  message$text == "Погода"

}
)

ואנחנו קוראים לשיטה הזו עם מטפל ההודעות הבא: MessageHandler(weather, filters = MessageFilters$weather).

ובסופו של דבר, השיטה העיקרית שלנו answer_cb מגיב ללחיצה על כפתורי Inline, אשר מיושם על ידי מטפל מיוחד: CallbackQueryHandler(answer_cb).

בתוך שיטה answer_cb, אנו קוראים את הנתונים שנשלחו מהמקלדת וכותבים אותם למשתנה city: city <- update$callback_query$data. לאחר מכן אנו מבקשים נתוני מזג אוויר מה-API, יוצרים ושולחים הודעה, ולבסוף משתמשים בשיטה answerCallbackQuery על מנת ליידע את הבוט שעיבדנו את הלחיצה על כפתור ה-Inline.

דוגמה לבוט שמציג רשימה של המאמרים העדכניים ביותר עם קישורים למרכז שצוין מ www.habr.com.

אני מציג את הבוט הזה כדי להראות לך כיצד להציג כפתורים מוטבעים המובילים לדפי אינטרנט.

ההיגיון של הבוט הזה דומה לקודם; בתחילה אנו מפעילים את המקלדת הראשית עם הפקודה /start. לאחר מכן, הבוט נותן לנו רשימה של 6 רכזות לבחירה, אנו בוחרים את הרכזת בה אנו מעוניינים, ומקבלים את 5 הפרסומים העדכניים ביותר מה-Hub הנבחר.

כפי שאתה מבין, במקרה זה אנו צריכים לקבל רשימה של מאמרים, ולשם כך נשתמש בחבילה מיוחדת habR, המאפשר לבקש מאמרים מהברא וקצת סטטיסטיקות עליהם בר.

התקן חבילה habR אפשרי רק מ-github, שעבורו תצטרך חבילה נוספת devtools. כדי להתקין, השתמש בקוד שלהלן.

install.packages('devtools')
devtools::install_github('selesnow/habR')

כעת נסתכל על הקוד לבניית הבוט המתואר לעיל:

קוד 5: בוט שמציג רשימה של המאמרים העדכניים ביותר ב-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()

הפעל את דוגמת הקוד למעלה, לאחר החלפת 'YOUR BOT TOKEN' באסימון האמיתי שקיבלת בעת יצירת הבוט באמצעות BotFather (דיברתי על יצירת בוט ב מאמר ראשון).

כתוצאה מכך, נקבל את התוצאה הזו:

קידוד קשיח את רשימת הרכזות הזמינות לבחירה בשיטה 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)
}

אנו מקבלים רשימה של מאמרים מה-Hub שצוין עם הפקודה habr_hub_posts(), מהחבילה habR. יחד עם זאת, אנו מציינים כי איננו זקוקים לרשימת מאמרים לכל הזמן, אלא רק לעמוד הראשון בו נמצאים 20 מאמרים. מהטבלה שהתקבלה באמצעות הפקודה head() אנו משאירים רק את 5 המובילים, שהם הכתבות העדכניות ביותר.

  # парсим Хабр
  posts <- head(habr_hub_posts(hub, 1), 5)

ההיגיון דומה מאוד לבוט הקודם, אך במקרה זה אנו יוצרים מקלדת Inline עם רשימת מאמרים באופן דינמי באמצעות הפונקציה lapply().

  # формируем список кнопок
  keys <- lapply(1:5, function(x) list(InlineKeyboardButton(posts$title[x], url = posts$link[x])))

  # формируем клавиатуру
  IKM <- InlineKeyboardMarkup(
    inline_keyboard =  keys 
    )

אנו מכניסים את כותרת המאמר לטקסט הכפתור posts$title[x], ובטיעון url קישור למאמר: url = posts$link[x].

לאחר מכן, אנו יוצרים מסנן, מטפלים ומשיקים את הבוט שלנו.

מסקנה

כעת הבוטים שתכתבו יהיו הרבה יותר נוחים לשימוש, בשל העובדה שהם ישלטו מהמקלדת, ולא באמצעות הזנת פקודות. לכל הפחות, בעת אינטראקציה עם בוט דרך סמארטפון, המקלדת תפשט משמעותית את תהליך השימוש בה.

במאמר הבא נבין כיצד לבנות דיאלוג לוגי עם בוט ולעבוד עם מסדי נתונים.

מקור: www.habr.com

כתיבת בוט טלגרם ב-R (חלק 3): כיצד להוסיף תמיכה במקלדת לבוט

כל הכתבות מהסדרה "כתיבת בוט טלגרם ב-R"

תוכן

באילו סוגי מקלדות תומך בוט הטלגרם?

מקלדת תשובה

מקלדת מוטבעת

דוגמה לבוט פשוט עם תמיכה בכפתורי InLine

דוגמה לבוט המדווח על מזג האוויר הנוכחי עבור עיר נבחרת

דוגמה לבוט שמציג רשימה של המאמרים העדכניים ביותר עם קישורים למרכז שצוין מ www.habr.com.

מסקנה

הוספת תגובה ביטול תגובה