"R માં ટેલિગ્રામ બોટ લખવું" શ્રેણીનો આ ત્રીજો લેખ છે. અગાઉના પ્રકાશનોમાં, અમે ટેલિગ્રામ બોટ કેવી રીતે બનાવવો, તેના દ્વારા સંદેશા મોકલવા, બોટમાં આદેશો અને સંદેશ ફિલ્ટર્સ ઉમેરવા શીખ્યા. તેથી, તમે આ લેખ વાંચવાનું શરૂ કરો તે પહેલાં, હું ખૂબ ભલામણ કરું છું કે તમે વાંચો અગાઉના, કારણ કે અહીં હું બોટ બિલ્ડિંગની અગાઉ વર્ણવેલ મૂળભૂત બાબતો પર ધ્યાન આપીશ નહીં.

આ લેખમાં, અમે કીબોર્ડ ઉમેરીને અમારા બોટની ઉપયોગીતામાં સુધારો કરીશું, જે બોટ ઈન્ટરફેસને સાહજિક અને ઉપયોગમાં સરળ બનાવશે.

"R માં ટેલિગ્રામ બોટ લખવું" શ્રેણીના તમામ લેખો

1. અમે એક બોટ બનાવીએ છીએ અને તેનો ઉપયોગ ટેલિગ્રામમાં સંદેશા મોકલવા માટે કરીએ છીએ
2. બોટમાં કમાન્ડ સપોર્ટ અને મેસેજ ફિલ્ટર્સ ઉમેરો
3. બોટમાં કીબોર્ડ સપોર્ટ કેવી રીતે ઉમેરવો

અનુક્રમણિકા

જો તમને ડેટા વિશ્લેષણમાં રસ હોય, તો તમને મારામાં રસ હોઈ શકે છે ટેલિગ્રામ и યુ ટ્યુબ ચેનલો મોટાભાગની સામગ્રી 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 બટન હશે:

• ચેટ 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()

ઉપરોક્ત કોડ ઉદાહરણ ચલાવો, 'યોર બોટ ટોકન' ને બદલ્યા પછી, તમને બોટ બનાવતી વખતે પ્રાપ્ત થયેલ વાસ્તવિક ટોકન સાથે બોટફેધર (મેં માં બોટ બનાવવા વિશે વાત કરી પ્રથમ લેખ).

લોન્ચ કર્યા પછી, બોટને આદેશ આપો /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, જે તમને હાબ્રાના લેખો અને R માં તેમના પરના કેટલાક આંકડાઓની વિનંતી કરવાની મંજૂરી આપે છે.

પેકેજ ઇન્સ્ટોલ કરો habR ફક્ત ગીથબથી જ શક્ય છે, જેના માટે તમારે વધારાના પેકેજની જરૂર પડશે 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