यह "आर में टेलीग्राम बॉट लिखना" श्रृंखला का तीसरा लेख है। पिछले प्रकाशनों में, हमने सीखा कि टेलीग्राम बॉट कैसे बनाया जाता है, इसके माध्यम से संदेश कैसे भेजे जाते हैं, बॉट में कमांड और संदेश फ़िल्टर कैसे जोड़े जाते हैं। इसलिए, इससे पहले कि आप इस लेख को पढ़ना शुरू करें, मैं अत्यधिक अनुशंसा करता हूं कि आप पढ़ें पहले का, क्योंकि यहां मैं अब बॉट बिल्डिंग की पहले वर्णित बुनियादी बातों पर ध्यान नहीं दूंगा।

इस लेख में, हम एक कीबोर्ड जोड़कर अपने बॉट की उपयोगिता में सुधार करेंगे, जो बॉट इंटरफ़ेस को सहज और उपयोग में आसान बना देगा।

श्रृंखला के सभी लेख "आर में टेलीग्राम बॉट लिखना"

1. हम एक बॉट बनाते हैं और टेलीग्राम में संदेश भेजने के लिए इसका उपयोग करते हैं
2. बॉट में कमांड समर्थन और संदेश फ़िल्टर जोड़ें
3. बॉट में कीबोर्ड सपोर्ट कैसे जोड़ें

सामग्री

यदि आप डेटा विश्लेषण में रुचि रखते हैं, तो आपको मेरी रुचि भी हो सकती है तार и यूट्यूब चैनल. अधिकांश सामग्री आर भाषा को समर्पित है।

1. टेलीग्राम बॉट किस प्रकार के कीबोर्ड का समर्थन करता है?
2. उत्तर कुंजीपटल
3. इनलाइन कीबोर्ड
   3.1. इनलाइन बटन के समर्थन के साथ एक साधारण बॉट का एक उदाहरण
   3.2. बॉट का एक उदाहरण जो किसी चयनित शहर के वर्तमान मौसम की रिपोर्ट देता है
   3.3. बॉट का एक उदाहरण जो habr.com से निर्दिष्ट हब के लिंक के साथ नवीनतम लेखों की एक सूची प्रदर्शित करता है
4. निष्कर्ष

टेलीग्राम बॉट किस प्रकार के कीबोर्ड का समर्थन करता है?

इस लेखन के समय telegram.bot आपको दो प्रकार के कीबोर्ड बनाने की अनुमति देता है:

• उत्तर - मुख्य, नियमित कीबोर्ड, जो संदेश टेक्स्ट इनपुट पैनल के नीचे स्थित है। ऐसा कीबोर्ड बस बॉट को एक टेक्स्ट संदेश भेजता है, और टेक्स्ट के रूप में यह बटन पर लिखे टेक्स्ट को ही भेजेगा।
• इनलाइन - एक विशिष्ट बॉट संदेश से जुड़ा कीबोर्ड। यह कीबोर्ड दबाए गए बटन से जुड़ा बॉट डेटा भेजता है; यह डेटा बटन पर लिखे टेक्स्ट से भिन्न हो सकता है। और ऐसे बटन के माध्यम से प्रोसेस किया जाता है कॉलबैकक्वेरीहैंडलर.

विधि के माध्यम से संदेश भेजते समय बॉट के लिए कीबोर्ड खोलना आवश्यक है 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()

बॉट बनाते समय प्राप्त वास्तविक टोकन के साथ 'आपके बॉट टोकन' को बदलने के बाद, उपरोक्त कोड उदाहरण चलाएँ बोटफादर (मैंने इसमें एक बॉट बनाने के बारे में बात की थी पहला लेख).

लॉन्च करने के बाद, बॉट को एक कमांड दें /start, क्योंकि यह बिल्कुल वही है जिसे हमने कीबोर्ड लॉन्च करने के लिए परिभाषित किया है।

यदि इस समय आपके लिए विधियों, फ़िल्टर और हैंडलर के निर्माण के साथ दिए गए कोड उदाहरण को पार्स करना मुश्किल है, तो आपको पिछले वाले पर वापस लौटना चाहिए लेखजिसमें मैंने इन सबका विस्तार से वर्णन किया है।

हमने 4 विधियाँ बनाईं:

• प्रारंभ - कीबोर्ड लॉन्च करें
• चैट_आईडी - चैट आईडी का अनुरोध करें
• मेरा_नाम - अपना नाम अनुरोध करें
• my_username - अपने लॉगिन का अनुरोध करें

वस्तु के लिए संदेशफ़िल्टर उनके पाठ के आधार पर 3 संदेश फ़िल्टर जोड़े गए:

• चैट_आईडी - टेक्स्ट वाले संदेश "Чат 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(), जो इनलाइन बटन दबाने वाले उपयोगकर्ता को टेलीग्राम इंटरफ़ेस में एक अधिसूचना प्रदर्शित कर सकता है।

इनलाइन बटन से भेजा गया डेटा टेक्स्ट नहीं है, इसलिए इसे संसाधित करने के लिए आपको कमांड का उपयोग करके एक विशेष हैंडलर बनाने की आवश्यकता है CallbackQueryHandler().

इनलाइन कीबोर्ड बनाने का कोड जो पैकेज की आधिकारिक सहायता में दिया गया है 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(), रिप्लाई कीबोर्ड के समान सिद्धांत पर। में InlineKeyboardMarkup() इनलाइन बटनों की सूचियों की सूची पास करना आवश्यक है, प्रत्येक व्यक्तिगत बटन फ़ंक्शन द्वारा बनाया जाता है InlineKeyboardButton().

एक इनलाइन बटन या तो एक तर्क का उपयोग करके बॉट को कुछ डेटा भेज सकता है callback_data, या तर्क का उपयोग करके निर्दिष्ट कोई भी HTML पृष्ठ खोलें url.

परिणाम एक सूची होगी जिसमें प्रत्येक तत्व इनलाइन बटनों की एक सूची भी होगी जिन्हें एक पंक्ति में संयोजित करने की आवश्यकता है।

आगे हम इनलाइन बटन वाले बॉट्स के कई उदाहरण देखेंगे।

इनलाइन बटन के समर्थन के साथ एक साधारण बॉट का एक उदाहरण

सबसे पहले, हम कोविड-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()

बॉट बनाते समय प्राप्त वास्तविक टोकन के साथ 'आपके बॉट टोकन' को बदलने के बाद, उपरोक्त कोड उदाहरण चलाएँ बोटफादर (मैंने इसमें एक बॉट बनाने के बारे में बात की थी पहला लेख).

रिजल्ट:

हमने दो विधियाँ बनाईं:

• परीक्षण — चैट इनलाइन कीबोर्ड पर भेजने के लिए
• उत्तर_सीबी -कीबोर्ड से भेजे गए डेटा को प्रोसेस करने के लिए।

प्रत्येक बटन से जो डेटा भेजा जाएगा वह तर्क में निर्दिष्ट है callback_data, एक बटन बनाते समय। आप कंस्ट्रक्ट का उपयोग करके बटन से भेजा गया डेटा प्राप्त कर सकते हैं update$callback_query$data, विधि के अंदर उत्तर_सीबी.

बॉट के लिए इनलाइन कीबोर्ड पर प्रतिक्रिया करने के लिए विधि उत्तर_सीबी एक विशेष हैंडलर द्वारा संसाधित: CallbackQueryHandler(answer_cb). जो इनलाइन बटन पर क्लिक करने पर निर्दिष्ट विधि चलाता है। हैंडलर कॉलबैकक्वेरीहैंडलर दो तर्क लेता है:

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

बॉट बनाते समय प्राप्त वास्तविक टोकन के साथ 'आपके बॉट टोकन' को बदलने के बाद, उपरोक्त कोड उदाहरण चलाएँ बोटफादर (मैंने इसमें एक बॉट बनाने के बारे में बात की थी पहला लेख).

अब हमने 2 अलग-अलग विधियाँ लिखी हैं अर्थात् प्रत्येक बटन दबाने के लिए एक विधि, और तर्क का उपयोग किया pattern, उनके हैंडलर बनाते समय:

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

विधि कोड समाप्त होता है उत्तर_सीबी टीम bot$answerCallbackQuery(callback_query_id = update$callback_query$id), जो बॉट को बताता है कि इनलाइन कीबोर्ड से डेटा प्राप्त हो गया है।

बॉट का एक उदाहरण जो किसी चयनित शहर के वर्तमान मौसम की रिपोर्ट देता है

आइए एक बॉट लिखने का प्रयास करें जो मौसम डेटा का अनुरोध करता है।

इसके कार्य का तर्क इस प्रकार होगा. शुरुआत में टीम द्वारा /start आप मुख्य कीबोर्ड को कॉल करते हैं, जिसमें केवल एक "मौसम" बटन होता है। इस बटन पर क्लिक करते ही आपको इनलाइन कीबोर्ड से एक संदेश प्राप्त होगा कि आप उस शहर का चयन करें जिसके लिए आप वर्तमान मौसम का पता लगाना चाहते हैं। किसी एक शहर का चयन करें और वर्तमान मौसम की जानकारी प्राप्त करें।

इस कोड उदाहरण में हम कई अतिरिक्त पैकेजों का उपयोग करेंगे:

• httr — HTTP अनुरोधों के साथ काम करने के लिए एक पैकेज, जिसके आधार पर किसी भी एपीआई के साथ काम किया जाता है। हमारे मामले में हम निःशुल्क एपीआई का उपयोग करेंगे 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()

बॉट बनाते समय प्राप्त वास्तविक टोकन के साथ 'आपके बॉट टोकन' को बदलने के बाद, उपरोक्त कोड उदाहरण चलाएँ बोटफादर (मैंने इसमें एक बॉट बनाने के बारे में बात की थी पहला लेख).

परिणामस्वरूप, हमारा बॉट कुछ इस तरह काम करेगा:

योजनाबद्ध रूप से, इस बॉट को इस प्रकार चित्रित किया जा सकता है:

हमने अपने मौसम बॉट के अंदर उपलब्ध 3 विधियाँ बनाई हैं:

• प्रारंभ - मुख्य बॉट कीबोर्ड लॉन्च करें
• मौसम - शहर का चयन करने के लिए इनलाइन कीबोर्ड लॉन्च करें
• उत्तर_सीबी - मुख्य विधि जो किसी दिए गए शहर के लिए एपीआई से मौसम का अनुरोध करती है और इसे चैट पर भेजती है।

विधि प्रारंभ हम इसे कमांड के साथ लॉन्च करते हैं /start, जिसे हैंडलर द्वारा कार्यान्वित किया जाता है CommandHandler('start', start).

एक विधि चलाने के लिए मौसम हमने इसी नाम का एक फ़िल्टर बनाया:

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

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

}
)

और हम इस विधि को निम्नलिखित संदेश हैंडलर के साथ कॉल करते हैं: MessageHandler(weather, filters = MessageFilters$weather).

और अंत में, हमारी मुख्य विधि उत्तर_सीबी इनलाइन बटन दबाने पर प्रतिक्रिया करता है, जिसे एक विशेष हैंडलर द्वारा कार्यान्वित किया जाता है: CallbackQueryHandler(answer_cb).

एक विधि के अंदर उत्तर_सीबी, हम कीबोर्ड से भेजे गए डेटा को पढ़ते हैं और इसे एक वेरिएबल में लिखते हैं city: city <- update$callback_query$data. फिर हम एपीआई से मौसम डेटा का अनुरोध करते हैं, एक संदेश बनाते हैं और भेजते हैं, और अंत में विधि का उपयोग करते हैं answerCallbackQuery बॉट को सूचित करने के लिए कि हमने इनलाइन बटन पर क्लिक संसाधित किया है।

बॉट का एक उदाहरण जो निर्दिष्ट हब के लिंक के साथ नवीनतम लेखों की एक सूची प्रदर्शित करता है www.habr.com.

मैं यह बॉट आपको यह दिखाने के लिए प्रस्तुत कर रहा हूं कि वेब पेजों तक ले जाने वाले इनलाइन बटन कैसे प्रदर्शित करें।

इस बॉट का तर्क पिछले बॉट के समान है; प्रारंभ में हम कमांड के साथ मुख्य कीबोर्ड लॉन्च करते हैं /start. इसके बाद, बॉट हमें चुनने के लिए 6 हब की एक सूची देता है, हम उस हब का चयन करते हैं जिसमें हम रुचि रखते हैं, और चयनित हब से 5 सबसे हालिया प्रकाशन प्राप्त करते हैं।

जैसा कि आप समझते हैं, इस मामले में हमें लेखों की एक सूची प्राप्त करने की आवश्यकता है, और इसके लिए हम एक विशेष पैकेज का उपयोग करेंगे habR, जो आपको हाबरा से लेखों और आर में उन पर कुछ आंकड़ों का अनुरोध करने की अनुमति देता है।

पैकेज स्थापित करे habR यह केवल github से ही संभव है, जिसके लिए आपको एक अतिरिक्त पैकेज की आवश्यकता होगी devtools. इंस्टॉल करने के लिए, नीचे दिए गए कोड का उपयोग करें।

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

अब आइए ऊपर वर्णित बॉट के निर्माण के लिए कोड देखें:

कोड 5: एक बॉट जो चयनित हब पर नवीनतम लेखों की सूची प्रदर्शित करता है

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

बॉट बनाते समय प्राप्त वास्तविक टोकन के साथ 'आपके बॉट टोकन' को बदलने के बाद, उपरोक्त कोड उदाहरण चलाएँ बोटफादर (मैंने इसमें एक बॉट बनाने के बारे में बात की थी पहला लेख).

परिणामस्वरूप, हमें यह परिणाम मिलेगा:

हमने विधि में चयन के लिए उपलब्ध हब की सूची को हार्डकोड किया है 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)
}

हमें कमांड के साथ निर्दिष्ट हब से लेखों की एक सूची मिलती है habr_hub_posts(), पैकेज से habR. साथ ही, हम बताते हैं कि हमें पूरे समय के लिए लेखों की सूची की आवश्यकता नहीं है, बल्कि केवल पहले पृष्ठ की आवश्यकता है जिस पर 20 लेख स्थित हैं। कमांड का उपयोग करके परिणामी तालिका से head() हम केवल शीर्ष 5 को छोड़ते हैं, जो सबसे हाल के लेख हैं।

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

तर्क पिछले बॉट के समान है, लेकिन इस मामले में हम फ़ंक्शन का उपयोग करके गतिशील रूप से लेखों की सूची के साथ एक इनलाइन कीबोर्ड उत्पन्न करते हैं 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