თუ უკვე წაიკითხე წინა სამი სტატია ამ სერიიდან, თქვენ უკვე იცით, როგორ დაწეროთ სრულფასოვანი ტელეგრამის ბოტები კლავიატურით.

ამ სტატიაში ჩვენ ვისწავლით როგორ დავწეროთ ბოტი, რომელიც შეინარჩუნებს თანმიმდევრულ დიალოგს. იმათ. ბოტი დაგისვამთ კითხვებს და დაელოდებათ რაიმე ინფორმაციის შეყვანას. თქვენს მიერ შეყვანილი მონაცემებიდან გამომდინარე, ბოტი შეასრულებს რამდენიმე მოქმედებას.

ასევე ამ სტატიაში ჩვენ ვისწავლით თუ როგორ გამოვიყენოთ მონაცემთა ბაზა ბოტის ქუდის ქვეშ, ჩვენს მაგალითში ეს იქნება SQLite, მაგრამ შეგიძლიათ გამოიყენოთ ნებისმიერი სხვა DBMS. მე უფრო დეტალურად დავწერე მონაცემთა ბაზებთან ურთიერთქმედების შესახებ R ენაზე ეს მუხლი.

ყველა სტატია სერიიდან "ტელეგრამის ბოტის დაწერა R-ში"

1. ჩვენ ვქმნით ბოტს და ვიყენებთ მას ტელეგრამაში შეტყობინებების გასაგზავნად
2. დაამატეთ ბრძანების მხარდაჭერა და შეტყობინებების ფილტრები ბოტში
3. როგორ დავამატოთ კლავიატურის მხარდაჭერა ბოტს
4. თანმიმდევრული, ლოგიკური დიალოგის აგება ბოტთან

ინფორმაციის

თუ გაინტერესებთ მონაცემთა ანალიზი, შეიძლება დაგაინტერესოთ ჩემი დეპეშა и youtube არხები. შინაარსის უმეტესი ნაწილი ეძღვნება R ენას.

1. შესავალი
2. ბოტის აგების პროცესი
3. ბოტის პროექტის სტრუქტურა
4. ბოტის კონფიგურაცია
5. შექმენით გარემოს ცვლადი
6. მონაცემთა ბაზის შექმნა
7. ფუნქციების ჩაწერა მონაცემთა ბაზასთან მუშაობისთვის
8. ბოტის მეთოდები
9. შეტყობინებების ფილტრები
10. დამმუშავებლები
11. ბოტის გაშვების კოდი
12. დასკვნა

შესავალი

იმისთვის, რომ ბოტმა მოითხოვოს თქვენგან მონაცემები და დაელოდოთ რაიმე ინფორმაციის შეყვანას, თქვენ დაგჭირდებათ დიალოგის მიმდინარე მდგომარეობის ჩაწერა. ამის გაკეთების საუკეთესო გზა არის რაიმე სახის ჩაშენებული მონაცემთა ბაზის გამოყენება, როგორიცაა SQLite.

იმათ. ლოგიკა ასეთი იქნება. ჩვენ მოვუწოდებთ ბოტის მეთოდს და ბოტი თანმიმდევრულად ითხოვს ჩვენგან გარკვეულ ინფორმაციას და ყოველ ნაბიჯზე ელოდება ამ ინფორმაციის შეყვანას და შეუძლია შეამოწმოს იგი.

ჩვენ დავწერთ უმარტივეს ბოტს, ჯერ ის მოგთხოვს სახელს, შემდეგ ასაკს და მიღებულ მონაცემებს მონაცემთა ბაზაში შეინახავს. ასაკის მოთხოვნისას ამოწმებს, რომ შეყვანილი მონაცემები არის რიცხვი და არა ტექსტი.

ასეთ მარტივ დიალოგს მხოლოდ სამი მდგომარეობა ექნება:

1. დაწყება არის ბოტის ნორმალური მდგომარეობა, რომელშიც ის არ ელის თქვენგან ინფორმაციას
2. Wait_name - მდგომარეობა, რომელშიც ბოტი ელოდება სახელის შეყვანას
3. Wait_age არის მდგომარეობა, რომელშიც ბოტი ელოდება თქვენი ასაკის შეყვანას, სრული წლების რაოდენობას.

ბოტის აგების პროცესი

სტატიის განმავლობაში ჩვენ ავაშენებთ ბოტს ეტაპობრივად; მთელი პროცესი შეიძლება სქემატურად იყოს გამოსახული შემდეგნაირად:

1. ჩვენ ვქმნით ბოტის კონფიგურაციას, რომელშიც შევინახავთ რამდენიმე პარამეტრს. ჩვენს შემთხვევაში, ბოტის ნიშანი და გზა მონაცემთა ბაზის ფაილისკენ.
2. ჩვენ ვქმნით გარემოს ცვლადს, რომელშიც შეინახება ბოტით პროექტის გზა.
3. ჩვენ ვქმნით თავად მონაცემთა ბაზას და რიგ ფუნქციებს, რათა ბოტმა შეძლოს მასთან ურთიერთობა.
4. ვწერთ ბოტის მეთოდებს, ე.ი. ფუნქციებს, რომელსაც ის შეასრულებს.
5. შეტყობინებების ფილტრების დამატება. რომლის დახმარებით ბოტი მიიღებს წვდომას აუცილებელ მეთოდებზე, რაც დამოკიდებულია ჩატის ამჟამინდელ მდგომარეობაზე.
6. ჩვენ ვამატებთ დამმუშავებლებს, რომლებიც დააკავშირებენ ბრძანებებს და შეტყობინებებს ბოტის საჭირო მეთოდებით.
7. მოდით გავუშვათ ბოტი.

ბოტის პროექტის სტრუქტურა

მოხერხებულობისთვის, ჩვენ დავყოფთ ჩვენი ბოტის კოდს და სხვა დაკავშირებულ ფაილებს შემდეგ სტრუქტურად.

• ბოტი.რ — ჩვენი ბოტის მთავარი კოდი
• db_bot_function.R — კოდის ბლოკი მონაცემთა ბაზასთან მუშაობის ფუნქციებით
• bot_methods.R - ბოტის მეთოდების კოდი
• შეტყობინების_ფილტრები.R - შეტყობინებების ფილტრები
• დამმუშავებლები.რ - დამმუშავებლები
• კონფიგურაცია. cfg - ბოტის კონფიგურაცია
• create_db_data.sql — SQL სკრიპტი მონაცემთა ბაზაში ჩატის მონაცემებით ცხრილის შესაქმნელად
• create_db_state.sql — SQL სკრიპტი მონაცემთა ბაზაში მიმდინარე ჩატის მდგომარეობის ცხრილის შესაქმნელად
• bot.db - ბოტების მონაცემთა ბაზა

შეგიძლიათ ნახოთ მთელი ბოტის პროექტი, ან ჩამოტვირთვა ჩემიდან საცავი GitHub-ზე.

ბოტის კონფიგურაცია

ჩვენ გამოვიყენებთ ჩვეულებრივს, როგორც კონფიგურაციას ini ფაილი, შემდეგი ფორმა:

[bot_settings]
bot_token=ТОКЕН_ВАШЕГО_БОТА

[db_settings]
db_path=C:/ПУТЬ/К/ПАПКЕ/ПРОЕКТА/bot.db

კონფიგურაციაში ვწერთ ბოტის ჟეტონს და გზას მონაცემთა ბაზისკენ, ე.ი. bot.db ფაილზე; ჩვენ შევქმნით თავად ფაილს შემდეგ ეტაპზე.

უფრო რთული ბოტებისთვის შეგიძლიათ შექმნათ უფრო რთული კონფიგურაციები, გარდა ამისა, არ არის აუცილებელი ini კონფიგურაციის დაწერა, შეგიძლიათ გამოიყენოთ ნებისმიერი სხვა ფორმატი JSON-ის ჩათვლით.

შექმენით გარემოს ცვლადი

თითოეულ კომპიუტერზე ბოტის პროექტის მქონე საქაღალდე შეიძლება განთავსდეს სხვადასხვა დირექტორიაში და სხვადასხვა დისკზე, ასე რომ კოდში პროექტის საქაღალდისკენ მიმავალი გზა დაყენდება გარემოს ცვლადის მეშვეობით. TG_BOT_PATH.

გარემოს ცვლადის შესაქმნელად რამდენიმე გზა არსებობს, უმარტივესი არის მისი ფაილში ჩაწერა .რენვირონი.

თქვენ შეგიძლიათ შექმნათ ან შეცვალოთ ეს ფაილი ბრძანების გამოყენებით file.edit(path.expand(file.path("~", ".Renviron"))). შეასრულეთ იგი და დაამატეთ ერთი ხაზი ფაილს:

TG_BOT_PATH=C:/ПУТЬ/К/ВАШЕМУ/ПРОЕКТУ

შემდეგ შეინახეთ ფაილი .რენვირონი და გადატვირთეთ RStudio.

მონაცემთა ბაზის შექმნა

შემდეგი ნაბიჯი არის მონაცემთა ბაზის შექმნა. დაგვჭირდება 2 მაგიდა:

• chat_data — მონაცემები, რომელიც ბოტმა მოითხოვა მომხმარებლისგან
• chat_state — ყველა ჩატის მიმდინარე მდგომარეობა

თქვენ შეგიძლიათ შექმნათ ეს ცხრილები შემდეგი SQL მოთხოვნის გამოყენებით:

CREATE TABLE chat_data (
    chat_id BIGINT  PRIMARY KEY
                    UNIQUE,
    name    TEXT,
    age     INTEGER
);

CREATE TABLE chat_state (
    chat_id BIGINT PRIMARY KEY
                   UNIQUE,
    state   TEXT
);

თუ ჩამოტვირთეთ ბოტის პროექტი GitHub, შემდეგ მონაცემთა ბაზის შესაქმნელად შეგიძლიათ გამოიყენოთ შემდეგი კოდი R-ში.

# Скрипт создания базы данных
library(DBI)     # интерфейс для работы с СУБД
library(configr) # чтение конфига
library(readr)   # чтение текстовых SQL файлов
library(RSQLite) # драйвер для подключения к SQLite

# директория проекта
setwd(Sys.getenv('TG_BOT_PATH'))

# чтение конфига
cfg <- read.config('config.cfg')

# подключение к SQLite
con <- dbConnect(SQLite(), cfg$db_settings$db_path)

# Создание таблиц в базе
dbExecute(con, statement = read_file('create_db_data.sql'))
dbExecute(con, statement = read_file('create_db_state.sql'))

ფუნქციების ჩაწერა მონაცემთა ბაზასთან მუშაობისთვის

ჩვენ უკვე გვაქვს მზად კონფიგურაციის ფაილი და შექმნილია მონაცემთა ბაზა. ახლა თქვენ უნდა დაწეროთ ფუნქციები, რომ წაიკითხოთ და ჩაწეროთ მონაცემები ამ მონაცემთა ბაზაში.

თუ თქვენ გადმოწერეთ პროექტი საიდან GitHub, შემდეგ შეგიძლიათ იპოვოთ ფუნქციები ფაილში db_bot_function.R.

მონაცემთა ბაზასთან მუშაობის ფუნქციის კოდი

# ###########################################################
# Function for work bot with database

# получить текущее состояние чата
get_state <- function(chat_id) {

  con <- dbConnect(SQLite(), cfg$db_settings$db_path)

  chat_state <- dbGetQuery(con, str_interp("SELECT state FROM chat_state WHERE chat_id == ${chat_id}"))$state

  return(unlist(chat_state))

  dbDisconnect(con)
}

# установить текущее состояние чата
set_state <- function(chat_id, state) {

  con <- dbConnect(SQLite(), cfg$db_settings$db_path)

  # upsert состояние чата
  dbExecute(con, 
            str_interp("
            INSERT INTO chat_state (chat_id, state)
                VALUES(${chat_id}, '${state}') 
                ON CONFLICT(chat_id) 
                DO UPDATE SET state='${state}';
            ")
  )

  dbDisconnect(con)

}

# запись полученных данных в базу
set_chat_data <- function(chat_id, field, value) {

  con <- dbConnect(SQLite(), cfg$db_settings$db_path)

  # upsert состояние чата
  dbExecute(con, 
            str_interp("
            INSERT INTO chat_data (chat_id, ${field})
                VALUES(${chat_id}, '${value}') 
                ON CONFLICT(chat_id) 
                DO UPDATE SET ${field}='${value}';
            ")
  )

  dbDisconnect(con)

}

# read chat data
get_chat_data <- function(chat_id, field) {

  con <- dbConnect(SQLite(), cfg$db_settings$db_path)

  # upsert состояние чата
  data <- dbGetQuery(con, 
                     str_interp("
            SELECT ${field}
            FROM chat_data
            WHERE chat_id = ${chat_id};
            ")
  )

  dbDisconnect(con)

  return(data[[field]])

}

ჩვენ შევქმენით 4 მარტივი ფუნქცია:

• get_state() - მიიღეთ მიმდინარე ჩატის მდგომარეობა მონაცემთა ბაზიდან
• set_state() — ჩაწერეთ მიმდინარე ჩატის მდგომარეობა მონაცემთა ბაზაში
• get_chat_data() — მიიღეთ მომხმარებლის მიერ გაგზავნილი მონაცემები
• set_chat_data() — ჩაწერეთ მომხმარებლისგან მიღებული მონაცემები

ყველა ფუნქცია საკმაოდ მარტივია, ისინი ან კითხულობენ მონაცემებს მონაცემთა ბაზიდან ბრძანების გამოყენებით dbGetQuery(), ან ჩაიდინოს UPSERT ოპერაცია (არსებული მონაცემების შეცვლა ან მონაცემთა ბაზაში ახალი მონაცემების ჩაწერა), ფუნქციის გამოყენებით dbExecute().

UPSERT ოპერაციის სინტაქსი ასეთია:

INSERT INTO chat_data (chat_id, ${field})
VALUES(${chat_id}, '${value}') 
ON CONFLICT(chat_id) 
DO UPDATE SET ${field}='${value}';

იმათ. ჩვენი ცხრილების ველში chat_id აქვს უნიკალურობის შეზღუდვა და არის ცხრილების ძირითადი გასაღები. თავდაპირველად, ჩვენ ვცდილობთ დავამატოთ ინფორმაცია ცხრილში და ვიღებთ შეცდომას, თუ უკვე არსებობს მონაცემები მიმდინარე ჩატის შესახებ, ამ შემთხვევაში ჩვენ უბრალოდ ვაახლებთ ინფორმაციას ამ ჩატის შესახებ.

შემდეგი, ჩვენ გამოვიყენებთ ამ ფუნქციებს ბოტის მეთოდებსა და ფილტრებში.

ბოტის მეთოდები

ჩვენი ბოტის შექმნის შემდეგი ნაბიჯი არის მეთოდების შექმნა. თუ თქვენ გადმოწერეთ პროექტი საიდან GitHub, მაშინ ყველა მეთოდი ფაილშია bot_methods.R.

ბოტის მეთოდის კოდი

# ###########################################################
# bot methods

# start dialog
start <- function(bot, update) {

  # 

  # Send query
  bot$sendMessage(update$message$chat_id, 
                  text = "Введи своё имя")

  # переключаем состояние диалога в режим ожидания ввода имени
  set_state(chat_id = update$message$chat_id, state = 'wait_name')

}

# get current chat state
state <- function(bot, update) {

  chat_state <- get_state(update$message$chat_id)

  # Send state
  bot$sendMessage(update$message$chat_id, 
                  text = unlist(chat_state))

}

# reset dialog state
reset <- function(bot, update) {

  set_state(chat_id = update$message$chat_id, state = 'start')

}

# enter username
enter_name <- function(bot, update) {

  uname <- update$message$text

  # Send message with name
  bot$sendMessage(update$message$chat_id, 
                  text = paste0(uname, ", приятно познакомится, я бот!"))

  # Записываем имя в глобальную переменную
  #username <<- uname
  set_chat_data(update$message$chat_id, 'name', uname) 

  # Справшиваем возраст
  bot$sendMessage(update$message$chat_id, 
                  text = "Сколько тебе лет?")

  # Меняем состояние на ожидание ввода имени
  set_state(chat_id = update$message$chat_id, state = 'wait_age')

}

# enter user age
enter_age <- function(bot, update) {

  uage <- as.numeric(update$message$text)

  # проверяем было введено число или нет
  if ( is.na(uage) ) {

    # если введено не число то переспрашиваем возраст
    bot$sendMessage(update$message$chat_id, 
                    text = "Ты ввёл некорректные данные, введи число")

  } else {

    # если введено число сообщаем что возраст принят
    bot$sendMessage(update$message$chat_id, 
                    text = "ОК, возраст принят")

    # записываем глобальную переменную с возрастом
    #userage <<- uage
    set_chat_data(update$message$chat_id, 'age', uage) 

    # сообщаем какие данные были собраны
    username <- get_chat_data(update$message$chat_id, 'name')
    userage  <- get_chat_data(update$message$chat_id, 'age')

    bot$sendMessage(update$message$chat_id, 
                    text = paste0("Тебя зовут ", username, " и тебе ", userage, " лет. Будем знакомы"))

    # возвращаем диалог в исходное состояние
    set_state(chat_id = update$message$chat_id, state = 'start')
  }

}

ჩვენ შევქმენით 5 მეთოდი:

• დაწყება - დიალოგის დაწყება
• სახელმწიფო — მიიღეთ მიმდინარე ჩატის მდგომარეობა
• გადატვირთვა — განაახლეთ ჩატის მიმდინარე მდგომარეობა
• enter_name — ბოტი ითხოვს თქვენს სახელს
• enter_age — ბოტი ითხოვს თქვენს ასაკს

მეთოდი start ითხოვს თქვენს სახელს და ცვლის ჩატის მდგომარეობას Wait_name, ე.ი. ლოდინის რეჟიმში თქვენი სახელის შეყვანისთვის.

შემდეგი, თქვენ აგზავნით სახელს და ის მუშავდება მეთოდით enter_name, ბოტი გილოცავს, წერს მიღებულ სახელს მონაცემთა ბაზაში და ცვლის ჩატს მდგომარეობაზე ლოდინის_ასაკი.

ამ ეტაპზე ბოტი ელის, რომ შეიყვანოთ თქვენი ასაკი. თქვენ აგზავნით თქვენს ასაკს, ბოტი ამოწმებს შეტყობინებას, თუ ნომრის ნაცვლად გაგზავნეთ ტექსტი, ის იტყვის: Ты ввёл некорректные данные, введи числоდა დაელოდება თქვენ ხელახლა შეიყვანოთ თქვენი მონაცემები. თუ ნომერი გამოგიგზავნეთ, ბოტი შეგატყობინებთ, რომ მან მიიღო თქვენი ასაკი, ჩაწერს მიღებულ მონაცემებს მონაცემთა ბაზაში, მოახსენებს თქვენგან მიღებული ყველა მონაცემს და დააბრუნებს ჩატის მდგომარეობას თავდაპირველ პოზიციაზე, ე.ი. ვ start.

მეთოდის გამოძახებით state შეგიძლიათ მოითხოვოთ მიმდინარე ჩატის სტატუსი ნებისმიერ დროს და გამოიყენოთ reset დააბრუნეთ ჩატი თავდაპირველ მდგომარეობაში.

შეტყობინებების ფილტრები

ჩვენს შემთხვევაში, ეს არის ერთ-ერთი ყველაზე მნიშვნელოვანი ნაწილი ბოტის მშენებლობაში. სწორედ შეტყობინებების ფილტრების დახმარებით გაიგებს ბოტი რა ინფორმაციას ელის თქვენგან და როგორ უნდა დამუშავდეს.

პროექტში GitHub ფილტრები რეგისტრირებულია ფაილში შეტყობინების_ფილტრები.R.

შეტყობინების ფილტრის კოდი:

# ###########################################################
# message state filters

# фильтр сообщений в состоянии ожидания имени
MessageFilters$wait_name <- BaseFilter(function(message) {
  get_state( message$chat_id )  == "wait_name"
}
)

# фильтр сообщений в состоянии ожидания возраста
MessageFilters$wait_age <- BaseFilter(function(message) {
  get_state( message$chat_id )   == "wait_age"
}
)

ფილტრებში ვიყენებთ ადრე დაწერილ ფუნქციას get_state(), იმისათვის, რომ მოითხოვოთ ჩატის მიმდინარე მდგომარეობა. ეს ფუნქცია მოითხოვს მხოლოდ 1 არგუმენტს, ჩატის ID-ს.

შემდეგი ფილტრი Wait_name ამუშავებს შეტყობინებებს, როდესაც ჩატი მდგომარეობაშია wait_name, და შესაბამისად ფილტრიც ლოდინის_ასაკი ამუშავებს შეტყობინებებს, როდესაც ჩატი მდგომარეობაშია wait_age.

დამმუშავებლები

ფაილი დამმუშავებლებით არის გამოძახებული დამმუშავებლები.რდა აქვს შემდეგი კოდი:

# ###########################################################
# handlers

# command handlers
start_h <- CommandHandler('start', start)
state_h <- CommandHandler('state', state)
reset_h <- CommandHandler('reset', reset)

# message handlers
## !MessageFilters$command - означает что команды данные обработчики не обрабатывают, 
## только текстовые сообщения
wait_age_h  <- MessageHandler(enter_age,  MessageFilters$wait_age  & !MessageFilters$command)
wait_name_h <- MessageHandler(enter_name, MessageFilters$wait_name & !MessageFilters$command)

პირველ რიგში ჩვენ ვქმნით ბრძანებების დამმუშავებლებს, რომლებიც საშუალებას მოგცემთ გაუშვათ მეთოდები დიალოგის დასაწყებად, გადატვირთოთ და მოითხოვოთ მიმდინარე მდგომარეობა.

შემდეგი, ჩვენ ვქმნით 2 შეტყობინებების დამმუშავებელს წინა ეტაპზე შექმნილი ფილტრების გამოყენებით და ვამატებთ მათ ფილტრს !MessageFilters$command, ასე რომ ჩვენ შეგვიძლია გამოვიყენოთ ბრძანებები ჩეთის ნებისმიერ მდგომარეობაში.

ბოტის გაშვების კოდი

ახლა ჩვენ ყველაფერი მზად გვაქვს გასაშვებად, ბოტის გაშვების მთავარი კოდი ფაილშია ბოტი.რ.

library(telegram.bot)
library(tidyverse)
library(RSQLite)
library(DBI)
library(configr)

# переходим в папку проекта
setwd(Sys.getenv('TG_BOT_PATH'))

# читаем конфиг
cfg <- read.config('config.cfg')

# создаём экземпляр бота
updater <- Updater(cfg$bot_settings$bot_token)

# Загрузка компонентов бота
source('db_bot_function.R') # функции для работы с БД
source('bot_methods.R')     # методы бота
source('message_filters.R') # фильтры сообщений
source('handlers.R') # обработчики сообщений

# Добавляем обработчики в диспетчер
updater <- updater +
  start_h +
  wait_age_h +
  wait_name_h +
  state_h +
  reset_h

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

შედეგად მივიღეთ ეს ბოტი:

ნებისმიერ დროს ბრძანების გამოყენებით /state ჩვენ შეგვიძლია გამოვიკითხოთ ჩატის მიმდინარე მდგომარეობა და ბრძანების გამოყენებით /reset დააბრუნეთ ჩატი თავდაპირველ მდგომარეობაში და კვლავ დაიწყეთ დიალოგი.

დასკვნა

ამ სტატიაში ჩვენ გავარკვიეთ, თუ როგორ გამოვიყენოთ მონაცემთა ბაზა ბოტის შიგნით და როგორ ავაშენოთ თანმიმდევრული ლოგიკური დიალოგები ჩატის მდგომარეობის ჩაწერით.

ამ შემთხვევაში ჩვენ გადავხედეთ ყველაზე პრიმიტიულ მაგალითს, რათა გაგიადვილდეთ ამგვარი ბოტების შექმნის იდეის გაგება; პრაქტიკაში, თქვენ შეგიძლიათ ააწყოთ ბევრად უფრო რთული დიალოგები.

ამ სერიის მომდევნო სტატიაში ჩვენ ვისწავლით, თუ როგორ შევზღუდოთ ბოტის მომხმარებლების უფლებები მისი სხვადასხვა მეთოდების გამოყენების შესახებ.

წყარო: www.habr.com