I tidigare publicering Vi har klurat ut hur man skapar en bot och initierat en instans av klassen Bot och bekantat oss med metoderna för att skicka meddelanden med hjälp av den.

I den här artikeln fortsätter jag med detta ämne, så jag rekommenderar att du först läser första delen.

Denna gång ska vi ta reda på hur vi livar upp vår bot och lägger till kommando stödet samt bekantar oss med klassen Updater.

Under artikeln kommer vi att skriva flera enkla bots, den sista kommer att avgöra om en angiven dag med ett lands kod är en helg eller arbetsdag enligt produktionskalendern. Men, som tidigare, är syftet med artikeln att introducera dig till paketets gränssnitt telegram.bot för att lösa dina egna uppgifter.

Alla artiklar i serien "Skriver en Telegram-bot på R"

1. Skapar en bot och skickar meddelanden genom den i Telegram
2. Lägger till kommandostöd och meddelandefilter till boten

Innehåll

Om du är intresserad av dataanalys kan du vara intresserad av mina telegram och YouTube kanaler. Största delen av innehållet handlar om R-språket.

1. Klassen Updater
2. Handlers — hanterare
3. Vi lägger till det första kommandot till boten, kommandohanteraren
4. Hanterare för textmeddelanden och filter
5. Lägg till kommandon med parametrar
6. Kör boten i bakgrunden
7. Slutsats

Klassen Updater

Updater — det är en klass som förenklar utvecklingen av en Telegram-bot och använder inuti klassen Dispatcher. Klassens syfte Updater är att hämta uppdateringar från boten (i den föregående artikeln använde vi metoden getUpdates()), och skicka dem vidare till Dispatcher.

I sin tur Dispatcher innehåller de skapade hanterarna, dvs. objekten av klassen Handler.

Handlers — hanterare

Med hjälp av hanterarna lägger du till Dispatcher botens reaktioner på olika händelser. Vid tidpunkten för artikelns skrivande har telegram.bot följande typer av hanterare lagts till:

• MessageHandler — Meddelandehanterare
• CommandHandler — Kommandohanterare
• CallbackQueryHandler — Hanterare för data skickat från Inline-tangentbord
• ErrorHandler — Felhanterare vid begäran om uppdateringar från boten

Vi lägger till det första kommandot till boten, kommandohanteraren

Om du aldrig tidigare har använt bots och inte är medveten om vad ett kommando är, så behöver du skicka kommandon till boten med ett snedstreck / som prefix.

Vi börjar med enkla kommandon, dvs. vi lär vår bot att hälsa på kommando /hi.

Kod 1: Vi lär boten att hälsa

library(telegram.bot)

# Skapar en instans av klassen Updater
updater <- Updater('DIN BOTS TOKEN')

# Skriver en metod för att ge ett välkomnande
say_hello <- function(bot, update) {

  # Användarnamn att hälsa på
  user_name <- update$message$from$first_name

  # Skickar ett välkomstmeddelande
  bot$sendMessage(update$message$chat_id, 
                  text = paste0("Hej, ", user_name, "!"), 
                  parse_mode = "Markdown")

}

# Skapar en hanterare
hi_hendler <- CommandHandler('hi', say_hello)

# Lägg till hanteraren i övervakaren
updater <- updater + hi_hendler

# Startar boten
updater$start_polling()

Kör koden ovan efter att ha bytt ut ‘DINA BOT TOKEN’ mot den verkliga token som du fick när du skapade boten via BotFather (jag beskrev hur man skapar en bot i den första artikeln).

Metod start_polling() klassen Updater, som används i slutet av koden, startar en oändlig loop för att begära och behandla uppdateringar från boten.

Nu öppnar vi Telegram och skriver vårt första kommando till vår bot /hi.

Nu förstår vår bot kommandot /hi, och kan hälsa på oss.

Schematic kan processen för att skapa en sådan enkel bot beskrivas som följer.

1. Skapar en instans av klassen Updater;
2. Skapar metoder, det vill säga funktioner som vår bot ska utföra. I exempel koden är det funktionen say_hello(). Funktioner som du kommer att använda som botmetoder måste ha två obligatoriska argument — bot och update, och ett valfritt — args. Argumentet botär din bot, med hjälp av den kan du svara på meddelanden, skicka meddelanden, eller använda andra tillgängliga metoder för boten. Argumentet update är det som boten mottog från användaren, i själva verket vad vi i den första artikeln fick med metoden getUpdates(). Argumentet args låter dig behandla ytterligare data som skickas av användaren tillsammans med kommandot, vi kommer att återkomma till detta ämne lite senare;
3. Skapar hanterare, det vill säga kopplar vissa åtgärder av användaren till de metoder som skapades i föregående steg. I själva verket är en hanterare en trigger, en händelse som utlöser en funktion i boten. I vårt exempel är en sådan trigger att skicka kommandot /hi, och implementeras med kommandot hi_hendler <- CommandHandler('hi', say_hello). Den första argumentet i funktionen CommandHandler() låter dig ställa in kommandot, i vårt fall hi, som boten kommer att reagera på. Det andra argumentet låter dig ange botens metod, vi kommer att kalla metoden say_hello, som kommer att köras om användaren aktiverade det angivna kommandot i det första argumentet;
4. Sedan lägger vi till den skapade hanteraren i övervakaren för vår instans av klassen Updater. Du kan lägga till hanterare på flera sätt, i exemplet ovan använde jag den enklaste metoden med hjälp av tecknet +, dvs. updater <- updater + hi_hendler. Detsamma kan göras med metoden add_handler(), som hör till klassen Dispatcher, den här metoden kan du hitta så här: updater$dispatcher$add_handler();
5. Vi startar boten med kommandot start_polling().

Hanterare för textmeddelanden och filter

Vi har förstått hur vi ska skicka kommandon till boten, men ibland behöver vi att boten reagerar inte bara på kommandon utan även på vanliga textmeddelanden. För detta ändamål måste vi använda meddelandehanterare — MessageHandler.

Standard MessageHandler som kommer att reagera på absolut alla inkommande meddelanden. Därför används meddelandehanterare ofta tillsammans med filter. Låt oss lära boten att hälsa inte bara på kommando /hi, utan alltid när meddelandet som skickas till boten innehåller ett av följande ord: hej, hälsar, salut, hej, bonjour.

Vi kommer inte att skriva några nya metoder just nu, eftersom vi redan har en metod som låter boten hälsa på oss. Det vi behöver göra är att skapa det nödvändiga filtret och meddelandehanteraren.

Kod 2: Lägg till en hanterare för textmeddelanden och filter

library(telegram.bot)

# Skapa en instans av klassen Updater
updater <- Updater('DIN BOTS TOKEN')

# Skriv en metod för att hälsa
## hälsningskommando
say_hello <- function(bot, update) {

  # Användarnamnet som boten ska hälsa på
  user_name <- update$message$from$first_name

  # Skicka ett välkomstmeddelande
  bot$sendMessage(update$message$chat_id, 
                  text = paste0("Mina hälsningar, ", user_name, "!"),
                  parse_mode = "Markdown",
                  reply_to_message_id = update$message$message_id)

}

# Skapa filter
MessageFilters$hi <- BaseFilter(function(message) {

  # Kontrollera om texten i meddelandet innehåller orden: hej, hälsar, salut, hej, bonjour
  grepl(x           = message$text, 
        pattern     = 'hej|hälsar|salut|hej|bonjour',
        ignore.case = TRUE)
  }
)

# Skapa hanterare
hi_hendler <- CommandHandler('hi', say_hello) # hanterare för kommandot hi
hi_txt_hnd <- MessageHandler(say_hello, filters = MessageFilters$hi)

# Lägg till hanterare i dispatchern
updater <- updater + 
             hi_hendler +
             hi_txt_hnd

# Starta boten
updater$start_polling()

Kör koden ovan efter att ha bytt ut ‘DINA BOT TOKEN’ mot den verkliga token som du fick när du skapade boten via BotFather (jag beskrev hur man skapar en bot i den första artikeln).

Nu ska vi försöka skicka boten flera meddelanden som innehåller de tidigare nämnda hälsningsorden:

Så, först och främst har vi lärt boten att inte bara hälsa, utan att svara på hälsningar. Vi gjorde detta med hjälp av argumentet reply_to_message_id, som är tillgängligt i metoden sendMessage(), där id:t på meddelandet som ska besvaras måste anges. Du kan få id:t på meddelandet så här: update$message$message_id.

Men det viktigaste vi har gjort är att vi har lagt till en filterfunktion till boten med hjälp av BaseFilter():

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

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

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

)

Som du kanske har lagt märke till, måste filter läggas till i objektet MessageFilters, som från början redan har en liten uppsättning färdiga filter. I vårt exempel i objektet MessageFilters har vi lagt till ett element hi, detta är en ny filter.

I funktionen BaseFilter() måste du skicka filterfunktionen. I grunden är ett filter bara en funktion som får ett meddelandeexemplar och returnerar SANN eller FALSK. I vårt exempel skrev vi en mycket enkel funktion som med hjälp av den grundläggande funktionen grepl() kontrollerar meddelandetexten, och om den matchar det reguljära uttrycket hej|hallå|tjena|hi|bonjour återvänder SANN.

Därefter skapar vi en meddelandehanterare hi_txt_hnd <- MessageHandler(say_hello, filters = MessageFilters$hi). Den första argumentet i funktionen MessageHandler() är metoden som kommer att anropa hanteraren, och det andra argumentet är filteret enligt vilket det kommer att anropas. I vårt fall är detta det filter vi har skapat MessageFilters$hi.

Och slutligen lägger vi till den skapade hanteraren i förvaltaren som just skapades hi_txt_hnd.

updater <- updater + 
             hi_hendler +
             hi_txt_hnd

Som jag nämnt tidigare finns det i paketet telegram.bot och objektet MessageFilters redan en uppsättning inbyggda filter som du kan använda:

• all — Alla meddelanden
• text — Textmeddelanden
• command — Kommandon, dvs. meddelanden som börjar med /
• reply — Meddelanden som är svar på ett annat meddelande
• audio — Meddelanden som innehåller en ljudfil
• document — Meddelanden med ett skickat dokument
• photo — Meddelanden med skickade bilder
• sticker — Meddelanden med ett skickat klistermärke
• video — Meddelanden med video
• voice — Röstmeddelanden
• contact — Meddelanden som innehåller kontaktinformation för en Telegram-användare
• location — Meddelanden med geolokalisering
• venue — Vidarebefordrade meddelanden
• game — Spel

Om du vill kombinera vissa filter i en hanterare, använd bara tecknet | — som en logisk ELLER, och tecknet & som en logisk Och. Till exempel, om du vill att botten ska anropa samma metod när den får video, bild eller dokument, använd följande exempel för att skapa en meddelandehanterare:

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

Lägg till kommandon med parametrar

Vi vet redan vad kommandon är, hur man skapar dem och hur man får botten att utföra det önskade kommandot. Men i vissa fall, förutom kommandots namn, behöver vi också skicka viss data för att det ska kunna utföras.

Nedan finns ett exempel på en bot som, baserat på ett angivet datum och land, returnerar typen av dag från produktionskalendern.

Den bot som beskrivs nedan använder API:et för produktionskalendern isdayoff.ru.

Kod 3: En bot som meddelar baserat på datum och land

library(telegram.bot)

# Skapar en instans av klassen Updater
updater <- Updater('1165649194:AAFkDqIzQ6Wq5GV0YU7PmEZcv1gmWIFIB_8')

# Skriver en metod för välkomnande
## Välkomstkommando
check_date <- function(bot, update, args) {

  # Ingående data
  day     <- args[1]  # datum
  country <- args[2]  # land

  # Kontroll av inmatade parametrar
  if ( !grepl('\d{4}-\d{2}-\d{2}', day) ) {

    # Skicka specialtangentbord
    bot$sendMessage(update$message$chat_id, 
                    text = paste0(day, " - ogiltigt datum, ange datum i formatet ÅÅÅÅ-MM-DD"),
                    parse_mode = "Markdown")

  } else {
    day <- as.Date(day)
    # Omvandla till format POSIXtl
    y <- format(day, "%Y")
    m <- format(day, "%m")
    d <- format(day, "%d")

  }

  # Land för kontroll
  ## Kolla om landet är angivet
  ## Om det inte är angivet sätts det till ru
  if ( ! country %in% c('ru', 'ua', 'by', 'kz', 'us') ) {

    # Skicka specialtangentbord
    bot$sendMessage(update$message$chat_id, 
                    text = paste0(country, " - ogiltig landkod, möjliga värden: ru, by, kz, ua, us. Efterfrågade data för Ryssland."),
                    parse_mode = "Markdown")

    country <- 'ru'

  }

  # Begär data från API
  # Montering av HTTP-förfrågan
  url <- paste0("https://isdayoff.ru/api/getdata?",
                "year=",  y, "&",
                "month=", m, "&",
                "day=",   d, "&",
                "cc=",    country, "&",
                "pre=1&",
                "covid=1")

  # Får svar
  res <- readLines(url)

  # Tolkning av svar
  out <- switch(res, 
                "0"   = "Arbetsdag",
                "1"   = "Icke-arbetsdag",
                "2"   = "Förkortad arbetsdag",
                "4"   = "covid-19",
                "100" = "Fel i datumet",
                "101" = "Data hittades inte",
                "199" = "Tjänstefel")

  # Skicka meddelande
  bot$sendMessage(update$message$chat_id, 
                  text = paste0(day, " - ", out),
                  parse_mode = "Markdown")

}

# Skapa en hanterare
date_hendler <- CommandHandler('check_date', check_date, pass_args = TRUE)

# Lägger till hanteraren i dispatcher
updater <- updater + date_hendler

# Startar botten
updater$start_polling()

Kör koden ovan efter att ha bytt ut ‘DINA BOT TOKEN’ mot den verkliga token som du fick när du skapade boten via BotFather (jag beskrev hur man skapar en bot i den första artikeln).

Vi har skapat en bot som har en enda metod i sin arsenal check_date, denna metod anropas av kommandot med samma namn.

Men, förutom kommandots namn, förväntar sig denna metod att du anger två parametrar, landkod och datum. Därefter kontrollerar boten om den angivna dagen i det angivna landet är en helgdag, kort dag eller arbetsdag enligt den officiella produktionskalendern.

För att den metod vi skapar ska ta emot ytterligare parametrar tillsammans med kommandot, använd argumentet pass_args = TRUE i funktionen CommandHandler(), och när du skapar metoden, förutom de obligatoriska argumenten, bot, update skapa en valfri— args. Den metod som skapats på detta sätt kommer att ta emot parametrar som du skickar till boten efter kommandots namn. Parametrarna måste separeras med ett mellanslag, och de kommer att tas emot i form av en textvektor.

Låt oss starta och testa vår bot.

Kör boten i bakgrunden

Det sista steget vi har kvar att utföra är att köra boten i bakgrunden.

För att göra detta, följ den nedan beskrivna algoritmen:

1. Spara botens kod i en fil med R-tillägget. När du arbetar i RStudio görs detta via menyn Arkiv, med kommandot Spara som….
2. Lägg till sökvägen till bin-mappen, som i sin tur ligger i mappen där du installerade R-språket i variabeln Path, instruktion ). Ett typiskt exempel på användning:.
3. Skapa en vanlig textfil där du skriver en rad: R CMD BATCH C:UsersAlseyDocumentsmy_bot.R. Istället för C:UsersAlseyDocumentsmy_bot.R skriv sökvägen till ditt bot-script. Det är viktigt att ingen kyrilliska eller mellanslag förekommer i sökvägen, eftersom detta kan orsaka problem vid körning av boten. Spara det, och ändra dess tillägg från txt till bat.
4. Öppna Windows aktivitetsplanerare, det finns många sätt att göra detta, till exempel kan du öppna vilken mapp som helst och skriva in adressen %windir%system32taskschd.msc \/s. Andra sätt att starta kan hittas ). Ett typiskt exempel på användning:.
5. I det övre högra menyn i aktivitetsplaneraren, klicka på "Skapa uppgift…".
6. I fliken "Allmänt", ange ett valfritt namn för din uppgift, och sätt omkopplaren till "Kör för alla användare".
7. Gå till fliken "Åtgärder", klicka på "Skapa". I fältet "Program eller skript", klicka på "Bläddra", hitta filen skapad i steg två bat och klicka OK.
8. Klicka OK, ange vid behov lösenordet för ditt operativsystemskonto.
9. Hitta den skapade uppgiften i aktivitetsplaneraren, markera den och klicka på knappen "Kör" i det nedre högra hörnet.

Vår bot körs i bakgrunden och kommer att fungera tills du stoppar uppgiften eller stänger av din PC eller server där den körs.

Slutsats

I den här artikeln har vi gått igenom hur man skriver en komplett bot som inte bara kan skicka meddelanden utan också reagera på inkommande meddelanden och kommandon. Kunskapen du har fått är tillräcklig för att lösa de flesta av dina uppgifter.

I nästa artikel kommer vi att diskutera hur man lägger till ett tangentbord till boten för en mer användarvänlig upplevelse.

Prenumerera på min telegram och YouTube kanaler.

Källa: habr.com