ടെലിഗ്രാം പ്രേക്ഷകർ അനുദിനം ക്രമാതീതമായി വളരുകയാണ്, മെസഞ്ചറിന്റെ സൗകര്യം, ചാനലുകളുടെ സാന്നിധ്യം, ചാറ്റുകൾ, തീർച്ചയായും ബോട്ടുകൾ സൃഷ്ടിക്കാനുള്ള കഴിവ് എന്നിവയാൽ ഇത് സുഗമമാക്കുന്നു.

നിങ്ങളുടെ ഉപഭോക്താക്കളുമായുള്ള ആശയവിനിമയം ഓട്ടോമേറ്റ് ചെയ്യുന്നത് മുതൽ നിങ്ങളുടെ സ്വന്തം ജോലികൾ കൈകാര്യം ചെയ്യുന്നത് വരെ തികച്ചും വ്യത്യസ്തമായ ആവശ്യങ്ങൾക്കായി ബോട്ടുകൾ ഉപയോഗിക്കാനാകും.

അടിസ്ഥാനപരമായി, ഒരു ബോട്ടിലൂടെ ഏത് പ്രവർത്തനങ്ങളും നടത്താൻ നിങ്ങൾക്ക് ടെലിഗ്രാം ഉപയോഗിക്കാം: ഡാറ്റ അയയ്ക്കുക അല്ലെങ്കിൽ അഭ്യർത്ഥിക്കുക, സെർവറിൽ ടാസ്‌ക്കുകൾ പ്രവർത്തിപ്പിക്കുക, ഒരു ഡാറ്റാബേസിലേക്ക് വിവരങ്ങൾ ശേഖരിക്കുക, ഇമെയിലുകൾ അയയ്‌ക്കുക തുടങ്ങിയവ.

എങ്ങനെ പ്രവർത്തിക്കണം എന്നതിനെക്കുറിച്ചുള്ള ലേഖനങ്ങളുടെ ഒരു പരമ്പര എഴുതാൻ ഞാൻ ആഗ്രഹിക്കുന്നു ടെലിഗ്രാം ബോട്ട് API, നിങ്ങളുടെ ആവശ്യങ്ങൾക്ക് അനുയോജ്യമായ ബോട്ടുകൾ എഴുതുക.

ഈ ആദ്യ ലേഖനത്തിൽ ഒരു ടെലിഗ്രാം ബോട്ട് എങ്ങനെ സൃഷ്ടിക്കാമെന്നും ടെലിഗ്രാമിൽ അറിയിപ്പുകൾ അയയ്ക്കാൻ അത് എങ്ങനെ ഉപയോഗിക്കാമെന്നും ഞങ്ങൾ കണ്ടെത്തും.

തൽഫലമായി, വിൻഡോസ് ടാസ്‌ക് ഷെഡ്യൂളറിലെ എല്ലാ ടാസ്‌ക്കുകളുടെയും അവസാന നിർവ്വഹണത്തിന്റെ നില പരിശോധിക്കുന്ന ഒരു ബോട്ട് ഞങ്ങൾക്കുണ്ടാകും, അവയിലേതെങ്കിലും പരാജയപ്പെട്ടാൽ നിങ്ങൾക്ക് അറിയിപ്പുകൾ അയയ്ക്കും.

എന്നാൽ ഈ ലേഖന പരമ്പരയുടെ ഉദ്ദേശ്യം ഒരു നിർദ്ദിഷ്ട, ഇടുങ്ങിയ ടാസ്‌ക്കിനായി ഒരു ബോട്ട് എങ്ങനെ എഴുതാമെന്ന് നിങ്ങളെ പഠിപ്പിക്കുകയല്ല, മറിച്ച് പാക്കേജിന്റെ വാക്യഘടനയിലേക്ക് നിങ്ങളെ പൊതുവെ പരിചയപ്പെടുത്തുക എന്നതാണ്. telegram.bot, കൂടാതെ നിങ്ങളുടെ സ്വന്തം പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ ബോട്ടുകൾ എഴുതാൻ കഴിയുന്ന കോഡ് ഉദാഹരണങ്ങൾ.

ഉള്ളടക്കം

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

1. ഒരു ടെലിഗ്രാം ബോട്ട് സൃഷ്ടിക്കുന്നു
2. R-ൽ ഒരു ടെലിഗ്രാം ബോട്ടിൽ പ്രവർത്തിക്കാൻ ഒരു പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്യുന്നു
3. R-ൽ നിന്ന് ടെലിഗ്രാമിലേക്ക് സന്ദേശങ്ങൾ അയയ്ക്കുന്നു
4. ടാസ്‌ക് സ്കാനുകൾ പ്രവർത്തിപ്പിക്കുന്നതിന് ഒരു ഷെഡ്യൂൾ സജ്ജീകരിക്കുന്നു
5. തീരുമാനം

ഒരു ടെലിഗ്രാം ബോട്ട് സൃഷ്ടിക്കുന്നു

ആദ്യം നമ്മൾ ഒരു ബോട്ട് ഉണ്ടാക്കണം. ഒരു പ്രത്യേക ബോട്ട് ഉപയോഗിച്ചാണ് ഇത് ചെയ്യുന്നത് ബോട്ട്ഫാദർ, പോകുക ലിങ്ക് ബോട്ടിന് എഴുതുകയും ചെയ്യുക /start.

അതിനുശേഷം നിങ്ങൾക്ക് കമാൻഡുകളുടെ ഒരു ലിസ്റ്റ് ഉള്ള ഒരു സന്ദേശം ലഭിക്കും:

ബോട്ട്ഫാദറിൽ നിന്നുള്ള സന്ദേശം

I can help you create and manage Telegram bots. If you're new to the Bot API, please see the manual (https://core.telegram.org/bots).

You can control me by sending these commands:

/newbot - create a new bot
/mybots - edit your bots [beta]

Edit Bots
/setname - change a bot's name
/setdescription - change bot description
/setabouttext - change bot about info
/setuserpic - change bot profile photo
/setcommands - change the list of commands
/deletebot - delete a bot

Bot Settings
/token - generate authorization token
/revoke - revoke bot access token
/setinline - toggle inline mode (https://core.telegram.org/bots/inline)
/setinlinegeo - toggle inline location requests (https://core.telegram.org/bots/inline#location-based-results)
/setinlinefeedback - change inline feedback (https://core.telegram.org/bots/inline#collecting-feedback) settings
/setjoingroups - can your bot be added to groups?
/setprivacy - toggle privacy mode (https://core.telegram.org/bots#privacy-mode) in groups

Games
/mygames - edit your games (https://core.telegram.org/bots/games) [beta]
/newgame - create a new game (https://core.telegram.org/bots/games)
/listgames - get a list of your games
/editgame - edit a game
/deletegame - delete an existing game

ഒരു പുതിയ ബോട്ട് സൃഷ്ടിക്കാൻ, കമാൻഡ് അയയ്ക്കുക /newbot.

ബോട്ടിന്റെ പേര് നൽകി ലോഗിൻ ചെയ്യാൻ ബോട്ട്ഫാദർ നിങ്ങളോട് ആവശ്യപ്പെടും.

BotFather, [25.07.20 09:39]
Alright, a new bot. How are we going to call it? Please choose a name for your bot.

Alexey Seleznev, [25.07.20 09:40]
My Test Bot

BotFather, [25.07.20 09:40]
Good. Now let's choose a username for your bot. It must end in `bot`. Like this, for example: TetrisBot or tetris_bot.

Alexey Seleznev, [25.07.20 09:40]
@my_test_bot

നിങ്ങൾക്ക് ഏത് പേരും നൽകാം, എന്നാൽ ലോഗിൻ അവസാനിക്കണം bot.

നിങ്ങൾ എല്ലാം ശരിയായി ചെയ്തുവെങ്കിൽ, നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന സന്ദേശം ലഭിക്കും:

Done! Congratulations on your new bot. You will find it at t.me/my_test_bot. You can now add a description, about section and profile picture for your bot, see /help for a list of commands. By the way, when you've finished creating your cool bot, ping our Bot Support if you want a better username for it. Just make sure the bot is fully operational before you do this.

Use this token to access the HTTP API:
123456789:abcdefghijklmnopqrstuvwxyz

For a description of the Bot API, see this page: https://core.telegram.org/bots/api

അടുത്തതായി നിങ്ങൾക്ക് ലഭിച്ച API ടോക്കൺ ആവശ്യമാണ്, എന്റെ ഉദാഹരണത്തിൽ അത് 123456789:abcdefghijklmnopqrstuvwxyz.

ഈ ഘട്ടത്തിൽ, ബോട്ട് സൃഷ്ടിക്കുന്നതിനുള്ള തയ്യാറെടുപ്പ് ജോലികൾ പൂർത്തിയായി.

R-ൽ ഒരു ടെലിഗ്രാം ബോട്ടിൽ പ്രവർത്തിക്കാൻ ഒരു പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്യുന്നു

നിങ്ങൾ ഇതിനകം R ഭാഷയും RStudio വികസന പരിതസ്ഥിതിയും ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെന്ന് ഞാൻ അനുമാനിക്കുന്നു. ഇത് അങ്ങനെയല്ലെങ്കിൽ, നിങ്ങൾക്ക് ഇത് നോക്കാം വീഡിയോ ട്യൂട്ടോറിയൽ അവ എങ്ങനെ ഇൻസ്റ്റാൾ ചെയ്യാം എന്നതിനെക്കുറിച്ച്.

ടെലിഗ്രാം ബോട്ട് API-യിൽ പ്രവർത്തിക്കാൻ ഞങ്ങൾ R പാക്കേജ് ഉപയോഗിക്കും telegram.bot.

ഫംഗ്ഷൻ ഉപയോഗിച്ചാണ് R-ൽ പാക്കേജുകൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നത് install.packages(), അതിനാൽ നമുക്ക് ആവശ്യമുള്ള പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്യാൻ, കമാൻഡ് ഉപയോഗിക്കുക install.packages("telegram.bot").

വിവിധ പാക്കേജുകൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നതിനെക്കുറിച്ച് നിങ്ങൾക്ക് കൂടുതലറിയാൻ കഴിയും ഈ വീഡിയോ.

പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്ത ശേഷം, നിങ്ങൾ ഇത് ബന്ധിപ്പിക്കേണ്ടതുണ്ട്:

library(telegram.bot)

R-ൽ നിന്ന് ടെലിഗ്രാമിലേക്ക് സന്ദേശങ്ങൾ അയയ്ക്കുന്നു

സൃഷ്‌ടിക്കുമ്പോൾ വ്യക്തമാക്കിയ ലോഗിൻ ഉപയോഗിച്ച് നിങ്ങൾ സൃഷ്ടിച്ച ബോട്ട് ടെലിഗ്രാമിൽ കണ്ടെത്താൻ കഴിയും, എന്റെ കാര്യത്തിൽ ഇത് @my_test_bot.

ബോട്ടിന് "ഹേ ബോട്ട്" പോലുള്ള എന്തെങ്കിലും സന്ദേശം അയയ്‌ക്കുക. ഇപ്പോൾ, ബോട്ടുമായുള്ള നിങ്ങളുടെ ചാറ്റിന്റെ ഐഡി ലഭിക്കുന്നതിന് ഞങ്ങൾക്ക് ഇത് ആവശ്യമാണ്.

ഇനി നമ്മൾ R-ൽ താഴെ പറയുന്ന കോഡ് എഴുതുന്നു.

library(telegram.bot)

# создаём экземпляр бота
bot <- Bot(token = "123456789:abcdefghijklmnopqrstuvwxyz")

# Запрашиваем информацию о боте
print(bot$getMe())

# Получаем обновления бота, т.е. список отправленных ему сообщений
updates <- bot$getUpdates()

# Запрашиваем идентификатор чата
# Примечание: перед запросом обновлений вы должны отправить боту сообщение
chat_id <- updates[[1L]]$from_chat_id()

തുടക്കത്തിൽ, ഫംഗ്ഷൻ ഉപയോഗിച്ച് ഞങ്ങളുടെ ബോട്ടിന്റെ ഒരു ഉദാഹരണം ഞങ്ങൾ സൃഷ്ടിക്കുന്നു Bot(), മുമ്പ് ലഭിച്ച ടോക്കൺ അതിലേക്ക് ഒരു ആർഗ്യുമെന്റായി നൽകണം.

കോഡിൽ ടോക്കൺ സംഭരിക്കുന്നത് മികച്ച രീതിയായി കണക്കാക്കില്ല, അതിനാൽ നിങ്ങൾക്കത് ഒരു എൻവയോൺമെന്റ് വേരിയബിളിൽ സംഭരിക്കാനും അതിൽ നിന്ന് വായിക്കാനും കഴിയും. പാക്കേജിൽ സ്ഥിരസ്ഥിതിയായി telegram.bot ഇനിപ്പറയുന്ന പേരുകളുടെ പരിസ്ഥിതി വേരിയബിളുകൾക്കുള്ള പിന്തുണ നടപ്പിലാക്കി: R_TELEGRAM_BOT_ИМЯ_ВАШЕГО_БОТА. ഇതിനുപകരമായി ИМЯ_ВАШЕГО_БОТА സൃഷ്ടിക്കുമ്പോൾ നിങ്ങൾ വ്യക്തമാക്കിയ പേര് പകരം വയ്ക്കുക, എന്റെ കാര്യത്തിൽ ഇത് ഒരു വേരിയബിളായിരിക്കും R_TELEGRAM_BOT_My Test Bot.

ഒരു പരിസ്ഥിതി വേരിയബിൾ സൃഷ്ടിക്കാൻ നിരവധി മാർഗങ്ങളുണ്ട്; ഏറ്റവും സാർവത്രികവും ക്രോസ്-പ്ലാറ്റ്ഫോമും ഞാൻ നിങ്ങളോട് പറയും. നിങ്ങളുടെ ഹോം ഡയറക്ടറിയിൽ സൃഷ്ടിക്കുക (കമാൻഡ് ഉപയോഗിച്ച് നിങ്ങൾക്കത് കണ്ടെത്താനാകും path.expand("~")) പേരുള്ള ടെക്സ്റ്റ് ഫയൽ .റെൻവിറോൺ. കമാൻഡ് ഉപയോഗിച്ചും നിങ്ങൾക്ക് ഇത് ചെയ്യാൻ കഴിയും file.edit(path.expand(file.path("~", ".Renviron"))).

അതിലേക്ക് ഇനിപ്പറയുന്ന വരി ചേർക്കുക.

R_TELEGRAM_BOT_ИМЯ_ВАШЕГО_БОТА=123456789:abcdefghijklmnopqrstuvwxyz

അടുത്തതായി, ഫംഗ്ഷൻ ഉപയോഗിച്ച് പരിസ്ഥിതി വേരിയബിളിൽ സംരക്ഷിച്ചിരിക്കുന്ന ടോക്കൺ നിങ്ങൾക്ക് ഉപയോഗിക്കാം bot_token(), അതായത്. ഇതുപോലെ:

bot <- Bot(token = bot_token("My Test Bot"))

രീതി getUpdates()ബോട്ട് അപ്‌ഡേറ്റുകൾ ലഭിക്കാൻ ഞങ്ങളെ അനുവദിക്കുന്നു, അതായത്. അയാൾക്ക് അയച്ച സന്ദേശങ്ങൾ. രീതി from_chat_id(), സന്ദേശം അയച്ച ചാറ്റിന്റെ ഐഡി ലഭിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ബോട്ടിൽ നിന്ന് സന്ദേശങ്ങൾ അയയ്‌ക്കാൻ ഞങ്ങൾക്ക് ഈ ഐഡി ആവശ്യമാണ്.

മെത്തേഡ് വഴി ലഭിച്ച ഒബ്ജക്റ്റിൽ നിന്നുള്ള ചാറ്റ് ഐഡിക്ക് പുറമേ getUpdates() നിങ്ങൾക്ക് മറ്റ് ചില ഉപയോഗപ്രദമായ വിവരങ്ങളും ലഭിക്കും. ഉദാഹരണത്തിന്, സന്ദേശം അയച്ച ഉപയോക്താവിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ.

updates[[1L]]$message$from

$id
[1] 000000000

$is_bot
[1] FALSE

$first_name
[1] "Alexey"

$last_name
[1] "Seleznev"

$username
[1] "AlexeySeleznev"

$language_code
[1] "ru"

അതിനാൽ, ഈ ഘട്ടത്തിൽ ഒരു ബോട്ടിൽ നിന്ന് ടെലിഗ്രാമിലേക്ക് ഒരു സന്ദേശം അയയ്‌ക്കാൻ ആവശ്യമായതെല്ലാം ഇതിനകം തന്നെ ഞങ്ങളുടെ പക്കലുണ്ട്. നമുക്ക് രീതി ഉപയോഗിക്കാം sendMessage(), അതിലേക്ക് നിങ്ങൾ ചാറ്റ് ഐഡി, സന്ദേശ വാചകം, സന്ദേശ ടെക്സ്റ്റ് മാർക്ക്അപ്പ് തരം എന്നിവ കൈമാറേണ്ടതുണ്ട്. മാർക്ക്അപ്പ് തരം മാർക്ക്ഡൗൺ അല്ലെങ്കിൽ HTML ആകാം, അത് ആർഗ്യുമെന്റ് പ്രകാരം സജ്ജീകരിച്ചിരിക്കുന്നു parse_mode.

# Отправка сообщения
bot$sendMessage(chat_id,
                text = "Привет, *жирный текст* _курсив_",
                parse_mode = "Markdown"
)

മാർക്ക്ഡൗൺ ഫോർമാറ്റിംഗ് അടിസ്ഥാനങ്ങൾ:

• ബോൾഡ് ഫോണ്ട് *:
  • ഉദാഹരണം: *жирный шритф*
  • ഫലമായി: ബോൾഡ് ഫോണ്ട്
• ഇറ്റാലിക്സ് അടിവരയിട്ട് സൂചിപ്പിച്ചിരിക്കുന്നു:
  • ഉദാഹരണം: _курсив_
  • ഫലമായി: ഇറ്റാലിക്സ്
• സാധാരണയായി പ്രോഗ്രാം കോഡ് ഹൈലൈറ്റ് ചെയ്യാൻ ഉപയോഗിക്കുന്ന മോണോസ്പേസ് ഫോണ്ട്, അപ്പോസ്ട്രോഫിസ് ഉപയോഗിച്ചാണ് വ്യക്തമാക്കിയിരിക്കുന്നത് - `:
  • ഉദാഹരണം: `മോണോസ്പേസ് ഫോണ്ട്`
  • ഫലമായി: моноширинный шрифт

HTML മാർക്ക്അപ്പ് ഫോർമാറ്റ് ചെയ്യുന്നതിനുള്ള അടിസ്ഥാനങ്ങൾ:
HTML-ൽ, ടാഗുകളിൽ ഹൈലൈറ്റ് ചെയ്യേണ്ട ടെക്സ്റ്റിന്റെ ഭാഗം നിങ്ങൾ പൊതിയുന്നു, ഉദാഹരണത്തിന് <тег>текст</тег>.

• <tag> - തുറക്കുന്ന ടാഗ്
• - ക്ലോസിംഗ് ടാഗ്

HTML മാർക്ക്അപ്പ് ടാഗുകൾ

• <b> - ബോൾഡ് ഫോണ്ട്
  • ഉദാഹരണം: <b>жирный шрифт</b>
  • ഇഫക്ട് ബോൾഡ് ഫോണ്ട്
• <i> - ഇറ്റാലിക്സ്
  • ഉദാഹരണം: <i>курсив</i>
  • ഫലമായി: ഇറ്റാലിക്സ്
• — моноширинный шрифт
  • ഉദാഹരണം: моноширинный шрифт
  • ഫലമായി: моноширинный шрифт

വാചകത്തിന് പുറമേ, പ്രത്യേക രീതികൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് മറ്റ് ഉള്ളടക്കം അയയ്ക്കാൻ കഴിയും:

# Отправить изображение
bot$sendPhoto(chat_id,
  photo = "https://telegram.org/img/t_logo.png"
)

# Отправка голосового сообщения
bot$sendAudio(chat_id,
  audio = "http://www.largesound.com/ashborytour/sound/brobob.mp3"
)

# Отправить документ
bot$sendDocument(chat_id,
  document = "https://github.com/ebeneditos/telegram.bot/raw/gh-pages/docs/telegram.bot.pdf"
)

# Отправить стикер
bot$sendSticker(chat_id,
  sticker = "https://www.gstatic.com/webp/gallery/1.webp"
)

# Отправить видео
bot$sendVideo(chat_id,
  video = "http://techslides.com/demos/sample-videos/small.mp4"
)

# Отправить gif анимацию
bot$sendAnimation(chat_id,
  animation = "https://media.giphy.com/media/sIIhZliB2McAo/giphy.gif"
)

# Отправить локацию
bot$sendLocation(chat_id,
  latitude = 51.521727,
  longitude = -0.117255
)

# Имитация действия в чате
bot$sendChatAction(chat_id,
  action = "typing"
)

ആ. ഉദാഹരണത്തിന് രീതി ഉപയോഗിച്ച് sendPhoto() പാക്കേജ് ഉപയോഗിച്ച് നിങ്ങൾ സൃഷ്ടിച്ച ഒരു ഇമേജായി സംരക്ഷിച്ചിരിക്കുന്ന ഒരു ഗ്രാഫ് നിങ്ങൾക്ക് അയയ്ക്കാൻ കഴിയും ggplot2.

വിൻഡോസ് ടാസ്ക് ഷെഡ്യൂളർ പരിശോധിച്ച് അസാധാരണമായി അവസാനിപ്പിച്ച ടാസ്ക്കുകളെക്കുറിച്ചുള്ള അറിയിപ്പുകൾ അയയ്ക്കുന്നു

വിൻഡോസ് ടാസ്ക് ഷെഡ്യൂളറുമായി പ്രവർത്തിക്കാൻ നിങ്ങൾ പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതുണ്ട് taskscheduleR, കൂടാതെ ഡാറ്റയുമായി പ്രവർത്തിക്കാനുള്ള സൗകര്യത്തിനായി, പാക്കേജ് ഇൻസ്റ്റാൾ ചെയ്യുക dplyr.

# Установка пакетов
install.packages(c('taskscheduleR', 'dplyr'))
# Подключение пакетов
library(taskscheduleR)
library(dplyr)

അടുത്തതായി, ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു taskscheduler_ls() ഞങ്ങളുടെ ഷെഡ്യൂളറിൽ നിന്ന് ടാസ്‌ക്കുകളെക്കുറിച്ചുള്ള വിവരങ്ങൾ ഞങ്ങൾ അഭ്യർത്ഥിക്കുന്നു. ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു filter() പാക്കേജിൽ നിന്ന് dplyr ഞങ്ങൾ ടാസ്‌ക്കുകളുടെ ലിസ്റ്റിൽ നിന്ന് വിജയകരമായി പൂർത്തിയാക്കിയതും അവസാന ഫല നില 0 ഉള്ളവയും ഇതുവരെ സമാരംഭിച്ചിട്ടില്ലാത്തതും 267011 എന്ന സ്റ്റാറ്റസ് ഉള്ളവയും പ്രവർത്തനരഹിതമാക്കിയ ടാസ്‌ക്കുകളും നിലവിൽ പ്രവർത്തിക്കുന്ന ടാസ്‌ക്കുകളും നീക്കംചെയ്യുന്നു.

# запрашиваем список задач
task <- task <- taskscheduler_ls() %>%
        filter(! `Last Result`  %in% c("0", "267011") & 
               `Scheduled Task State` == "Enabled" & 
               Status != "Running") %>%
        select(TaskName) %>%
        unique() %>%
        unlist() %>%
        paste0(., collapse = "n")

സൗകര്യത്തിൽ task പരാജയപ്പെട്ട ടാസ്ക്കുകളുടെ ഒരു ലിസ്റ്റ് ഞങ്ങളുടെ പക്കലുണ്ട്, ഈ ലിസ്റ്റ് ടെലിഗ്രാമിലേക്ക് അയയ്‌ക്കേണ്ടതുണ്ട്.

നമ്മൾ ഓരോ കമാൻഡും കൂടുതൽ വിശദമായി നോക്കുകയാണെങ്കിൽ:

• filter() - മുകളിൽ വിവരിച്ച വ്യവസ്ഥകൾക്കനുസൃതമായി ടാസ്ക്കുകളുടെ ലിസ്റ്റ് ഫിൽട്ടർ ചെയ്യുന്നു
• select() - ടാസ്ക്കുകളുടെ പേരിനൊപ്പം പട്ടികയിൽ ഒരു ഫീൽഡ് മാത്രം അവശേഷിക്കുന്നു
• unique() - തനിപ്പകർപ്പ് പേരുകൾ നീക്കംചെയ്യുന്നു
• unlist() - തിരഞ്ഞെടുത്ത പട്ടിക നിരയെ വെക്‌ടറാക്കി മാറ്റുന്നു
• paste0() - ടാസ്ക്കുകളുടെ പേരുകൾ ഒരു വരിയിലേക്ക് ബന്ധിപ്പിക്കുന്നു, കൂടാതെ ഒരു ലൈൻ ഫീഡ് ഒരു സെപ്പറേറ്ററായി ഇടുന്നു, അതായത്. n.

ഈ ഫലം ടെലിഗ്രാം വഴി അയയ്ക്കുക മാത്രമാണ് ഞങ്ങൾക്ക് അവശേഷിക്കുന്നത്.

bot$sendMessage(chat_id,
                text = task,
                parse_mode = "Markdown"
)

അതിനാൽ, ഇപ്പോൾ ബോട്ട് കോഡ് ഇതുപോലെ കാണപ്പെടുന്നു:

ടാസ്‌ക് റിവ്യൂ ബോട്ട് കോഡ്

# Подключение пакета
library(telegram.bot)
library(taskscheduleR)
library(dplyr)

# инициализируем бота
bot <- Bot(token = "123456789:abcdefghijklmnopqrstuvwxyz")

# идентификатор чата
chat_id <- 123456789

# запрашиваем список задач
task <- taskscheduler_ls() %>%
        filter(! `Last Result`  %in% c("0", "267011")  &
               `Scheduled Task State` == "Enabled" & 
               Status != "Running") %>%
        select(TaskName) %>%
        unique() %>%
        unlist() %>%
        paste0(., collapse = "n")

# если есть проблемные задачи отправляем сообщение
if ( task != "" ) {

  bot$sendMessage(chat_id,
                  text = task,
                  parse_mode = "Markdown"
  )

}

മുകളിലുള്ള ഉദാഹരണം ഉപയോഗിക്കുമ്പോൾ, നിങ്ങളുടെ ബോട്ട് ടോക്കണും നിങ്ങളുടെ ചാറ്റ് ഐഡിയും കോഡിലേക്ക് മാറ്റിസ്ഥാപിക്കുക.

ടാസ്‌ക്കുകൾ ഫിൽട്ടർ ചെയ്യുന്നതിനായി നിങ്ങൾക്ക് വ്യവസ്ഥകൾ ചേർക്കാൻ കഴിയും, ഉദാഹരണത്തിന്, നിങ്ങൾ സൃഷ്‌ടിച്ച ടാസ്‌ക്കുകൾ മാത്രം പരിശോധിക്കുക, സിസ്റ്റത്തിലുള്ളവ ഒഴികെ.

നിങ്ങൾക്ക് ഒരു പ്രത്യേക കോൺഫിഗറേഷൻ ഫയലിലേക്ക് വിവിധ ക്രമീകരണങ്ങൾ ഇടാനും അതിൽ ചാറ്റ് ഐഡിയും ടോക്കണും സംഭരിക്കാനും കഴിയും. നിങ്ങൾക്ക് കോൺഫിഗറേഷൻ വായിക്കാം, ഉദാഹരണത്തിന്, പാക്കേജ് ഉപയോഗിച്ച് configr.

ഉദാഹരണം ini കോൺഫിഗറേഷൻ

[telegram_bot]
;настройки телеграм бота и чата, в который будут приходить уведомления
chat_id=12345678
bot_token=123456789:abcdefghijklmnopqrstuvwxyz"

R ലെ കോൺഫിഗറിൽ നിന്നുള്ള വേരിയബിളുകൾ വായിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം

library(configr)

# чтение конфина
config <- read.config('C:/путь_к_конфигу/config.cfg', rcmd.parse = TRUE)

bot_token <- config$telegram_bot$bot_token
chat_id     <- config$telegram_bot$chat_id

ടാസ്‌ക് സ്കാനുകൾ പ്രവർത്തിപ്പിക്കുന്നതിന് ഒരു ഷെഡ്യൂൾ സജ്ജീകരിക്കുന്നു

ഒരു ഷെഡ്യൂളിൽ സ്ക്രിപ്റ്റുകളുടെ ലോഞ്ച് സജ്ജീകരിക്കുന്ന പ്രക്രിയ ഇതിൽ കൂടുതൽ വിശദമായി വിവരിച്ചിരിക്കുന്നു ലേഖനം. ഇതിനായി പാലിക്കേണ്ട ഘട്ടങ്ങൾ മാത്രമാണ് ഞാൻ ഇവിടെ വിവരിക്കുന്നത്. ഏതെങ്കിലും ഘട്ടങ്ങൾ നിങ്ങൾക്ക് വ്യക്തമല്ലെങ്കിൽ, ഞാൻ ഒരു ലിങ്ക് നൽകിയ ലേഖനം പരിശോധിക്കുക.

നമ്മൾ നമ്മുടെ ബോട്ട് കോഡ് ഒരു ഫയലിൽ സേവ് ചെയ്തു എന്ന് കരുതുക check_bot.R. ഈ ഫയൽ പതിവായി റൺ ചെയ്യാൻ ഷെഡ്യൂൾ ചെയ്യാൻ, ഈ ഘട്ടങ്ങൾ പാലിക്കുക:

1. പാത്ത് സിസ്റ്റം വേരിയബിളിൽ R ഇൻസ്റ്റാൾ ചെയ്തിരിക്കുന്ന ഫോൾഡറിലേക്കുള്ള പാത്ത് എഴുതുക; വിൻഡോസിൽ, പാത്ത് ഇതുപോലെയായിരിക്കും: C:Program FilesRR-4.0.2bin.
2. ഒരു ലൈൻ ഉപയോഗിച്ച് എക്സിക്യൂട്ടബിൾ ബാറ്റ് ഫയൽ സൃഷ്ടിക്കുക R CMD BATCH C:rscriptscheck_botcheck_bot.R. മാറ്റിസ്ഥാപിക്കുക C:rscriptscheck_botcheck_bot.R നിങ്ങളുടെ R ഫയലിലേക്കുള്ള പൂർണ്ണ പാതയിലേക്ക്.
3. അടുത്തതായി, ഒരു ലോഞ്ച് ഷെഡ്യൂൾ സജ്ജീകരിക്കാൻ വിൻഡോസ് ടാസ്ക് ഷെഡ്യൂളർ ഉപയോഗിക്കുക, ഉദാഹരണത്തിന്, ഓരോ അര മണിക്കൂറിലും.

തീരുമാനം

ഈ ലേഖനത്തിൽ, ഒരു ബോട്ട് എങ്ങനെ സൃഷ്ടിക്കാമെന്നും ടെലിഗ്രാമിൽ വിവിധ അറിയിപ്പുകൾ അയയ്ക്കാൻ അത് എങ്ങനെ ഉപയോഗിക്കാമെന്നും ഞങ്ങൾ കണ്ടെത്തി.

വിൻഡോസ് ടാസ്ക് ഷെഡ്യൂളർ നിരീക്ഷിക്കുന്നതിനുള്ള ചുമതല ഞാൻ വിവരിച്ചു, എന്നാൽ കാലാവസ്ഥാ പ്രവചനം മുതൽ സ്റ്റോക്ക് എക്സ്ചേഞ്ചിലെ സ്റ്റോക്ക് ഉദ്ധരണികൾ വരെ ഏതെങ്കിലും അറിയിപ്പുകൾ അയയ്ക്കാൻ നിങ്ങൾക്ക് ഈ ലേഖനത്തിലെ മെറ്റീരിയൽ ഉപയോഗിക്കാം. ധാരാളം ഡാറ്റ ഉറവിടങ്ങളിലേക്ക് കണക്റ്റുചെയ്യാൻ R നിങ്ങളെ അനുവദിക്കുന്നു.

അടുത്ത ലേഖനത്തിൽ, ബോട്ടിലേക്ക് കമാൻഡുകളും ഒരു കീബോർഡും എങ്ങനെ ചേർക്കാമെന്ന് ഞങ്ങൾ കണ്ടെത്തും, അതുവഴി അറിയിപ്പുകൾ അയയ്ക്കാൻ മാത്രമല്ല, കൂടുതൽ സങ്കീർണ്ണമായ പ്രവർത്തനങ്ങൾ നടത്താനും കഴിയും.

അവലംബം: www.habr.com