פּראָהאָסטער > בלאָג > אַדמיניסטראַציע > שרייבן אַ טעלעגראַם באָט אין ר (טייל 3): ווי צו לייגן קלאַוויאַטור שטיצן צו אַ באָט

שרייבן אַ טעלעגראַם באָט אין ר (טייל 3): ווי צו לייגן קלאַוויאַטור שטיצן צו אַ באָט

דאָס איז דער דריטער אַרטיקל אין דער סעריע "שרייבן אַ טעלעגראַם באָט אין ר". אין פריערדיקע אויסגאבעס, מיר געלערנט ווי צו שאַפֿן אַ טעלעגראַם באָט, שיקן אַרטיקלען דורך אים, צוגעלייגט קאַמאַנדז און אָנזאָג פילטערס צו די באָט. דעריבער, איידער איר אָנהייבן לייענען דעם אַרטיקל, איך העכסט רעקאָמענדירן איר לייענען פֿריִערדיקע, т.к. тут я уже не буду останавливать на описанных ранее основах ботостроения.

אין דעם אַרטיקל, מיר וועלן פֿאַרבעסערן די וסאַביליטי פון אונדזער באָט דורך אַדינג אַ קלאַוויאַטור, וואָס וועט מאַכן די באָט צובינד ינטואַטיוו און גרינג צו נוצן.

שרייבן אַ טעלעגראַם באָט אין ר (טייל 3): ווי צו לייגן קלאַוויאַטור שטיצן צו אַ באָט

אַלע אַרטיקלען פֿון דער סעריע "שרייבן אַ טעלעגראַם באָט אין ר"

  1. מיר מאַכן אַ באָט און נוצן עס צו שיקן אַרטיקלען אין טעלעגראַם
  2. לייג באַפֿעלן שטיצן און אָנזאָג פילטערס צו די באָט
  3. ווי צו לייגן קלאַוויאַטור שטיצן צו אַ באָט

צופרידן

אויב איר זענט אינטערעסירט אין דאַטן אַנאַליסיס, איר קען זיין אינטערעסירט אין מיין telegram и יאָוטובע טשאַנאַלז. רובֿ פון די אינהאַלט איז דעדאַקייטאַד צו די R שפּראַך.

  1. וואָס טייפּס פון קיבאָרדז שטיצט די טעלעגראַם באָט?
  2. ענטפער קלאַוויאַטור
  3. ינלינע קלאַוויאַטור
    קסנומקס. Пример простейшего бота с поддержкой InLine кнопок
    קסנומקס. Пример бота, который сообщает текущую погоду по выбранному городу
    קסנומקס. אַ ביישפּיל פון אַ באָט וואָס דיספּלייז אַ רשימה פון די לעצטע אַרטיקלען מיט לינקס צו די ספּעסיפיעד הוב פֿון habr.com
  4. סאָף

וואָס טייפּס פון קיבאָרדז שטיצט די טעלעגראַם באָט?

אין דער צייט פון דעם שרייבן telegram.bot אַלאַוז איר צו שאַפֿן צוויי טייפּס פון קיבאָרדז:

  • ענטפער - די הויפּט, רעגולער קלאַוויאַטור, וואָס איז ליגן אונטער די אָנזאָג טעקסט אַרייַנשרייַב טאַפליע. אַזאַ אַ קלאַוויאַטור שיקט פשוט אַ טעקסט אָנזאָג צו די באָט, און ווי דער טעקסט וועט עס שיקן די טעקסט וואָס איז געשריבן אויף די קנעפּל זיך.
  • ינלינע - קלאַוויאַטור פֿאַרבונדן מיט אַ ספּעציפיש באָט אָנזאָג. די קלאַוויאַטור סענדז די באָט דאַטן פֿאַרבונדן מיט דעם קנעפּל געדריקט; די דאַטן קען זיין אַנדערש פון די טעקסט געשריבן אויף די קנעפּל זיך. און אַזאַ קנעפּלעך זענען פּראַסעסט דורך CallbackQueryHandler.

Для того, что бы бот открыл клавиатуру необходимо при отправке сообщения через метод sendMessage(), פאָרן די פריער באשאפן קלאַוויאַטור ווי אַן אַרגומענט reply_markup.

ונטער מיר וועלן קוקן אין עטלעכע ביישפילן.

ענטפער קלאַוויאַטור

Как я уже писал выше, это основная клавиатура управления ботом.

Пример создания Reply клавиатуры из официальной справки

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, т.к. именно её мы определили для запуска клавиатуры.

שרייבן אַ טעלעגראַם באָט אין ר (טייל 3): ווי צו לייגן קלאַוויאַטור שטיצן צו אַ באָט

אויב אין דעם מאָמענט עס איז שווער פֿאַר איר צו פּאַרס די געגעבן קאָד בייַשפּיל, מיט די שאַפונג פון מעטהאָדס, פילטערס און האַנדלערס, איר זאָל צוריקקומען צו די פריערדיקע. אַרטיקל, אי ן װעלכ ן אי ך הא ב דא ס אל ץ באשריבן .

מיר האָבן באשאפן 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
)

שרייבן אַ טעלעגראַם באָט אין ר (טייל 3): ווי צו לייגן קלאַוויאַטור שטיצן צו אַ באָט

די קלאַוויאַטור איז געשיקט צו די שמועסן מיט דעם אופֿן sendMessage(), אין די אַרגומענט reply_markup.

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

ינלינע קלאַוויאַטור

ווי איך געשריבן אויבן, די ינלינע קלאַוויאַטור איז טייד צו אַ ספּעציפיש אָנזאָג. עס איז עפּעס מער שווער צו אַרבעטן מיט די הויפּט קלאַוויאַטור.

Изначально вам необходимо добавить боту метод, для вызова Inline клавиатуры.

Для ответа на нажатие Inline кнопки также можно использовать метод бота answerCallbackQuery(), который может вывести уведомление в интерфейсе telegram, пользователю нажавшему Inline кнопку.

די דאַטן געשיקט פֿון די ינלינע קנעפּל זענען נישט טעקסט, אַזוי צו פּראָצעס עס איר דאַרפֿן צו שאַפֿן אַ ספּעציעל האַנדלער מיט דעם באַפֿעל CallbackQueryHandler().

Код построения Inline клавиатуры который приводится в официальной справке пакета telegram.bot.

Код построения Inline клавиатуры из официальной справки

# 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 клавиатуру. В InlineKeyboardMarkup() עס איז נייטיק צו פאָרן אַ רשימה פון רשימות פון ינלינע קנעפּלעך, יעדער יחיד קנעפּל איז באשאפן דורך די פונקציע InlineKeyboardButton().

Inline кнопка может либо передавать боту какие-то данные с помощью аргумента callback_data, либо открывать какую-либо HTML страницу, заданную с помощью аргумента url.

דער רעזולטאַט וועט זיין אַ רשימה אין וואָס יעדער עלעמענט איז אויך אַ רשימה פון ינלינע קנעפּלעך וואָס דאַרפֿן צו זיין קאַמביינד אין איין רודערן.

Далее мы рассмотрим несколько примеров ботов с Inline кнопками.

Пример простейшего бота с поддержкой InLine кнопок

Для начала мы напишем бота для экспресс тестирования на covid-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()

לויפן די קאָד ביישפיל אויבן, נאָך ריפּלייסינג 'דיין באָאָט טאָקען' מיט די פאַקטיש סימען איר באקומען ווען איר שאַפֿן דעם באָט דורך באָטפאַטהער (איך האָב גערעדט וועגן שאַפֿן אַ באָט אין ערשטער אַרטיקל).

דער רעזולטאַט:
שרייבן אַ טעלעגראַם באָט אין ר (טייל 3): ווי צו לייגן קלאַוויאַטור שטיצן צו אַ באָט

מיר האָבן באשאפן צוויי מעטהאָדס:

  • פּראָבע - צו שיקן צו שמועסן ינלינע קלאַוויאַטור
  • answer_cb - צו פּראָצעס דאַטן געשיקט פֿון די קלאַוויאַטור.

Данные, которые будут отправлены с каждой кнопки задаются в аргументе callback_data, при создании кнопки. Получить отправленные с кнопки данные можно с помощью конструкции update$callback_query$data, ין דער אופֿן answer_cb.

Что бы бот реагировал на Inline клавиатуру, метод 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()

לויפן די קאָד ביישפיל אויבן, נאָך ריפּלייסינג 'דיין באָאָט טאָקען' מיט די פאַקטיש סימען איר באקומען ווען איר שאַפֿן דעם באָט דורך באָטפאַטהער (איך האָב גערעדט וועגן שאַפֿן אַ באָט אין ערשטער אַרטיקל).

איצט מיר האָבן געשריבן 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), которая сообщает боту, что данные с inline клавиатуры получены.

Пример бота, который сообщает текущую погоду по выбранному городу

Давайте попробуем написать бота, который запрашивает данные о погоде.

Логика его работы будет следующая. Изначально командой /start איר רופן אַרויף די הויפּט קלאַוויאַטור, וואָס האט בלויז איין "וועטער" קנעפּל. דורך געבן אַ קליק אויף דעם קנעפּל איר וועט באַקומען אַ אָנזאָג מיט די ינלינע קלאַוויאַטור צו אויסקלייַבן די שטאָט פֿאַר וואָס איר ווילן צו געפֿינען די קראַנט וועטער. אויסקלייַבן איינער פון די שטעט און באַקומען די קראַנט וועטער.

В этом примере кода мы будем использовать несколько дополнительных пакетов:

  • httr - אַ פּעקל פֿאַר ארבעטן מיט הטטפּ ריקוועס, אויף דער באזע פון ​​וואָס אַרבעט מיט קיין אַפּי איז געבויט. אין אונדזער פאַל, מיר וועלן נוצן די פריי 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()

לויפן די קאָד ביישפיל אויבן, נאָך ריפּלייסינג 'דיין באָאָט טאָקען' מיט די פאַקטיש סימען איר באקומען ווען איר שאַפֿן דעם באָט דורך באָטפאַטהער (איך האָב גערעדט וועגן שאַפֿן אַ באָט אין ערשטער אַרטיקל).

В результате наш бот будет работать примерно так:
שרייבן אַ טעלעגראַם באָט אין ר (טייל 3): ווי צו לייגן קלאַוויאַטור שטיצן צו אַ באָט

סכעמאַטיש, דעם באָט קענען זיין דיפּיקטיד ווי דאָס:
שרייבן אַ טעלעגראַם באָט אין ר (טייל 3): ווי צו לייגן קלאַוויאַטור שטיצן צו אַ באָט

Мы создали 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.

Данного бота я привожу для того, что бы показать вам, как вывести Inline кнопки которые ведут на веб страницы.

Логика данного бота схожа с предыдущим, изначально мы запускаем основную клавиатуру командой /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()

לויפן די קאָד ביישפיל אויבן, נאָך ריפּלייסינג 'דיין באָאָט טאָקען' מיט די פאַקטיש סימען איר באקומען ווען איר שאַפֿן דעם באָט דורך באָטפאַטהער (איך האָב גערעדט וועגן שאַפֿן אַ באָט אין ערשטער אַרטיקל).

ווי אַ רעזולטאַט, מיר וועלן באַקומען דעם רעזולטאַט:
שרייבן אַ טעלעגראַם באָט אין ר (טייל 3): ווי צו לייגן קלאַוויאַטור שטיצן צו אַ באָט

Список доступных для выбора Хабов мы вбили хардкодом, в методе 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

לייגן אַ באַמערקונג