"ਆਰ ਵਿੱਚ ਟੈਲੀਗ੍ਰਾਮ ਬੋਟ ਲਿਖਣਾ" ਲੜੀ ਦਾ ਇਹ ਤੀਜਾ ਲੇਖ ਹੈ। ਪਿਛਲੇ ਪ੍ਰਕਾਸ਼ਨਾਂ ਵਿੱਚ, ਅਸੀਂ ਸਿੱਖਿਆ ਕਿ ਟੈਲੀਗ੍ਰਾਮ ਬੋਟ ਕਿਵੇਂ ਬਣਾਉਣਾ ਹੈ, ਇਸ ਰਾਹੀਂ ਸੰਦੇਸ਼ ਕਿਵੇਂ ਭੇਜਣੇ ਹਨ, ਬੋਟ ਵਿੱਚ ਕਮਾਂਡਾਂ ਅਤੇ ਸੰਦੇਸ਼ ਫਿਲਟਰ ਸ਼ਾਮਲ ਕੀਤੇ ਗਏ ਹਨ। ਇਸ ਲਈ, ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਤੁਸੀਂ ਇਸ ਲੇਖ ਨੂੰ ਪੜ੍ਹਨਾ ਸ਼ੁਰੂ ਕਰੋ, ਮੈਂ ਜ਼ੋਰਦਾਰ ਸਿਫਾਰਸ਼ ਕਰਦਾ ਹਾਂ ਕਿ ਤੁਸੀਂ ਪੜ੍ਹੋ ਪਿਛਲਾ, ਕਿਉਂਕਿ ਇੱਥੇ ਮੈਂ ਹੁਣ ਬੋਟ ਬਿਲਡਿੰਗ ਦੀਆਂ ਪਹਿਲਾਂ ਦੱਸੀਆਂ ਮੂਲ ਗੱਲਾਂ 'ਤੇ ਧਿਆਨ ਨਹੀਂ ਦੇਵਾਂਗਾ।

ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਕੀਬੋਰਡ ਜੋੜ ਕੇ ਆਪਣੇ ਬੋਟ ਦੀ ਉਪਯੋਗਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰਾਂਗੇ, ਜੋ ਬੋਟ ਇੰਟਰਫੇਸ ਨੂੰ ਅਨੁਭਵੀ ਅਤੇ ਵਰਤੋਂ ਵਿੱਚ ਆਸਾਨ ਬਣਾ ਦੇਵੇਗਾ।

ਲੜੀ ਦੇ ਸਾਰੇ ਲੇਖ “R ਵਿੱਚ ਟੈਲੀਗ੍ਰਾਮ ਬੋਟ ਲਿਖਣਾ”

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

'ਤੁਹਾਡੇ ਬੋਟ ਟੋਕਨ' ਨੂੰ ਅਸਲ ਟੋਕਨ ਨਾਲ ਬਦਲਣ ਤੋਂ ਬਾਅਦ, ਉਪਰੋਕਤ ਕੋਡ ਦੀ ਉਦਾਹਰਨ ਚਲਾਓ, ਜਿਸ ਰਾਹੀਂ ਤੁਸੀਂ ਬੋਟ ਬਣਾਉਣ ਵੇਲੇ ਪ੍ਰਾਪਤ ਕੀਤਾ ਸੀ ਬੋਟਫੈਦਰ (ਮੈਂ ਵਿੱਚ ਇੱਕ ਬੋਟ ਬਣਾਉਣ ਬਾਰੇ ਗੱਲ ਕੀਤੀ ਪਹਿਲਾ ਲੇਖ).

ਲਾਂਚ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਬੋਟ ਨੂੰ ਇੱਕ ਕਮਾਂਡ ਦਿਓ /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)

ਇਨਲਾਈਨ ਕੀਬੋਰਡ

ਜਿਵੇਂ ਕਿ ਮੈਂ ਉੱਪਰ ਲਿਖਿਆ ਹੈ, ਇਨਲਾਈਨ ਕੀਬੋਰਡ ਇੱਕ ਖਾਸ ਸੰਦੇਸ਼ ਨਾਲ ਜੁੜਿਆ ਹੋਇਆ ਹੈ। ਮੁੱਖ ਕੀਬੋਰਡ ਨਾਲੋਂ ਇਸ ਨਾਲ ਕੰਮ ਕਰਨਾ ਕੁਝ ਹੋਰ ਮੁਸ਼ਕਲ ਹੈ।

ਸ਼ੁਰੂ ਵਿੱਚ, ਤੁਹਾਨੂੰ ਇਨਲਾਈਨ ਕੀਬੋਰਡ ਨੂੰ ਕਾਲ ਕਰਨ ਲਈ ਬੋਟ ਵਿੱਚ ਇੱਕ ਢੰਗ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ।

ਇੱਕ ਇਨਲਾਈਨ ਬਟਨ ਕਲਿੱਕ ਦਾ ਜਵਾਬ ਦੇਣ ਲਈ, ਤੁਸੀਂ ਬੋਟ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ 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()

'ਤੁਹਾਡੇ ਬੋਟ ਟੋਕਨ' ਨੂੰ ਅਸਲ ਟੋਕਨ ਨਾਲ ਬਦਲਣ ਤੋਂ ਬਾਅਦ, ਉਪਰੋਕਤ ਕੋਡ ਦੀ ਉਦਾਹਰਨ ਚਲਾਓ, ਜਿਸ ਰਾਹੀਂ ਤੁਸੀਂ ਬੋਟ ਬਣਾਉਣ ਵੇਲੇ ਪ੍ਰਾਪਤ ਕੀਤਾ ਸੀ ਬੋਟਫੈਦਰ (ਮੈਂ ਵਿੱਚ ਇੱਕ ਬੋਟ ਬਣਾਉਣ ਬਾਰੇ ਗੱਲ ਕੀਤੀ ਪਹਿਲਾ ਲੇਖ).

ਨਤੀਜਾ:

ਅਸੀਂ ਦੋ ਤਰੀਕੇ ਬਣਾਏ:

• ਟੈਸਟ - ਚੈਟ ਇਨਲਾਈਨ ਕੀਬੋਰਡ ਨੂੰ ਭੇਜਣ ਲਈ
• ਜਵਾਬ_ਸੀਬੀ - ਕੀਬੋਰਡ ਤੋਂ ਭੇਜੇ ਗਏ ਡੇਟਾ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਲਈ।

ਡੇਟਾ ਜੋ ਹਰੇਕ ਬਟਨ ਤੋਂ ਭੇਜਿਆ ਜਾਵੇਗਾ ਆਰਗੂਮੈਂਟ ਵਿੱਚ ਦਿੱਤਾ ਗਿਆ ਹੈ 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()

'ਤੁਹਾਡੇ ਬੋਟ ਟੋਕਨ' ਨੂੰ ਅਸਲ ਟੋਕਨ ਨਾਲ ਬਦਲਣ ਤੋਂ ਬਾਅਦ, ਉਪਰੋਕਤ ਕੋਡ ਦੀ ਉਦਾਹਰਨ ਚਲਾਓ, ਜਿਸ ਰਾਹੀਂ ਤੁਸੀਂ ਬੋਟ ਬਣਾਉਣ ਵੇਲੇ ਪ੍ਰਾਪਤ ਕੀਤਾ ਸੀ ਬੋਟਫੈਦਰ (ਮੈਂ ਵਿੱਚ ਇੱਕ ਬੋਟ ਬਣਾਉਣ ਬਾਰੇ ਗੱਲ ਕੀਤੀ ਪਹਿਲਾ ਲੇਖ).

ਹੁਣ ਅਸੀਂ 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()

'ਤੁਹਾਡੇ ਬੋਟ ਟੋਕਨ' ਨੂੰ ਅਸਲ ਟੋਕਨ ਨਾਲ ਬਦਲਣ ਤੋਂ ਬਾਅਦ, ਉਪਰੋਕਤ ਕੋਡ ਦੀ ਉਦਾਹਰਨ ਚਲਾਓ, ਜਿਸ ਰਾਹੀਂ ਤੁਸੀਂ ਬੋਟ ਬਣਾਉਣ ਵੇਲੇ ਪ੍ਰਾਪਤ ਕੀਤਾ ਸੀ ਬੋਟਫੈਦਰ (ਮੈਂ ਵਿੱਚ ਇੱਕ ਬੋਟ ਬਣਾਉਣ ਬਾਰੇ ਗੱਲ ਕੀਤੀ ਪਹਿਲਾ ਲੇਖ).

ਨਤੀਜੇ ਵਜੋਂ, ਸਾਡਾ ਬੋਟ ਇਸ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰੇਗਾ:

ਯੋਜਨਾਬੱਧ ਤੌਰ 'ਤੇ, ਇਸ ਬੋਟ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਦਰਸਾਇਆ ਜਾ ਸਕਦਾ ਹੈ:

ਅਸੀਂ ਆਪਣੇ ਮੌਸਮ ਬੋਟ ਦੇ ਅੰਦਰ ਉਪਲਬਧ 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, ਜੋ ਤੁਹਾਨੂੰ ਹਾਬਰਾ ਤੋਂ ਲੇਖਾਂ ਦੀ ਬੇਨਤੀ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਅਤੇ ਉਹਨਾਂ 'ਤੇ ਕੁਝ ਅੰਕੜੇ ਆਰ.

ਪੈਕੇਜ ਇੰਸਟਾਲ ਕਰੋ 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