"आर मध्ये टेलिग्राम बॉट लिहिणे" या मालिकेतील हा तिसरा लेख आहे. मागील प्रकाशनांमध्ये, आम्ही टेलीग्राम बॉट कसा बनवायचा, त्याद्वारे संदेश कसे पाठवायचे, बॉटमध्ये कमांड्स आणि मेसेज फिल्टर कसे जोडायचे हे शिकलो. म्हणून, आपण हा लेख वाचण्यास प्रारंभ करण्यापूर्वी, मी शिफारस करतो की आपण वाचा मागील, कारण येथे मी यापुढे बॉट बिल्डिंगच्या पूर्वी वर्णन केलेल्या मूलभूत गोष्टींवर लक्ष ठेवणार नाही.

या लेखात, आम्ही कीबोर्ड जोडून आमच्या बॉटची उपयोगिता सुधारू, ज्यामुळे बॉट इंटरफेस अंतर्ज्ञानी आणि वापरण्यास सुलभ होईल.

"आर मध्ये टेलिग्राम बॉट लिहिणे" या मालिकेतील सर्व लेख

1. आम्ही एक बॉट तयार करतो आणि त्याचा वापर टेलीग्राममध्ये संदेश पाठवण्यासाठी करतो
2. बॉटमध्ये कमांड सपोर्ट आणि मेसेज फिल्टर्स जोडा
3. बॉटमध्ये कीबोर्ड सपोर्ट कसा जोडायचा

सामग्री

तुम्हाला डेटा विश्लेषणामध्ये स्वारस्य असल्यास, तुम्हाला माझ्यामध्ये स्वारस्य असेल तार и YouTube चॅनेल बहुतेक सामग्री आर भाषेला समर्पित आहे.

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

टेलिग्राम बॉट कोणत्या प्रकारच्या कीबोर्डना सपोर्ट करतो?

या लेखनाच्या वेळी telegram.bot तुम्हाला दोन प्रकारचे कीबोर्ड तयार करण्याची परवानगी देते:

• प्रत्युत्तर - मुख्य, नियमित कीबोर्ड, जो संदेश मजकूर इनपुट पॅनेल अंतर्गत स्थित आहे. असा कीबोर्ड बोटाला फक्त मजकूर संदेश पाठवतो आणि मजकूर म्हणून तो बटणावरच लिहिलेला मजकूर पाठवेल.
• इनलाइन - विशिष्ट बॉट संदेशाशी संबंधित कीबोर्ड. हा कीबोर्ड दाबलेल्या बटणाशी संबंधित बॉट डेटा पाठवतो; हा डेटा बटणावर लिहिलेल्या मजकुरापेक्षा वेगळा असू शकतो. आणि अशा बटणांवर प्रक्रिया केली जाते 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' च्या जागी तुम्हाला बॉट तयार करताना मिळालेल्या वास्तविक टोकनने बॉट फेदर (मी मध्ये बॉट तयार करण्याबद्दल बोललो पहिला लेख).

लाँच केल्यानंतर, बॉटला कमांड द्या /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(), जे इनलाइन बटण दाबणाऱ्या वापरकर्त्याला टेलिग्राम इंटरफेसमध्ये सूचना प्रदर्शित करू शकते.

इनलाइन बटणावरून पाठवलेला डेटा मजकूर नसतो, त्यामुळे त्यावर प्रक्रिया करण्यासाठी तुम्हाला कमांड वापरून विशेष हँडलर तयार करणे आवश्यक आहे 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(), रिप्लाय कीबोर्डच्या समान तत्त्वावर. IN 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()

वरील कोड उदाहरण चालवा, 'YOUR BOT TOKEN' च्या जागी तुम्हाला बॉट तयार करताना मिळालेल्या वास्तविक टोकनने बॉट फेदर (मी मध्ये बॉट तयार करण्याबद्दल बोललो पहिला लेख).

निकाल:

आम्ही दोन पद्धती तयार केल्या आहेत:

• चाचणी — चॅट इनलाइन कीबोर्डवर पाठवण्यासाठी
• उत्तर_सीबी — कीबोर्डवरून पाठवलेल्या डेटावर प्रक्रिया करण्यासाठी.

प्रत्येक बटणावरून पाठवलेला डेटा वितर्कात निर्दिष्ट केला आहे callback_data, बटण तयार करताना. तुम्ही कन्स्ट्रक्ट वापरून बटणावरून पाठवलेला डेटा प्राप्त करू शकता update$callback_query$data, पद्धतीच्या आत उत्तर_सीबी.

बॉटने इनलाइन कीबोर्डवर प्रतिक्रिया देण्यासाठी, पद्धत उत्तर_सीबी विशेष हँडलरद्वारे प्रक्रिया केली जाते: CallbackQueryHandler(answer_cb). जे इनलाइन बटण क्लिक केल्यावर निर्दिष्ट पद्धत चालवते. हाताळणारा 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' च्या जागी तुम्हाला बॉट तयार करताना मिळालेल्या वास्तविक टोकनने बॉट फेदर (मी मध्ये बॉट तयार करण्याबद्दल बोललो पहिला लेख).

आता आम्ही 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 विनंत्यांसह कार्य करण्यासाठी पॅकेज, ज्याच्या आधारावर कोणत्याही 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' च्या जागी तुम्हाला बॉट तयार करताना मिळालेल्या वास्तविक टोकनने बॉट फेदर (मी मध्ये बॉट तयार करण्याबद्दल बोललो पहिला लेख).

परिणामी, आमचा बॉट असे काहीतरी कार्य करेल:

योजनाबद्धपणे, हा बॉट असे चित्रित केला जाऊ शकतो:

आम्ही आमच्या हवामान बॉटमध्ये उपलब्ध असलेल्या 3 पद्धती तयार केल्या आहेत:

• प्रारंभ - मुख्य बॉट कीबोर्ड लाँच करा
• हवामान — शहर निवडण्यासाठी इनलाइन कीबोर्ड लाँच करा
• उत्तर_सीबी — दिलेल्या शहरासाठी API कडून हवामानाची विनंती करणारी आणि चॅटवर पाठवणारी मुख्य पद्धत.

पद्धत प्रारंभ आम्ही ते कमांडसह लॉन्च करतो /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. मग आम्ही API कडून हवामान डेटाची विनंती करतो, संदेश तयार करतो आणि पाठवतो आणि शेवटी पद्धत वापरतो answerCallbackQuery बॉटला सूचित करण्यासाठी की आम्ही इनलाइन बटणाच्या क्लिकवर प्रक्रिया केली आहे.

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

वेब पृष्ठांवर नेणारी इनलाइन बटणे कशी प्रदर्शित करायची हे दाखवण्यासाठी मी हा बॉट सादर करतो.

या बॉटचे लॉजिक मागील प्रमाणेच आहे, सुरुवातीला आम्ही कमांडसह मुख्य कीबोर्ड लाँच करतो /start. पुढे, बॉट आम्हाला निवडण्यासाठी 6 हबची सूची देतो, आम्ही आम्हाला स्वारस्य असलेले हब निवडतो आणि निवडलेल्या हबमधून 5 सर्वात अलीकडील प्रकाशने प्राप्त करतो.

जसे आपण समजता, या प्रकरणात आम्हाला लेखांची सूची मिळणे आवश्यक आहे आणि यासाठी आम्ही एक विशेष पॅकेज वापरू habR, जे तुम्हाला हाब्रा कडील लेख आणि R मध्ये त्यांच्यावरील काही आकडेवारीची विनंती करण्यास अनुमती देते.

पॅकेज स्थापित करा 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()

वरील कोड उदाहरण चालवा, 'YOUR BOT TOKEN' च्या जागी तुम्हाला बॉट तयार करताना मिळालेल्या वास्तविक टोकनने बॉट फेदर (मी मध्ये बॉट तयार करण्याबद्दल बोललो पहिला लेख).

परिणामी, आम्हाला हा परिणाम मिळेल:

पद्धतीमध्ये निवडीसाठी उपलब्ध हबची यादी आम्ही हार्डकोड केली आहे 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