"R-ൽ ഒരു ടെലിഗ്രാം ബോട്ട് എഴുതുന്നു" എന്ന പരമ്പരയിലെ മൂന്നാമത്തെ ലേഖനമാണിത്. മുൻ പ്രസിദ്ധീകരണങ്ങളിൽ, ഒരു ടെലിഗ്രാം ബോട്ട് എങ്ങനെ സൃഷ്ടിക്കാമെന്നും അതിലൂടെ സന്ദേശങ്ങൾ അയയ്ക്കാമെന്നും ബോട്ടിലേക്ക് കമാൻഡുകളും സന്ദേശ ഫിൽട്ടറുകളും എങ്ങനെ ചേർക്കാമെന്നും ഞങ്ങൾ പഠിച്ചു. അതിനാൽ, നിങ്ങൾ ഈ ലേഖനം വായിക്കാൻ തുടങ്ങുന്നതിനുമുമ്പ്, നിങ്ങൾ വായിക്കാൻ ഞാൻ വളരെ ശുപാർശ ചെയ്യുന്നു മുമ്പത്തെ, കാരണം ബോട്ട് നിർമ്മാണത്തിന്റെ മുമ്പ് വിവരിച്ച അടിസ്ഥാനകാര്യങ്ങളിൽ ഞാൻ ഇനി താമസിക്കില്ല.

ഈ ലേഖനത്തിൽ, ഒരു കീബോർഡ് ചേർത്ത് ഞങ്ങളുടെ ബോട്ടിന്റെ ഉപയോഗക്ഷമത ഞങ്ങൾ മെച്ചപ്പെടുത്തും, അത് ബോട്ട് ഇന്റർഫേസ് അവബോധജന്യവും ഉപയോഗിക്കാൻ എളുപ്പവുമാക്കും.

"R-ൽ ഒരു ടെലിഗ്രാം ബോട്ട് എഴുതുന്നു" എന്ന പരമ്പരയിലെ എല്ലാ ലേഖനങ്ങളും

1. ഞങ്ങൾ ഒരു ബോട്ട് സൃഷ്ടിക്കുകയും ടെലിഗ്രാമിൽ സന്ദേശങ്ങൾ അയയ്ക്കാൻ അത് ഉപയോഗിക്കുകയും ചെയ്യുന്നു
2. ബോട്ടിലേക്ക് കമാൻഡ് പിന്തുണയും സന്ദേശ ഫിൽട്ടറുകളും ചേർക്കുക
3. ഒരു ബോട്ടിലേക്ക് കീബോർഡ് പിന്തുണ എങ്ങനെ ചേർക്കാം

ഉള്ളടക്കം

നിങ്ങൾക്ക് ഡാറ്റ വിശകലനത്തിൽ താൽപ്പര്യമുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് എന്റെ താൽപ്പര്യമുണ്ടാകാം ടെലഗ്രാം и YouTube ചാനലുകൾ. ഉള്ളടക്കത്തിന്റെ ഭൂരിഭാഗവും R ഭാഷയ്‌ക്കായി സമർപ്പിച്ചിരിക്കുന്നു.

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 - എച്ച്ടിടിപി അഭ്യർത്ഥനകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നതിനുള്ള ഒരു പാക്കേജ്, ഏത് എപിഐയുമായുള്ള പ്രവർത്തനത്തിന്റെ അടിസ്ഥാനത്തിലാണ് നിർമ്മിച്ചിരിക്കുന്നത്. ഞങ്ങളുടെ കാര്യത്തിൽ ഞങ്ങൾ സൗജന്യ 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