В ಹಿಂದಿನ ಪ್ರಕಟಣೆ ಬೋಟ್ ಅನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂದು ನಾವು ಕಂಡುಕೊಂಡಿದ್ದೇವೆ, ವರ್ಗದ ಉದಾಹರಣೆಯನ್ನು ಪ್ರಾರಂಭಿಸಿದ್ದೇವೆ Bot ಮತ್ತು ಅದನ್ನು ಬಳಸಿಕೊಂಡು ಸಂದೇಶಗಳನ್ನು ಕಳುಹಿಸುವ ವಿಧಾನಗಳ ಪರಿಚಯವಾಯಿತು.

ಈ ಲೇಖನದಲ್ಲಿ ನಾನು ಈ ವಿಷಯವನ್ನು ಮುಂದುವರಿಸುತ್ತೇನೆ, ಆದ್ದರಿಂದ ಓದಿದ ನಂತರ ಮಾತ್ರ ಈ ಲೇಖನವನ್ನು ಓದಲು ಪ್ರಾರಂಭಿಸಲು ನಾನು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ ಮೊದಲ ಭಾಗ.

ಈ ಸಮಯದಲ್ಲಿ ನಮ್ಮ ಬೋಟ್ ಅನ್ನು ಹೇಗೆ ಪುನರುಜ್ಜೀವನಗೊಳಿಸುವುದು ಮತ್ತು ಅದಕ್ಕೆ ಕಮಾಂಡ್ ಬೆಂಬಲವನ್ನು ಸೇರಿಸುವುದು ಹೇಗೆ ಎಂದು ನಾವು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತೇವೆ ಮತ್ತು ವರ್ಗದೊಂದಿಗೆ ಪರಿಚಯ ಮಾಡಿಕೊಳ್ಳುತ್ತೇವೆ Updater.

ಲೇಖನದ ಸಮಯದಲ್ಲಿ, ನಾವು ಹಲವಾರು ಸರಳ ಬಾಟ್‌ಗಳನ್ನು ಬರೆಯುತ್ತೇವೆ, ನಿರ್ದಿಷ್ಟ ದಿನಾಂಕ ಮತ್ತು ದೇಶದ ಕೋಡ್ ಅನ್ನು ಆಧರಿಸಿ, ನಿರ್ದಿಷ್ಟ ದೇಶದಲ್ಲಿ ಒಂದು ದಿನವು ವಾರಾಂತ್ಯವೇ ಅಥವಾ ಉತ್ಪಾದನಾ ಕ್ಯಾಲೆಂಡರ್ ಪ್ರಕಾರ ಕೆಲಸದ ದಿನವೇ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ. ಆದರೆ, ಮೊದಲಿನಂತೆ, ಲೇಖನದ ಉದ್ದೇಶವು ಪ್ಯಾಕೇಜ್ ಇಂಟರ್ಫೇಸ್ನೊಂದಿಗೆ ನಿಮಗೆ ಪರಿಚಿತವಾಗಿದೆ telegram.bot ನಿಮ್ಮ ಸ್ವಂತ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು.

"R ನಲ್ಲಿ ಟೆಲಿಗ್ರಾಮ್ ಬಾಟ್ ಅನ್ನು ಬರೆಯುವುದು" ಸರಣಿಯ ಎಲ್ಲಾ ಲೇಖನಗಳು

1. ನಾವು ಬೋಟ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ ಮತ್ತು ಟೆಲಿಗ್ರಾಮ್ನಲ್ಲಿ ಸಂದೇಶಗಳನ್ನು ಕಳುಹಿಸಲು ಅದನ್ನು ಬಳಸುತ್ತೇವೆ
2. ಬೋಟ್‌ಗೆ ಕಮಾಂಡ್ ಬೆಂಬಲ ಮತ್ತು ಸಂದೇಶ ಫಿಲ್ಟರ್‌ಗಳನ್ನು ಸೇರಿಸಿ

ಪರಿವಿಡಿ

ನೀವು ಡೇಟಾ ವಿಶ್ಲೇಷಣೆಯಲ್ಲಿ ಆಸಕ್ತಿ ಹೊಂದಿದ್ದರೆ, ನೀವು ನನ್ನ ಬಗ್ಗೆ ಆಸಕ್ತಿ ಹೊಂದಿರಬಹುದು ಟೆಲಿಗ್ರಾಮ್ и YouTube ವಾಹಿನಿಗಳು. ಹೆಚ್ಚಿನ ವಿಷಯವನ್ನು R ಭಾಷೆಗೆ ಮೀಸಲಿಡಲಾಗಿದೆ.

1. ಅಪ್ಡೇಟರ್ ವರ್ಗ
2. ನಿರ್ವಾಹಕರು - ನಿರ್ವಾಹಕರು
3. ಮೊದಲ ಆಜ್ಞೆಯನ್ನು ಬೋಟ್, ಕಮಾಂಡ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗೆ ಸೇರಿಸಿ
4. ಪಠ್ಯ ಸಂದೇಶ ಪ್ರೊಸೆಸರ್ ಮತ್ತು ಫಿಲ್ಟರ್‌ಗಳು
5. ನಿಯತಾಂಕಗಳೊಂದಿಗೆ ಆಜ್ಞೆಗಳನ್ನು ಸೇರಿಸಲಾಗುತ್ತಿದೆ
6. ಹಿನ್ನೆಲೆಯಲ್ಲಿ ಬೋಟ್ ಅನ್ನು ರನ್ ಮಾಡಿ
7. ತೀರ್ಮಾನಕ್ಕೆ

ಅಪ್ಡೇಟರ್ ವರ್ಗ

Updater ಟೆಲಿಗ್ರಾಮ್ ಬೋಟ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ನಿಮಗೆ ಸುಲಭವಾಗುವಂತೆ ಮಾಡುವ ವರ್ಗವಾಗಿದೆ ಮತ್ತು ಹುಡ್ ಅಡಿಯಲ್ಲಿ ವರ್ಗವನ್ನು ಬಳಸುತ್ತದೆ Dispetcher. ವರ್ಗ ನಿಯೋಜನೆ Updater ಬೋಟ್‌ನಿಂದ ನವೀಕರಣಗಳನ್ನು ಸ್ವೀಕರಿಸುವುದು (ಹಿಂದಿನ ಲೇಖನದಲ್ಲಿ ನಾವು ಈ ಉದ್ದೇಶಕ್ಕಾಗಿ ವಿಧಾನವನ್ನು ಬಳಸಿದ್ದೇವೆ getUpdates()), ಮತ್ತು ಅವುಗಳನ್ನು ಮತ್ತಷ್ಟು ವರ್ಗಾಯಿಸಿ Dispetcher.

ಪ್ರತಿಯಾಗಿ Dispetcher ನೀವು ರಚಿಸಿದ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿದೆ, ಅಂದರೆ. ವರ್ಗ ವಸ್ತುಗಳು Handler.

ನಿರ್ವಾಹಕರು - ನಿರ್ವಾಹಕರು

ಹ್ಯಾಂಡ್ಲರ್‌ಗಳೊಂದಿಗೆ ನೀವು ಸೇರಿಸುತ್ತೀರಿ Dispetcher ವಿವಿಧ ಘಟನೆಗಳಿಗೆ ಬೋಟ್ ಪ್ರತಿಕ್ರಿಯೆಗಳು. ಈ ಲೇಖನವನ್ನು ಬರೆಯುವ ಸಮಯದಲ್ಲಿ telegram.bot ಕೆಳಗಿನ ರೀತಿಯ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳನ್ನು ಸೇರಿಸಲಾಗಿದೆ:

• MessageHandler — ಸಂದೇಶ ನಿರ್ವಾಹಕ
• ಕಮಾಂಡ್ ಹ್ಯಾಂಡ್ಲರ್ - ಕಮಾಂಡ್ ಹ್ಯಾಂಡ್ಲರ್
• CallbackQueryHandler - ಇನ್‌ಲೈನ್‌ನಿಂದ ಕಳುಹಿಸಲಾದ ಕೀಬೋರ್ಡ್‌ಗಳಿಗಾಗಿ ಡೇಟಾ ಹ್ಯಾಂಡ್ಲರ್
• ErrorHandler — ಬೋಟ್‌ನಿಂದ ನವೀಕರಣಗಳನ್ನು ವಿನಂತಿಸುವಾಗ ದೋಷ ನಿರ್ವಾಹಕ

ಮೊದಲ ಆಜ್ಞೆಯನ್ನು ಬೋಟ್, ಕಮಾಂಡ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗೆ ಸೇರಿಸಿ

ನೀವು ಹಿಂದೆಂದೂ ಬಾಟ್‌ಗಳನ್ನು ಬಳಸಿಲ್ಲದಿದ್ದರೆ ಮತ್ತು ಕಮಾಂಡ್ ಎಂದರೇನು ಎಂದು ತಿಳಿದಿಲ್ಲದಿದ್ದರೆ, ನಂತರ ಬಾಟ್‌ಗೆ ಕಮಾಂಡ್‌ಗಳನ್ನು ಫಾರ್ವರ್ಡ್ ಸ್ಲ್ಯಾಷ್ ಬಳಸಿ ಕಳುಹಿಸಬೇಕು / ಪೂರ್ವಪ್ರತ್ಯಯವಾಗಿ.

ನಾವು ಸರಳ ಆಜ್ಞೆಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ, ಅಂದರೆ. ಆಜ್ಞೆಯ ಮೇರೆಗೆ ಹಲೋ ಹೇಳಲು ನಮ್ಮ ಬೋಟ್‌ಗೆ ಕಲಿಸೋಣ /hi.

ಕೋಡ್ 1: ಹಲೋ ಹೇಳಲು ಬೋಟ್‌ಗೆ ಕಲಿಸುವುದು

library(telegram.bot)

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

# Пишем метод для приветсвия
say_hello <- function(bot, update) {

  # Имя пользователя с которым надо поздароваться
  user_name <- update$message$from$first_name

  # Отправка приветственного сообщения
  bot$sendMessage(update$message$chat_id, 
                  text = paste0("Моё почтение, ", user_name, "!"), 
                  parse_mode = "Markdown")

}

# создаём обработчик 
hi_hendler <- CommandHandler('hi', say_hello)

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

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

ಈ ಮೂಲಕ ಬೋಟ್ ರಚಿಸುವಾಗ ನೀವು ಸ್ವೀಕರಿಸಿದ ನಿಜವಾದ ಟೋಕನ್‌ನೊಂದಿಗೆ 'ನಿಮ್ಮ ಬಾಟ್ ಟೋಕನ್' ಅನ್ನು ಬದಲಿಸಿದ ನಂತರ ಮೇಲಿನ ಕೋಡ್ ಉದಾಹರಣೆಯನ್ನು ರನ್ ಮಾಡಿ ಬೋಟ್ಫೆದರ್ (ನಾನು ಬೋಟ್ ಅನ್ನು ರಚಿಸುವ ಬಗ್ಗೆ ಮಾತನಾಡಿದ್ದೇನೆ ಮೊದಲ ಲೇಖನ).

ವಿಧಾನ start_polling() ವರ್ಗ Updater, ಕೋಡ್‌ನ ಕೊನೆಯಲ್ಲಿ ಬಳಸಲಾಗುವ, ಬೋಟ್‌ನಿಂದ ನವೀಕರಣಗಳನ್ನು ವಿನಂತಿಸುವ ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಅಂತ್ಯವಿಲ್ಲದ ಲೂಪ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ.

ಈಗ ನಾವು ಟೆಲಿಗ್ರಾಮ್ ಅನ್ನು ತೆರೆಯೋಣ ಮತ್ತು ನಮ್ಮ ಬೋಟ್ಗೆ ಮೊದಲ ಆಜ್ಞೆಯನ್ನು ಬರೆಯೋಣ /hi.

ಈಗ ನಮ್ಮ ಬೋಟ್ ಆಜ್ಞೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಂಡಿದೆ /hi, ಮತ್ತು ನಮ್ಮನ್ನು ಹೇಗೆ ಸ್ವಾಗತಿಸಬೇಕೆಂದು ತಿಳಿದಿದೆ.

ಕ್ರಮಬದ್ಧವಾಗಿ, ಅಂತಹ ಸರಳ ಬೋಟ್ ಅನ್ನು ನಿರ್ಮಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಈ ಕೆಳಗಿನಂತೆ ಚಿತ್ರಿಸಬಹುದು.

1. ವರ್ಗದ ಉದಾಹರಣೆಯನ್ನು ರಚಿಸಿ Updater;
2. ನಾವು ವಿಧಾನಗಳನ್ನು ರಚಿಸುತ್ತೇವೆ, ಅಂದರೆ. ನಮ್ಮ ಬೋಟ್ ನಿರ್ವಹಿಸುವ ಕಾರ್ಯಗಳು. ಕೋಡ್ ಉದಾಹರಣೆಯಲ್ಲಿ ಇದು ಒಂದು ಕಾರ್ಯವಾಗಿದೆ say_hello(). ನೀವು ಬೋಟ್ ವಿಧಾನಗಳಾಗಿ ಬಳಸುವ ಕಾರ್ಯಗಳು ಎರಡು ಅಗತ್ಯವಿರುವ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಹೊಂದಿರಬೇಕು - ಬೋಟ್ и ಅಪ್ಡೇಟ್, ಮತ್ತು ಒಂದು ಐಚ್ಛಿಕ - ಆರ್ಗ್ಸ್. ವಾದ ಬೋಟ್, ಇದು ನಿಮ್ಮ ಬೋಟ್ ಆಗಿದೆ, ಇದರ ಸಹಾಯದಿಂದ ನೀವು ಸಂದೇಶಗಳಿಗೆ ಪ್ರತ್ಯುತ್ತರಿಸಬಹುದು, ಸಂದೇಶಗಳನ್ನು ಕಳುಹಿಸಬಹುದು ಅಥವಾ ಬೋಟ್‌ಗೆ ಲಭ್ಯವಿರುವ ಯಾವುದೇ ಇತರ ವಿಧಾನಗಳನ್ನು ಬಳಸಬಹುದು. ವಾದ ಅಪ್ಡೇಟ್ ಬಳಕೆದಾರರಿಂದ ಬೋಟ್ ಸ್ವೀಕರಿಸಿದ್ದು ಇದನ್ನೇ, ವಾಸ್ತವವಾಗಿ, ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ಮೊದಲ ಲೇಖನದಲ್ಲಿ ಸ್ವೀಕರಿಸಿದ್ದೇವೆ getUpdates(). ವಾದ ಆರ್ಗ್ಸ್ ಆಜ್ಞೆಯೊಂದಿಗೆ ಬಳಕೆದಾರರು ಕಳುಹಿಸಿದ ಹೆಚ್ಚುವರಿ ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ನಾವು ಸ್ವಲ್ಪ ಸಮಯದ ನಂತರ ಈ ವಿಷಯಕ್ಕೆ ಹಿಂತಿರುಗುತ್ತೇವೆ;
3. ನಾವು ಹ್ಯಾಂಡ್ಲರ್ಗಳನ್ನು ರಚಿಸುತ್ತೇವೆ, ಅಂದರೆ. ಹಿಂದಿನ ಹಂತದಲ್ಲಿ ರಚಿಸಲಾದ ವಿಧಾನಗಳೊಂದಿಗೆ ನಾವು ಕೆಲವು ಬಳಕೆದಾರ ಕ್ರಿಯೆಗಳನ್ನು ಸಂಯೋಜಿಸುತ್ತೇವೆ. ಮೂಲಭೂತವಾಗಿ, ಹ್ಯಾಂಡ್ಲರ್ ಒಂದು ಪ್ರಚೋದಕವಾಗಿದೆ, ಇದು ಕೆಲವು ಬೋಟ್ ಕಾರ್ಯವನ್ನು ಕರೆಯುವ ಘಟನೆಯಾಗಿದೆ. ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ಅಂತಹ ಪ್ರಚೋದಕವು ಆಜ್ಞೆಯನ್ನು ಕಳುಹಿಸುತ್ತಿದೆ /hi, ಮತ್ತು ತಂಡದಿಂದ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ hi_hendler <- CommandHandler('hi', say_hello). ಮೊದಲ ಫಂಕ್ಷನ್ ಆರ್ಗ್ಯುಮೆಂಟ್ CommandHandler() ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ ಆಜ್ಞೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ hi, ಇದಕ್ಕೆ ಬೋಟ್ ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತದೆ. ಎರಡನೇ ವಾದವು ಬೋಟ್ ವಿಧಾನವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ನಾವು ವಿಧಾನವನ್ನು ಕರೆಯುತ್ತೇವೆ say_hello, ಮೊದಲ ಆರ್ಗ್ಯುಮೆಂಟ್‌ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಆಜ್ಞೆಯನ್ನು ಬಳಕೆದಾರರು ಕರೆದರೆ ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ;
4. ಮುಂದೆ, ನಾವು ರಚಿಸಿದ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ನಮ್ಮ ವರ್ಗ ನಿದರ್ಶನದ ರವಾನೆದಾರರಿಗೆ ಸೇರಿಸುತ್ತೇವೆ Updater. ನೀವು ಹಲವಾರು ವಿಧಗಳಲ್ಲಿ ಹ್ಯಾಂಡ್ಲರ್ಗಳನ್ನು ಸೇರಿಸಬಹುದು; ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾನು ಚಿಹ್ನೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಸರಳವಾದದನ್ನು ಬಳಸಿದ್ದೇನೆ +, ಅಂದರೆ. updater <- updater + hi_hendler. ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಅದೇ ರೀತಿ ಮಾಡಬಹುದು add_handler(), ಇದು ವರ್ಗಕ್ಕೆ ಸೇರಿದೆ Dispatcher, ನೀವು ಈ ವಿಧಾನವನ್ನು ಈ ರೀತಿ ಕಾಣಬಹುದು: updater$dispatcher$add_handler();
5. ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಬೋಟ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ start_polling().

ಪಠ್ಯ ಸಂದೇಶ ಪ್ರೊಸೆಸರ್ ಮತ್ತು ಫಿಲ್ಟರ್‌ಗಳು

ಬೋಟ್‌ಗೆ ಆಜ್ಞೆಗಳನ್ನು ಹೇಗೆ ಕಳುಹಿಸುವುದು ಎಂದು ನಾವು ಕಂಡುಕೊಂಡಿದ್ದೇವೆ, ಆದರೆ ಕೆಲವೊಮ್ಮೆ ನಮಗೆ ಆಜ್ಞೆಗಳಿಗೆ ಮಾತ್ರವಲ್ಲ, ಕೆಲವು ಸಾಮಾನ್ಯ ಪಠ್ಯ ಸಂದೇಶಗಳಿಗೂ ಪ್ರತಿಕ್ರಿಯಿಸಲು ಬೋಟ್ ಅಗತ್ಯವಿದೆ. ಇದನ್ನು ಮಾಡಲು ನೀವು ಸಂದೇಶ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ - ಸಂದೇಶ ಹ್ಯಾಂಡ್ಲರ್.

ಸಾಮಾನ್ಯ ಸಂದೇಶ ಹ್ಯಾಂಡ್ಲರ್ ಎಲ್ಲಾ ಒಳಬರುವ ಸಂದೇಶಗಳಿಗೆ ಸಂಪೂರ್ಣವಾಗಿ ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತದೆ. ಆದ್ದರಿಂದ, ಸಂದೇಶ ನಿರ್ವಾಹಕರನ್ನು ಹೆಚ್ಚಾಗಿ ಫಿಲ್ಟರ್‌ಗಳೊಂದಿಗೆ ಬಳಸಲಾಗುತ್ತದೆ. ಆಜ್ಞೆಯಲ್ಲಿ ಮಾತ್ರವಲ್ಲದೆ ಹಲೋ ಹೇಳಲು ಬೋಟ್ಗೆ ಕಲಿಸೋಣ /hi, ಆದರೆ ಬೋಟ್‌ಗೆ ಕಳುಹಿಸಲಾದ ಸಂದೇಶದಲ್ಲಿ ಈ ಕೆಳಗಿನ ಪದಗಳಲ್ಲಿ ಒಂದನ್ನು ಕಾಣಿಸಿಕೊಂಡಾಗಲೆಲ್ಲಾ: ಹಲೋ, ಹಲೋ, ಸೆಲ್ಯೂಟ್, ಹೈ, ಬೊಂಜೌರ್.

ಸದ್ಯಕ್ಕೆ ನಾವು ಯಾವುದೇ ಹೊಸ ವಿಧಾನಗಳನ್ನು ಬರೆಯುವುದಿಲ್ಲ, ಏಕೆಂದರೆ... ಬೋಟ್ ನಮ್ಮನ್ನು ಸ್ವಾಗತಿಸುವ ವಿಧಾನವನ್ನು ನಾವು ಈಗಾಗಲೇ ಹೊಂದಿದ್ದೇವೆ. ನಾವು ಮಾಡಬೇಕಾಗಿರುವುದು ಅಗತ್ಯವಿರುವ ಫಿಲ್ಟರ್ ಮತ್ತು ಸಂದೇಶ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ರಚಿಸುವುದು.

ಕೋಡ್ 2: ಪಠ್ಯ ಸಂದೇಶ ಹ್ಯಾಂಡ್ಲರ್ ಮತ್ತು ಫಿಲ್ಟರ್ ಸೇರಿಸಿ

library(telegram.bot)

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

# Пишем метод для приветсвия
## команда приветвия
say_hello <- function(bot, update) {

  # Имя пользователя с которым надо поздароваться
  user_name <- update$message$from$first_name

  # Отправляем приветсвенное сообщение
  bot$sendMessage(update$message$chat_id, 
                  text = paste0("Моё почтение, ", user_name, "!"),
                  parse_mode = "Markdown",
                  reply_to_message_id = update$message$message_id)

}

# создаём фильтры
MessageFilters$hi <- BaseFilter(function(message) {

  # проверяем, встречается ли в тексте сообщения слова: привет, здравствуй, салют, хай, бонжур
  grepl(x           = message$text, 
        pattern     = 'привет|здравствуй|салют|хай|бонжур',
        ignore.case = TRUE)
  }
)

# создаём обработчик 
hi_hendler <- CommandHandler('hi', say_hello) # обработчик команды hi
hi_txt_hnd <- MessageHandler(say_hello, filters = MessageFilters$hi)

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

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

ಈ ಮೂಲಕ ಬೋಟ್ ರಚಿಸುವಾಗ ನೀವು ಸ್ವೀಕರಿಸಿದ ನಿಜವಾದ ಟೋಕನ್‌ನೊಂದಿಗೆ 'ನಿಮ್ಮ ಬಾಟ್ ಟೋಕನ್' ಅನ್ನು ಬದಲಿಸಿದ ನಂತರ ಮೇಲಿನ ಕೋಡ್ ಉದಾಹರಣೆಯನ್ನು ರನ್ ಮಾಡಿ ಬೋಟ್ಫೆದರ್ (ನಾನು ಬೋಟ್ ಅನ್ನು ರಚಿಸುವ ಬಗ್ಗೆ ಮಾತನಾಡಿದ್ದೇನೆ ಮೊದಲ ಲೇಖನ).

ಈಗ ನಾವು ಮೊದಲು ಪಟ್ಟಿ ಮಾಡಲಾದ ಶುಭಾಶಯ ಪದಗಳನ್ನು ಹೊಂದಿರುವ ಹಲವಾರು ಸಂದೇಶಗಳನ್ನು ಬೋಟ್‌ಗೆ ಕಳುಹಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ:

ಆದ್ದರಿಂದ, ಮೊದಲನೆಯದಾಗಿ, ನಾವು ಬೋಟ್‌ಗೆ ಹಲೋ ಹೇಳಲು ಮಾತ್ರವಲ್ಲ, ಶುಭಾಶಯಕ್ಕೆ ಪ್ರತಿಕ್ರಿಯಿಸಲು ಕಲಿಸಿದ್ದೇವೆ. ನಾವು ವಾದವನ್ನು ಬಳಸಿಕೊಂಡು ಇದನ್ನು ಮಾಡಿದ್ದೇವೆ ಪ್ರತ್ಯುತ್ತರ_ಸಂದೇಶ_ಐಡಿ, ಇದು ವಿಧಾನದಲ್ಲಿ ಲಭ್ಯವಿದೆ sendMessage(), ನೀವು ಪ್ರತಿಕ್ರಿಯಿಸಲು ಬಯಸುವ ಸಂದೇಶದ ಐಡಿಯನ್ನು ನೀವು ವರ್ಗಾಯಿಸಬೇಕಾಗುತ್ತದೆ. ನೀವು ಈ ರೀತಿಯ ಸಂದೇಶ ಐಡಿಯನ್ನು ಪಡೆಯಬಹುದು: update$message$message_id.

ಆದರೆ ನಾವು ಮಾಡಿದ ಮುಖ್ಯ ವಿಷಯವೆಂದರೆ ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ಬೋಟ್‌ಗೆ ಫಿಲ್ಟರ್ ಅನ್ನು ಸೇರಿಸುವುದು BaseFilter():

# создаём фильтры
MessageFilters$hi <- BaseFilter( 

  # анонимная фильтрующая функция
  function(message) {

    # проверяем, встречается ли в тексте сообщения слова приветствия
    grepl(x           = message$text, 
          pattern     = 'привет|здравствуй|салют|хай|бонжур',
          ignore.case = TRUE)
  }

)

ನೀವು ಗಮನಿಸಿದಂತೆ, ಫಿಲ್ಟರ್‌ಗಳನ್ನು ವಸ್ತುವಿಗೆ ಸೇರಿಸುವ ಅಗತ್ಯವಿದೆ ಸಂದೇಶ ಫಿಲ್ಟರ್‌ಗಳು, ಇದು ಆರಂಭದಲ್ಲಿ ಈಗಾಗಲೇ ಸಿದ್ಧ-ಸಿದ್ಧ ಫಿಲ್ಟರ್‌ಗಳ ಸಣ್ಣ ಗುಂಪನ್ನು ಹೊಂದಿದೆ. ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ವಸ್ತುವಿಗೆ ಸಂದೇಶ ಫಿಲ್ಟರ್‌ಗಳು ನಾವು ಒಂದು ಅಂಶವನ್ನು ಸೇರಿಸಿದ್ದೇವೆ hi, ಇದು ಹೊಸ ಫಿಲ್ಟರ್ ಆಗಿದೆ.

ಕಾರ್ಯದಲ್ಲಿ BaseFilter() ನೀವು ಫಿಲ್ಟರ್ ಕಾರ್ಯವನ್ನು ರವಾನಿಸಬೇಕಾಗಿದೆ. ಮೂಲಭೂತವಾಗಿ, ಫಿಲ್ಟರ್ ಕೇವಲ ಒಂದು ಕಾರ್ಯವಾಗಿದ್ದು ಅದು ಸಂದೇಶದ ನಿದರ್ಶನವನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ ಮತ್ತು ಹಿಂತಿರುಗಿಸುತ್ತದೆ ಸರಿ ಅಥವಾ ತಪ್ಪು. ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಮೂಲಭೂತ ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ಸರಳವಾದ ಕಾರ್ಯವನ್ನು ಬರೆದಿದ್ದೇವೆ grepl() ಸಂದೇಶ ಪಠ್ಯವನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಅದು ಸಾಮಾನ್ಯ ಅಭಿವ್ಯಕ್ತಿಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆಯೇ привет|здравствуй|салют|хай|бонжур ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಸರಿ.

ಮುಂದೆ ನಾವು ಸಂದೇಶ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ hi_txt_hnd <- MessageHandler(say_hello, filters = MessageFilters$hi). ಮೊದಲ ಫಂಕ್ಷನ್ ಆರ್ಗ್ಯುಮೆಂಟ್ MessageHandler() ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ಕರೆಯುವ ವಿಧಾನವಾಗಿದೆ, ಮತ್ತು ಎರಡನೇ ವಾದವು ಅದನ್ನು ಕರೆಯುವ ಫಿಲ್ಟರ್ ಆಗಿದೆ. ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಇದು ನಾವು ರಚಿಸಿದ ಫಿಲ್ಟರ್ ಆಗಿದೆ MessageFilters$hi.

ಸರಿ, ಕೊನೆಯಲ್ಲಿ, ನಾವು ರಚಿಸಿದ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ರವಾನೆದಾರರಿಗೆ ಸೇರಿಸುತ್ತೇವೆ hi_txt_hnd.

updater <- updater + 
             hi_hendler +
             hi_txt_hnd

ನಾನು ಮೇಲೆ ಬರೆದಂತೆ, ಪ್ಯಾಕೇಜ್‌ನಲ್ಲಿ telegram.bot ಮತ್ತು ವಸ್ತು ಸಂದೇಶ ಫಿಲ್ಟರ್‌ಗಳು ನೀವು ಬಳಸಬಹುದಾದ ಅಂತರ್ನಿರ್ಮಿತ ಫಿಲ್ಟರ್‌ಗಳ ಸೆಟ್ ಈಗಾಗಲೇ ಇದೆ:

• ಎಲ್ಲಾ - ಎಲ್ಲಾ ಸಂದೇಶಗಳು
• ಪಠ್ಯ - ಪಠ್ಯ ಸಂದೇಶಗಳು
• ಆಜ್ಞೆ - ಆಜ್ಞೆಗಳು, ಅಂದರೆ. ಎಂದು ಪ್ರಾರಂಭವಾಗುವ ಸಂದೇಶಗಳು /
• ಪ್ರತ್ಯುತ್ತರ - ಮತ್ತೊಂದು ಸಂದೇಶಕ್ಕೆ ಪ್ರತ್ಯುತ್ತರವಾಗಿರುವ ಸಂದೇಶಗಳು
• ಆಡಿಯೋ - ಆಡಿಯೋ ಫೈಲ್ ಹೊಂದಿರುವ ಸಂದೇಶಗಳು
• ಡಾಕ್ಯುಮೆಂಟ್ - ಕಳುಹಿಸಿದ ದಾಖಲೆಯೊಂದಿಗೆ ಸಂದೇಶಗಳು
• ಫೋಟೋ - ಕಳುಹಿಸಿದ ಚಿತ್ರಗಳೊಂದಿಗೆ ಸಂದೇಶಗಳು
• ಸ್ಟಿಕ್ಕರ್ - ಕಳುಹಿಸಿದ ಸ್ಟಿಕ್ಕರ್‌ನೊಂದಿಗೆ ಸಂದೇಶಗಳು
• ವೀಡಿಯೊ - ವೀಡಿಯೊದೊಂದಿಗೆ ಸಂದೇಶಗಳು
• ಧ್ವನಿ - ಧ್ವನಿ ಸಂದೇಶಗಳು
• ಸಂಪರ್ಕ - ಬಳಕೆದಾರರ ಟೆಲಿಗ್ರಾಮ್ ವಿಷಯವನ್ನು ಹೊಂದಿರುವ ಸಂದೇಶಗಳು
• ಸ್ಥಳ - ಜಿಯೋಲೊಕೇಶನ್‌ನೊಂದಿಗೆ ಸಂದೇಶಗಳು
• ಸ್ಥಳ - ಫಾರ್ವರ್ಡ್ ಮಾಡಿದ ಸಂದೇಶಗಳು
• ಆಟ - ಆಟಗಳು

ನೀವು ಒಂದು ಹ್ಯಾಂಡ್ಲರ್‌ನಲ್ಲಿ ಕೆಲವು ಫಿಲ್ಟರ್‌ಗಳನ್ನು ಸಂಯೋಜಿಸಲು ಬಯಸಿದರೆ ಚಿಹ್ನೆಯನ್ನು ಬಳಸಿ | - ತಾರ್ಕಿಕವಾಗಿ ಅಥವಾ, ಮತ್ತು ಸಹಿ & ತಾರ್ಕಿಕವಾಗಿ И. ಉದಾಹರಣೆಗೆ, ವೀಡಿಯೊ, ಚಿತ್ರ ಅಥವಾ ಡಾಕ್ಯುಮೆಂಟ್ ಅನ್ನು ಸ್ವೀಕರಿಸಿದಾಗ ಬೋಟ್ ಅದೇ ವಿಧಾನವನ್ನು ಕರೆಯಲು ನೀವು ಬಯಸಿದರೆ, ಸಂದೇಶ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ರಚಿಸಲು ಕೆಳಗಿನ ಉದಾಹರಣೆಯನ್ನು ಬಳಸಿ:

handler <- MessageHandler(callback, 
  MessageFilters$video | MessageFilters$photo | MessageFilters$document
)

ನಿಯತಾಂಕಗಳೊಂದಿಗೆ ಆಜ್ಞೆಗಳನ್ನು ಸೇರಿಸಲಾಗುತ್ತಿದೆ

ಆಜ್ಞೆಗಳು ಯಾವುವು, ಅವುಗಳನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಮತ್ತು ಅಪೇಕ್ಷಿತ ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬೋಟ್ ಅನ್ನು ಹೇಗೆ ಒತ್ತಾಯಿಸುವುದು ಎಂದು ನಮಗೆ ಈಗಾಗಲೇ ತಿಳಿದಿದೆ. ಆದರೆ ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ, ಆಜ್ಞೆಯ ಹೆಸರಿನ ಜೊತೆಗೆ, ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಾವು ಕೆಲವು ಡೇಟಾವನ್ನು ರವಾನಿಸಬೇಕಾಗಿದೆ.

ನಿರ್ದಿಷ್ಟ ದಿನಾಂಕ ಮತ್ತು ದೇಶವನ್ನು ನೀಡಿದರೆ, ಉತ್ಪಾದನಾ ಕ್ಯಾಲೆಂಡರ್‌ನಿಂದ ದಿನದ ಪ್ರಕಾರವನ್ನು ನಿಮಗೆ ಹಿಂತಿರುಗಿಸುವ ಬೋಟ್‌ನ ಉದಾಹರಣೆ ಕೆಳಗೆ ಇದೆ.

ಕೆಳಗಿನ ಬೋಟ್ ಪ್ರೊಡಕ್ಷನ್ ಕ್ಯಾಲೆಂಡರ್ API ಅನ್ನು ಬಳಸುತ್ತದೆ isdayoff.ru.

ಕೋಡ್ 3: ದಿನಾಂಕ ಮತ್ತು ದೇಶದ ಪ್ರಕಾರ ವರದಿ ಮಾಡುವ ಬಾಟ್

library(telegram.bot)

# создаём экземпляр класса Updater
updater <- Updater('1165649194:AAFkDqIzQ6Wq5GV0YU7PmEZcv1gmWIFIB_8')

# Пишем метод для приветсвия
## команда приветвия
check_date <- function(bot, update, args) {

  # входящие данные
  day     <- args[1]  # дата
  country <- args[2]  # страна

  # проверка введённых параметров
  if ( !grepl('\d{4}-\d{2}-\d{2}', day) ) {

    # Send Custom Keyboard
    bot$sendMessage(update$message$chat_id, 
                    text = paste0(day, " - некорреткная дата, введите дату в формате ГГГГ-ММ-ДД"),
                    parse_mode = "Markdown")

  } else {
    day <- as.Date(day)
    # переводим в формат POSIXtl
    y <- format(day, "%Y")
    m <- format(day, "%m")
    d <- format(day, "%d")

  }

  # страна для проверки
  ## проверяем задана ли страна
  ## если не задана устанавливаем ru
  if ( ! country %in% c('ru', 'ua', 'by', 'kz', 'us') ) {

    # Send Custom Keyboard
    bot$sendMessage(update$message$chat_id, 
                    text = paste0(country, " - некорретктный код страны, возможнные значения: ru, by, kz, ua, us. Запрошены данные по России."),
                    parse_mode = "Markdown")

    country <- 'ru'

  }

  # запрос данных из API
  # компоновка HTTP запроса
  url <- paste0("https://isdayoff.ru/api/getdata?",
                "year=",  y, "&",
                "month=", m, "&",
                "day=",   d, "&",
                "cc=",    country, "&",
                "pre=1&",
                "covid=1")

  # получаем ответ
  res <- readLines(url)

  # интрепретация ответа
  out <- switch(res, 
                "0"   = "Рабочий день",
                "1"   = "Нерабочий день",
                "2"   = "Сокращённый рабочий день",
                "4"   = "covid-19",
                "100" = "Ошибка в дате",
                "101" = "Данные не найдены",
                "199" = "Ошибка сервиса")

  # отправляем сообщение
  bot$sendMessage(update$message$chat_id, 
                  text = paste0(day, " - ", out),
                  parse_mode = "Markdown")

}

# создаём обработчик 
date_hendler <- CommandHandler('check_date', check_date, pass_args = TRUE)

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

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

ಈ ಮೂಲಕ ಬೋಟ್ ರಚಿಸುವಾಗ ನೀವು ಸ್ವೀಕರಿಸಿದ ನಿಜವಾದ ಟೋಕನ್‌ನೊಂದಿಗೆ 'ನಿಮ್ಮ ಬಾಟ್ ಟೋಕನ್' ಅನ್ನು ಬದಲಿಸಿದ ನಂತರ ಮೇಲಿನ ಕೋಡ್ ಉದಾಹರಣೆಯನ್ನು ರನ್ ಮಾಡಿ ಬೋಟ್ಫೆದರ್ (ನಾನು ಬೋಟ್ ಅನ್ನು ರಚಿಸುವ ಬಗ್ಗೆ ಮಾತನಾಡಿದ್ದೇನೆ ಮೊದಲ ಲೇಖನ).

ನಾವು ಅದರ ಆರ್ಸೆನಲ್ನಲ್ಲಿ ಕೇವಲ ಒಂದು ವಿಧಾನವನ್ನು ಹೊಂದಿರುವ ಬೋಟ್ ಅನ್ನು ರಚಿಸಿದ್ದೇವೆ check_date, ಈ ವಿಧಾನವನ್ನು ಅದೇ ಹೆಸರಿನ ಆಜ್ಞೆಯಿಂದ ಕರೆಯಲಾಗುತ್ತದೆ.

ಆದರೆ, ಆಜ್ಞೆಯ ಹೆಸರಿನ ಜೊತೆಗೆ, ಈ ವಿಧಾನವು ನೀವು ಎರಡು ನಿಯತಾಂಕಗಳನ್ನು ನಮೂದಿಸುವ ಅಗತ್ಯವಿದೆ, ದೇಶದ ಕೋಡ್ ಮತ್ತು ದಿನಾಂಕ. ಮುಂದೆ, ಅಧಿಕೃತ ಉತ್ಪಾದನಾ ಕ್ಯಾಲೆಂಡರ್ ಪ್ರಕಾರ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ದೇಶದಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ದಿನವು ವಾರಾಂತ್ಯ, ಸಂಕ್ಷಿಪ್ತ ದಿನ ಅಥವಾ ಕೆಲಸದ ದಿನವೇ ಎಂಬುದನ್ನು ಬೋಟ್ ಪರಿಶೀಲಿಸುತ್ತದೆ.

ಆಜ್ಞೆಯೊಂದಿಗೆ ಹೆಚ್ಚುವರಿ ನಿಯತಾಂಕಗಳನ್ನು ಸ್ವೀಕರಿಸಲು ನಾವು ರಚಿಸುವ ವಿಧಾನಕ್ಕಾಗಿ, ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ಬಳಸಿ pass_args = TRUE ಕಾರ್ಯದಲ್ಲಿ CommandHandler(), ಮತ್ತು ವಿಧಾನವನ್ನು ರಚಿಸುವಾಗ, ಅಗತ್ಯವಿರುವ ವಾದಗಳ ಜೊತೆಗೆ ಬೋಟ್, ಅಪ್ಡೇಟ್ ಐಚ್ಛಿಕ ಒಂದನ್ನು ರಚಿಸಿ - ಆರ್ಗ್ಸ್. ಈ ರೀತಿಯಲ್ಲಿ ರಚಿಸಲಾದ ವಿಧಾನವು ಕಮಾಂಡ್ ಹೆಸರಿನ ನಂತರ ನೀವು ಬೋಟ್‌ಗೆ ರವಾನಿಸುವ ನಿಯತಾಂಕಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ. ನಿಯತಾಂಕಗಳನ್ನು ಜಾಗದಿಂದ ಬೇರ್ಪಡಿಸಬೇಕು; ಅವುಗಳನ್ನು ಪಠ್ಯ ವೆಕ್ಟರ್ ಆಗಿ ವಿಧಾನಕ್ಕೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ.

ನಮ್ಮ ಬೋಟ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸೋಣ ಮತ್ತು ಪರೀಕ್ಷಿಸೋಣ.

ಹಿನ್ನೆಲೆಯಲ್ಲಿ ಬೋಟ್ ಅನ್ನು ರನ್ ಮಾಡಿ

ನಾವು ಪೂರ್ಣಗೊಳಿಸಬೇಕಾದ ಕೊನೆಯ ಹಂತವೆಂದರೆ ಹಿನ್ನೆಲೆಯಲ್ಲಿ ಬೋಟ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವುದು.

ಇದನ್ನು ಮಾಡಲು, ಕೆಳಗೆ ವಿವರಿಸಿದ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಅನುಸರಿಸಿ:

1. ಆರ್ ವಿಸ್ತರಣೆಯೊಂದಿಗೆ ಫೈಲ್‌ಗೆ ಬೋಟ್ ಕೋಡ್ ಅನ್ನು ಉಳಿಸಿ. RStudio ನಲ್ಲಿ ಕೆಲಸ ಮಾಡುವಾಗ, ಇದನ್ನು ಮೆನು ಮೂಲಕ ಮಾಡಲಾಗುತ್ತದೆ ಫೈಲ್, ತಂಡ ಉಳಿಸಿ ....
2. ಬಿನ್ ಫೋಲ್ಡರ್‌ಗೆ ಮಾರ್ಗವನ್ನು ಸೇರಿಸಿ, ಅದು ನೀವು R ಭಾಷೆಯನ್ನು ಸ್ಥಾಪಿಸಿದ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ, ಪಾತ್ ವೇರಿಯಬಲ್, ಸೂಚನೆಗಳಿಗೆ ಇದೆ ಇಲ್ಲಿ.
3. 1 ಸಾಲನ್ನು ಬರೆಯುವ ಸಾಮಾನ್ಯ ಪಠ್ಯ ಫೈಲ್ ಅನ್ನು ರಚಿಸಿ: R CMD BATCH C:UsersAlseyDocumentsmy_bot.R... ಬದಲಾಗಿ C:UsersAlseyDocumentsmy_bot.R ನಿಮ್ಮ ಬೋಟ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಮಾರ್ಗವನ್ನು ಬರೆಯಿರಿ. ಅದೇ ಸಮಯದಲ್ಲಿ, ದಾರಿಯುದ್ದಕ್ಕೂ ಯಾವುದೇ ಸಿರಿಲಿಕ್ ಅಕ್ಷರಗಳು ಅಥವಾ ಸ್ಥಳಗಳಿಲ್ಲ ಎಂಬುದು ಮುಖ್ಯ, ಏಕೆಂದರೆ ಇದು ಬೋಟ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡುವಾಗ ಸಮಸ್ಯೆಗಳನ್ನು ಉಂಟುಮಾಡಬಹುದು. ಅದನ್ನು ಉಳಿಸಿ ಮತ್ತು ಅದರ ವಿಸ್ತರಣೆಯನ್ನು ಬದಲಾಯಿಸಿ txt ಮೇಲೆ ಬ್ಯಾಟ್.
4. ವಿಂಡೋಸ್ ಟಾಸ್ಕ್ ಶೆಡ್ಯೂಲರ್ ತೆರೆಯಿರಿ, ಇದನ್ನು ಮಾಡಲು ಹಲವು ಮಾರ್ಗಗಳಿವೆ, ಉದಾಹರಣೆಗೆ, ಯಾವುದೇ ಫೋಲ್ಡರ್ ತೆರೆಯಿರಿ ಮತ್ತು ವಿಳಾಸವನ್ನು ನಮೂದಿಸಿ %windir%system32taskschd.msc /s. ಇತರ ಉಡಾವಣಾ ವಿಧಾನಗಳನ್ನು ಕಾಣಬಹುದು ಇಲ್ಲಿ.
5. ಶೆಡ್ಯೂಲರ್‌ನ ಮೇಲಿನ ಬಲ ಮೆನುವಿನಲ್ಲಿ, "ಕಾರ್ಯವನ್ನು ರಚಿಸಿ..." ಕ್ಲಿಕ್ ಮಾಡಿ.
6. "ಸಾಮಾನ್ಯ" ಟ್ಯಾಬ್‌ನಲ್ಲಿ, ನಿಮ್ಮ ಕಾರ್ಯಕ್ಕೆ ಕಸ್ಟಮ್ ಹೆಸರನ್ನು ನೀಡಿ ಮತ್ತು "ಎಲ್ಲಾ ಬಳಕೆದಾರರಿಗಾಗಿ ರನ್" ಸ್ಥಿತಿಗೆ ಸ್ವಿಚ್ ಮಾಡಿ.
7. "ಕ್ರಿಯೆಗಳು" ಟ್ಯಾಬ್ಗೆ ಹೋಗಿ, "ರಚಿಸು" ಕ್ಲಿಕ್ ಮಾಡಿ. "ಪ್ರೋಗ್ರಾಂ ಅಥವಾ ಸ್ಕ್ರಿಪ್ಟ್" ಕ್ಷೇತ್ರದಲ್ಲಿ, "ಬ್ರೌಸ್" ಕ್ಲಿಕ್ ಮಾಡಿ, ಎರಡನೇ ಹಂತದಲ್ಲಿ ರಚಿಸಿದದನ್ನು ಹುಡುಕಿ ಬ್ಯಾಟ್ ಫೈಲ್ ಮತ್ತು ಸರಿ ಕ್ಲಿಕ್ ಮಾಡಿ.
8. ಸರಿ ಕ್ಲಿಕ್ ಮಾಡಿ ಮತ್ತು ಅಗತ್ಯವಿದ್ದರೆ, ನಿಮ್ಮ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಖಾತೆಗಾಗಿ ಪಾಸ್ವರ್ಡ್ ಅನ್ನು ನಮೂದಿಸಿ.
9. ಶೆಡ್ಯೂಲರ್‌ನಲ್ಲಿ ರಚಿಸಿದ ಕಾರ್ಯವನ್ನು ಹುಡುಕಿ, ಅದನ್ನು ಆಯ್ಕೆ ಮಾಡಿ ಮತ್ತು ಕೆಳಗಿನ ಬಲ ಮೂಲೆಯಲ್ಲಿರುವ "ರನ್" ಬಟನ್ ಕ್ಲಿಕ್ ಮಾಡಿ.

ನಮ್ಮ ಬೋಟ್ ಹಿನ್ನೆಲೆಯಲ್ಲಿ ಚಲಿಸುತ್ತದೆ ಮತ್ತು ನೀವು ಕೆಲಸವನ್ನು ನಿಲ್ಲಿಸುವವರೆಗೆ ಅಥವಾ ನಿಮ್ಮ PC ಅಥವಾ ಅದನ್ನು ಪ್ರಾರಂಭಿಸಿದ ಸರ್ವರ್ ಅನ್ನು ಆಫ್ ಮಾಡುವವರೆಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

ತೀರ್ಮಾನಕ್ಕೆ

ಈ ಲೇಖನದಲ್ಲಿ, ಸಂದೇಶಗಳನ್ನು ಕಳುಹಿಸಲು ಮಾತ್ರವಲ್ಲದೆ ಒಳಬರುವ ಸಂದೇಶಗಳು ಮತ್ತು ಆಜ್ಞೆಗಳಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುವ ಪೂರ್ಣ ಪ್ರಮಾಣದ ಬೋಟ್ ಅನ್ನು ಹೇಗೆ ಬರೆಯುವುದು ಎಂದು ನಾವು ಕಂಡುಕೊಂಡಿದ್ದೇವೆ. ನಿಮ್ಮ ಹೆಚ್ಚಿನ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ಪಡೆದ ಜ್ಞಾನವು ಈಗಾಗಲೇ ಸಾಕು.

ಹೆಚ್ಚು ಅನುಕೂಲಕರ ಕೆಲಸಕ್ಕಾಗಿ ಬೋಟ್ಗೆ ಕೀಬೋರ್ಡ್ ಅನ್ನು ಹೇಗೆ ಸೇರಿಸುವುದು ಎಂಬುದರ ಕುರಿತು ಮುಂದಿನ ಲೇಖನವು ಮಾತನಾಡುತ್ತದೆ.

ನನ್ನ ಚಂದಾದಾರರಾಗಿ ಟೆಲಿಗ್ರಾಮ್ и YouTube ಚಾನಲ್‌ಗಳು.

ಮೂಲ: www.habr.com