ეს არის მესამე სტატია სერიიდან „ტელეგრამის ბოტის დაწერა R-ში“. წინა პუბლიკაციებში ვისწავლეთ როგორ შევქმნათ ტელეგრამის ბოტი, გავგზავნოთ შეტყობინებები, დავამატეთ ბრძანებები და შეტყობინებების ფილტრები ბოტში. ამიტომ, სანამ ამ სტატიის კითხვას დაიწყებთ, გირჩევთ წაიკითხოთ წინა, იმიტომ აქ აღარ შევჩერდები ბოტების აგების ადრე აღწერილ საფუძვლებზე.

ამ სტატიაში ჩვენ გავაუმჯობესებთ ჩვენი ბოტის გამოყენებადობას კლავიატურის დამატებით, რაც ბოტის ინტერფეისს ინტუიციურს და მარტივ გამოყენებას გახდის.

ყველა სტატია სერიიდან "ტელეგრამის ბოტის დაწერა R-ში"

1. ჩვენ ვქმნით ბოტს და ვიყენებთ მას ტელეგრამაში შეტყობინებების გასაგზავნად
2. დაამატეთ ბრძანების მხარდაჭერა და შეტყობინებების ფილტრები ბოტში
3. როგორ დავამატოთ კლავიატურის მხარდაჭერა ბოტს

ინფორმაციის

თუ გაინტერესებთ მონაცემთა ანალიზი, შეიძლება დაგაინტერესოთ ჩემი დეპეშა и youtube არხები. შინაარსის უმეტესი ნაწილი ეძღვნება R ენას.

1. რა ტიპის კლავიატურებს უჭერს მხარს ტელეგრამის ბოტი?
2. პასუხის კლავიატურა
3. ინლაინ კლავიატურა
   3.1. მარტივი ბოტის მაგალითი InLine ღილაკების მხარდაჭერით
   3.2. ბოტის მაგალითი, რომელიც აცნობებს ამჟამინდელ ამინდს არჩეული ქალაქისთვის
   3.3. ბოტის მაგალითი, რომელიც აჩვენებს უახლესი სტატიების ჩამონათვალს habr.com-დან მითითებულ Hub-თან ბმულებით
4. დასკვნა

რა ტიპის კლავიატურებს უჭერს მხარს ტელეგრამის ბოტი?

ამ წერის დროს 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 ღილაკი:

• ჩატის ID - მოითხოვეთ ჩეთის ID ბოტთან დიალოგის შესახებ
• ჩემი სახელი - მოითხოვეთ თქვენი სახელი
• ჩემი შესვლა - მოითხოვეთ თქვენი მომხმარებლის სახელი ტელეგრამაში

კოდი 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 — მოითხოვეთ ჩატის 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)

ინლაინ კლავიატურა

როგორც ზემოთ დავწერე, Inline კლავიატურა მიბმულია კონკრეტულ შეტყობინებაზე. გარკვეულწილად უფრო რთულია მუშაობა, ვიდრე მთავარ კლავიატურაზე.

თავდაპირველად, თქვენ უნდა დაამატოთ მეთოდი ბოტს, რომ გამოიძახოთ Inline კლავიატურა.

Inline ღილაკზე დაწკაპუნებაზე საპასუხოდ, ასევე შეგიძლიათ გამოიყენოთ ბოტის მეთოდი answerCallbackQuery(), რომელსაც შეუძლია აჩვენოს შეტყობინება ტელეგრამის ინტერფეისში მომხმარებლისთვის, რომელიც დააჭერს Inline ღილაკს.

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)

თქვენ უნდა ააწყოთ Inline კლავიატურა ბრძანების გამოყენებით InlineKeyboardMarkup(), იგივე პრინციპით, როგორც Reply კლავიატურა. IN InlineKeyboardMarkup() აუცილებელია გაიაროთ Inline ღილაკების სიების სია, თითოეული ინდივიდუალური ღილაკი იქმნება ფუნქციით InlineKeyboardButton().

ინლაინ ღილაკს შეუძლია გარკვეული მონაცემების გადაცემა ბოტზე არგუმენტის გამოყენებით callback_dataან გახსენით ნებისმიერი HTML გვერდი, რომელიც მითითებულია არგუმენტის გამოყენებით url.

შედეგი იქნება სია, რომელშიც თითოეული ელემენტი ასევე არის Inline ღილაკების სია, რომლებიც უნდა გაერთიანდეს ერთ რიგში.

შემდეგ ჩვენ გადავხედავთ ბოტების რამდენიმე მაგალითს Inline ღილაკებით.

მარტივი ბოტის მაგალითი InLine ღილაკების მხარდაჭერით

პირველ რიგში, ჩვენ დავწერთ ბოტს კოვიდ-19-ის ექსპრეს ტესტირებისთვის. ბრძანებით /test, გამოგიგზავნით კლავიატურას ორი ღილაკით, დაჭერილი ღილაკიდან გამომდინარე გამოგიგზავნით შეტყობინებას თქვენი ტესტირების შედეგებით.

კოდი 2: უმარტივესი ბოტი Inline კლავიატურით

library(telegram.bot)

# создаём экземпляр класса Updater
updater <- Updater('ТОКЕН ВАШЕГО БОТА')

# метод для отправки InLine клавиатуры
test <- function(bot, update) {

  # создаём InLine клавиатуру
  IKM <- InlineKeyboardMarkup(
    inline_keyboard = list(
      list(
        InlineKeyboardButton("Да", callback_data = 'yes'),
        InlineKeyboardButton("Нет", callback_data = 'no')
      )
    )
  )

  # Отправляем клавиатуру в чат
  bot$sendMessage(update$message$chat_id, 
                  text = "Вы болете коронавирусом?", 
                  reply_markup = IKM)
}

# метод для обработки нажатия кнопки
answer_cb <- function(bot, update) {

  # полученные данные с кнопки
  data <- update$callback_query$data

  # получаем имя пользователя, нажавшего кнопку
  uname <- update$effective_user()$first_name

  # обработка результата
  if ( data == 'no' ) {

    msg <- paste0(uname, ", поздравляю, ваш тест на covid-19 отрицательный.")

  } else {

    msg <- paste0(uname, ", к сожалени ваш тест на covid-19 положительный.")

  }

  # Отправка сообщения
  bot$sendMessage(chat_id = update$from_chat_id(),
                  text = msg)

  # сообщаем боту, что запрос с кнопки принят
  bot$answerCallbackQuery(callback_query_id = update$callback_query$id) 
}

# создаём обработчики
inline_h      <- CommandHandler('test', test)
query_handler <- CallbackQueryHandler(answer_cb)

# добавляем обработчики в диспетчер
updater <- updater + inline_h + query_handler

# запускаем бота
updater$start_polling()

გაუშვით ზემოთ მოცემული კოდის მაგალითი, მას შემდეგ, რაც შეცვალეთ "YOUR BOT TOKEN" რეალური ჟეტონით, რომელიც მიიღეთ ბოტის მეშვეობით შექმნისას. BotFather (მე ვისაუბრე ბოტის შექმნაზე პირველი სტატია).

შედეგი:

ჩვენ შევქმენით ორი მეთოდი:

• ტესტი — ჩატში გასაგზავნად Inline კლავიატურა
• პასუხი_კბ — კლავიატურიდან გაგზავნილი მონაცემების დასამუშავებლად.

მონაცემები, რომლებიც გაიგზავნება თითოეული ღილაკიდან, მითითებულია არგუმენტში callback_data, ღილაკის შექმნისას. თქვენ შეგიძლიათ მიიღოთ ღილაკიდან გაგზავნილი მონაცემები კონსტრუქციის გამოყენებით update$callback_query$data, მეთოდის შიგნით პასუხი_კბ.

იმისათვის, რომ ბოტმა მოახდინოს რეაგირება Inline კლავიატურაზე, მეთოდი პასუხი_კბ დამუშავებულია სპეციალური დამმუშავებლის მიერ: CallbackQueryHandler(answer_cb). რომელიც აწარმოებს მითითებულ მეთოდს Inline ღილაკზე დაწკაპუნებისას. დამმუშავებელი CallbackQueryHandler იღებს ორ არგუმენტს:

• callback — მეთოდი, რომელიც უნდა გაუშვათ
• pattern — არგუმენტის გამოყენებით ღილაკზე მიბმული მონაცემების გაფილტვრა callback_data.

შესაბამისად არგუმენტის გამოყენებით pattern ჩვენ შეგვიძლია დავწეროთ თითოეული ღილაკის დაჭერის ცალკე მეთოდი:

კოდი 3: ცალკე მეთოდები თითოეული Inline ღილაკისთვის

library(telegram.bot)

# создаём экземпляр класса Updater
updater <- Updater('ТОКЕН ВАШЕГО БОТА')

# метод для отправки InLine клавиатуры
test <- function(bot, update) {  

  # создаём InLine клавиатуру
  IKM <- InlineKeyboardMarkup(
    inline_keyboard = list(
      list(
        InlineKeyboardButton("Да", callback_data = 'yes'),
        InlineKeyboardButton("Нет", callback_data = 'no')
      )
    )
  )

  # Отправляем клавиатуру в чат
  bot$sendMessage(update$message$chat_id, 
                  text = "Вы болете коронавирусом?", 
                  reply_markup = IKM)
}

# метод для обработки нажатия кнопки Да
answer_cb_yes <- function(bot, update) {

  # получаем имя пользователя, нажавшего кнопку
  uname <- update$effective_user()$first_name

  # обработка результата
  msg <- paste0(uname, ", к сожалени ваш текст на covid-19 положительный.")

  # Отправка сообщения
  bot$sendMessage(chat_id = update$from_chat_id(),
                  text = msg)

  # сообщаем боту, что запрос с кнопки принят
  bot$answerCallbackQuery(callback_query_id = update$callback_query$id) 
}

# метод для обработки нажатия кнопки Нет
answer_cb_no <- function(bot, update) {

  # получаем имя пользователя, нажавшего кнопку
  uname <- update$effective_user()$first_name

  msg <- paste0(uname, ", поздравляю, ваш текст на covid-19 отрицательный.")

  # Отправка сообщения
  bot$sendMessage(chat_id = update$from_chat_id(),
                  text = msg)

  # сообщаем боту, что запрос с кнопки принят
  bot$answerCallbackQuery(callback_query_id = update$callback_query$id) 
}

# создаём обработчики
inline_h          <- CommandHandler('test', test)
query_handler_yes <- CallbackQueryHandler(answer_cb_yes, pattern = 'yes')
query_handler_no  <- CallbackQueryHandler(answer_cb_no, pattern = 'no')

# добавляем обработчики в диспетчер
updater <- updater + 
            inline_h + 
            query_handler_yes +
            query_handler_no

# запускаем бота
updater$start_polling()

გაუშვით ზემოთ მოცემული კოდის მაგალითი, მას შემდეგ, რაც შეცვალეთ "YOUR BOT TOKEN" რეალური ჟეტონით, რომელიც მიიღეთ ბოტის მეშვეობით შექმნისას. BotFather (მე ვისაუბრე ბოტის შექმნაზე პირველი სტატია).

ახლა ჩვენ დავწერეთ 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), რომელიც ეუბნება ბოტს, რომ მონაცემები მიღებულია inline კლავიატურიდან.

ბოტის მაგალითი, რომელიც აცნობებს ამჟამინდელ ამინდს არჩეული ქალაქისთვის

შევეცადოთ დავწეროთ ბოტი, რომელიც ითხოვს ამინდის მონაცემებს.

მისი მუშაობის ლოგიკა შემდეგი იქნება. თავდაპირველად გუნდის მიერ /start თქვენ ურეკავთ მთავარ კლავიატურას, რომელსაც აქვს მხოლოდ ერთი ღილაკი „ამინდი“. ამ ღილაკზე დაწკაპუნებით თქვენ მიიღებთ შეტყობინებას Inline კლავიატურით, რომ აირჩიოთ ქალაქი, რომლისთვისაც გსურთ გაიგოთ მიმდინარე ამინდი. აირჩიეთ ერთ-ერთი ქალაქი და მიიღეთ მიმდინარე ამინდი.

ამ კოდის მაგალითში ჩვენ გამოვიყენებთ რამდენიმე დამატებით პაკეტს:

• 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 მეთოდი, რომელიც ხელმისაწვდომია ჩვენი ამინდის ბოტის შიგნით:

• დაწყება — გაუშვით მთავარი ბოტის კლავიატურა
• ამინდი — გაუშვით Inline კლავიატურა ქალაქის ასარჩევად
• პასუხი_კბ — მთავარი მეთოდი, რომელიც ითხოვს ამინდს API-დან მოცემული ქალაქისთვის და აგზავნის მას ჩატში.

მეთოდი დაწყება ჩვენ ვიწყებთ მას ბრძანებით /start, რომელსაც ახორციელებს დამმუშავებელი CommandHandler('start', start).

მეთოდის გასაშვებად ამინდი ჩვენ შევქმენით ამავე სახელწოდების ფილტრი:

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

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

}
)

და ჩვენ ვუწოდებთ ამ მეთოდს შემდეგი შეტყობინებების დამმუშავებლით: MessageHandler(weather, filters = MessageFilters$weather).

და ბოლოს, ჩვენი მთავარი მეთოდი პასუხი_კბ რეაგირებს Inline ღილაკების დაჭერაზე, რომელსაც ახორციელებს სპეციალური დამმუშავებელი: CallbackQueryHandler(answer_cb).

მეთოდის შიგნით პასუხი_კბ, ვკითხულობთ კლავიატურიდან გამოგზავნილ მონაცემებს და ვწერთ ცვლადში city: city <- update$callback_query$data. შემდეგ ვითხოვთ ამინდის მონაცემებს API-დან, ვქმნით და ვაგზავნით შეტყობინებას და ბოლოს ვიყენებთ მეთოდს answerCallbackQuery რათა შეატყობინოთ ბოტს, რომ დავამუშავეთ Inline ღილაკის დაწკაპუნება.

ბოტის მაგალითი, რომელიც აჩვენებს უახლესი სტატიების სიას მითითებულ Hub-ის ბმულებით www.habr.com.

მე წარმოგიდგენთ ამ ბოტს, რათა გაჩვენოთ, თუ როგორ უნდა აჩვენოთ Inline ღილაკები, რომლებიც მიდიან ვებ გვერდებზე.

ამ ბოტის ლოგიკა წინა მსგავსია; თავდაპირველად ბრძანებით ვუშვებთ მთავარ კლავიატურას /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()

გაუშვით ზემოთ მოცემული კოდის მაგალითი, მას შემდეგ, რაც შეცვალეთ "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