ប្រសិនបើអ្នកបានអានរួចហើយ អត្ថបទបី ពីស៊េរីនេះ បន្ទាប់មកអ្នកដឹងពីរបៀបសរសេរ bots តេឡេក្រាមពេញលេញជាមួយនឹងក្តារចុច។

នៅក្នុងអត្ថបទនេះ យើងនឹងរៀនពីរបៀបសរសេរ bot ដែលនឹងរក្សាការសន្ទនាជាប់លាប់។ ទាំងនោះ។ bot នឹងសួរអ្នកនូវសំណួរ ហើយរង់ចាំអ្នកបញ្ចូលព័ត៌មានមួយចំនួន។ អាស្រ័យលើទិន្នន័យដែលអ្នកបញ្ចូល bot នឹងអនុវត្តសកម្មភាពមួយចំនួន។

ផងដែរនៅក្នុងអត្ថបទនេះយើងនឹងរៀនពីរបៀបប្រើមូលដ្ឋានទិន្នន័យនៅក្រោមក្រណាត់នៃ bot ក្នុងឧទាហរណ៍របស់យើងវានឹងជា SQLite ប៉ុន្តែអ្នកអាចប្រើ DBMS ផ្សេងទៀត។ ខ្ញុំបានសរសេរលម្អិតបន្ថែមទៀតអំពីអន្តរកម្មជាមួយមូលដ្ឋានទិន្នន័យនៅក្នុងភាសា R នៅក្នុង អត្ថបទនេះ.

អត្ថបទទាំងអស់ពីស៊េរី "ការសរសេរសារទូរលេខជាអក្សរ R"

1. យើងបង្កើត bot ហើយប្រើវាដើម្បីផ្ញើសារក្នុងទូរលេខ
2. បន្ថែមការគាំទ្រពាក្យបញ្ជា និងតម្រងសារទៅ bot
3. របៀបបន្ថែមការគាំទ្រក្តារចុចទៅបូត
4. ការកសាងការសន្ទនាសមហេតុផល និងសមហេតុផលជាមួយបូត

មាតិកា

ប្រសិនបើអ្នកចាប់អារម្មណ៍លើការវិភាគទិន្នន័យ អ្នកប្រហែលជាចាប់អារម្មណ៍លើរបស់ខ្ញុំ ទូរលេខ и YouTube ឆានែល។ មាតិកាភាគច្រើនត្រូវបានឧទ្ទិសដល់ភាសា R ។

1. សេចក្តីណែនាំ
2. ដំណើរការសាងសង់បូត
3. រចនាសម្ព័ន្ធគម្រោង
4. កំណត់រចនាសម្ព័ន្ធបូត
5. បង្កើតអថេរបរិស្ថាន
6. ការបង្កើតមូលដ្ឋានទិន្នន័យ
7. មុខងារសរសេរដើម្បីធ្វើការជាមួយមូលដ្ឋានទិន្នន័យ
8. វិធីសាស្រ្តបូត
9. តម្រងសារ
10. អ្នកដោះស្រាយ
11. កូដបើកដំណើរការបូត
12. សេចក្តីសន្និដ្ឋាន

សេចក្តីណែនាំ

ដើម្បីឱ្យ bot ស្នើសុំទិន្នន័យពីអ្នក ហើយរង់ចាំអ្នកបញ្ចូលព័ត៌មានណាមួយ អ្នកនឹងត្រូវកត់ត្រាស្ថានភាពបច្ចុប្បន្ននៃការសន្ទនា។ មធ្យោបាយដ៏ល្អបំផុតដើម្បីធ្វើវាគឺត្រូវប្រើប្រភេទនៃមូលដ្ឋានទិន្នន័យដែលបានបង្កប់ដូចជា SQLite ។

ទាំងនោះ។ តក្កវិជ្ជានឹងមានដូចខាងក្រោម។ យើងហៅវិធីសាស្ត្រ bot ហើយ bot ស្នើសុំព័ត៌មានមួយចំនួនពីយើងជាបន្តបន្ទាប់ ហើយនៅជំហាននីមួយៗ វារង់ចាំព័ត៌មាននេះបញ្ចូល ហើយអាចពិនិត្យមើលវាបាន។

យើងនឹងសរសេរ bot ដ៏សាមញ្ញបំផុតដែលអាចធ្វើទៅបាន ដំបូងវានឹងសួររកឈ្មោះរបស់អ្នក បន្ទាប់មកអាយុរបស់អ្នក ហើយនឹងរក្សាទុកទិន្នន័យដែលទទួលបានទៅក្នុងមូលដ្ឋានទិន្នន័យ។ នៅពេលសួររកអាយុ វានឹងពិនិត្យមើលថាទិន្នន័យដែលបានបញ្ចូលគឺជាលេខ មិនមែនអត្ថបទទេ។

ការសន្ទនាដ៏សាមញ្ញបែបនេះ នឹងមានរដ្ឋតែបីប៉ុណ្ណោះ៖

1. ការចាប់ផ្តើមគឺជាស្ថានភាពធម្មតារបស់ bot ដែលក្នុងនោះវាមិនរំពឹងថានឹងមានព័ត៌មានណាមួយពីអ្នកទេ។
2. wait_name - ស្ថានភាពដែល bot រង់ចាំឈ្មោះដែលត្រូវបញ្ចូល
3. wait_age គឺជាស្ថានភាពដែល bot រង់ចាំអាយុរបស់អ្នកត្រូវបានបញ្ចូល ចំនួនឆ្នាំពេញ។

ដំណើរការសាងសង់បូត

ក្នុងអំឡុងពេលអត្ថបទ យើងនឹងបង្កើត bot មួយជំហានម្តងមួយៗ ដំណើរការទាំងមូលអាចត្រូវបានពិពណ៌នាតាមគ្រោងការណ៍ដូចខាងក្រោម:

1. យើងបង្កើត bot config ដែលយើងនឹងរក្សាទុកការកំណត់មួយចំនួន។ ក្នុងករណីរបស់យើង bot token និងផ្លូវទៅកាន់ឯកសារ database។
2. យើងបង្កើតអថេរបរិស្ថានដែលផ្លូវទៅកាន់គម្រោងជាមួយ bot នឹងត្រូវបានរក្សាទុក។
3. យើងបង្កើតមូលដ្ឋានទិន្នន័យដោយខ្លួនឯង និងមុខងារមួយចំនួនដើម្បីឱ្យ bot អាចធ្វើអន្តរកម្មជាមួយវាបាន។
4. យើងសរសេរ bot method, i.e. មុខងារដែលវានឹងអនុវត្ត។
5. ការបន្ថែមតម្រងសារ។ ដោយមានជំនួយដែល bot នឹងចូលប្រើវិធីសាស្ត្រចាំបាច់ អាស្រ័យលើស្ថានភាពបច្ចុប្បន្ននៃការជជែក។
6. យើងបន្ថែមឧបករណ៍ដោះស្រាយដែលនឹងភ្ជាប់ពាក្យបញ្ជា និងសារជាមួយនឹងវិធីសាស្ត្រ bot ចាំបាច់។
7. តោះបើកដំណើរការ bot ។

រចនាសម្ព័ន្ធគម្រោង

ដើម្បីភាពងាយស្រួល យើងនឹងបែងចែកកូដនៃ bot របស់យើង និងឯកសារពាក់ព័ន្ធផ្សេងទៀតទៅជារចនាសម្ព័ន្ធដូចខាងក្រោម។

• bot.R - លេខកូដសំខាន់នៃ bot របស់យើង។
• db_bot_function.R - ប្លុកនៃកូដដែលមានមុខងារសម្រាប់ធ្វើការជាមួយមូលដ្ឋានទិន្នន័យ
• bot_methods.R - កូដនៃវិធីសាស្ត្រ bot
• message_filters.R - តម្រងសារ
• អ្នកដោះស្រាយ.R - អ្នកដោះស្រាយ
• config.cfg - ការកំណត់រចនាសម្ព័ន្ធ bot
• create_db_data.sql - ស្គ្រីប SQL សម្រាប់បង្កើតតារាងដែលមានទិន្នន័យជជែកក្នុងមូលដ្ឋានទិន្នន័យ
• create_db_state.sql - ស្គ្រីប SQL សម្រាប់បង្កើតតារាងនៃស្ថានភាពជជែកបច្ចុប្បន្ននៅក្នុងមូលដ្ឋានទិន្នន័យ
• bot.db - មូលដ្ឋានទិន្នន័យ bot

អ្នកអាចមើលគម្រោង bot ទាំងមូល ឬ ទាញយក ពីរបស់ខ្ញុំ ឃ្លាំងនៅលើ GitHub.

កំណត់រចនាសម្ព័ន្ធបូត

យើងនឹងប្រើធម្មតាជាការកំណត់ ឯកសារ ini, ទម្រង់ខាងក្រោម៖

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

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

នៅក្នុង config យើងសរសេរ bot token និងផ្លូវទៅកាន់ database i.e. ទៅឯកសារ bot.db យើងនឹងបង្កើតឯកសារដោយខ្លួនឯងនៅជំហានបន្ទាប់។

សម្រាប់ bots ស្មុគ្រស្មាញកាន់តែច្រើន អ្នកអាចបង្កើត configs ស្មុគ្រស្មាញបន្ថែមទៀត ក្រៅពីនេះវាមិនចាំបាច់ក្នុងការសរសេរ ini config ទេ អ្នកអាចប្រើទម្រង់ផ្សេងទៀតរួមទាំង JSON ផងដែរ។

បង្កើតអថេរបរិស្ថាន

នៅលើកុំព្យូទ័រនីមួយៗ ថតឯកសារដែលមានគម្រោង bot អាចមានទីតាំងនៅក្នុងថតផ្សេងៗគ្នា និងនៅលើដ្រាយផ្សេងគ្នា ដូច្នេះនៅក្នុងកូដផ្លូវទៅកាន់ថតគម្រោងនឹងត្រូវបានកំណត់តាមរយៈអថេរបរិស្ថាន។ TG_BOT_PATH.

មានវិធីជាច្រើនដើម្បីបង្កើតអថេរបរិស្ថាន ដែលសាមញ្ញបំផុតគឺសរសេរវានៅក្នុងឯកសារ .រ៉េនវីរ៉ុន.

អ្នកអាចបង្កើត ឬកែសម្រួលឯកសារនេះដោយប្រើពាក្យបញ្ជា file.edit(path.expand(file.path("~", ".Renviron"))). ប្រតិបត្តិវា ហើយបន្ថែមបន្ទាត់មួយទៅឯកសារ៖

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

បន្ទាប់រក្សាទុកឯកសារ .រ៉េនវីរ៉ុន ហើយចាប់ផ្តើម RStudio ឡើងវិញ។

ការបង្កើតមូលដ្ឋានទិន្នន័យ

ជំហានបន្ទាប់គឺបង្កើតមូលដ្ឋានទិន្នន័យ។ យើងនឹងត្រូវការតុចំនួន ២៖

• chat_data — ទិន្នន័យដែល bot បានស្នើសុំពីអ្នកប្រើប្រាស់
• 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
);

ប្រសិនបើអ្នកបានទាញយកគម្រោង bot ពី 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]])

}

យើងបានបង្កើតមុខងារសាមញ្ញចំនួន ៤៖

• 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 មានកម្រិតនៃភាពឯកកោ និងជាគន្លឹះចម្បងនៃតារាង។ ជាដំបូង យើងព្យាយាមបន្ថែមព័ត៌មានទៅក្នុងតារាង ហើយយើងទទួលបានកំហុស ប្រសិនបើទិន្នន័យសម្រាប់ការជជែកបច្ចុប្បន្នមានវត្តមានរួចហើយ ក្នុងករណីនេះ យើងគ្រាន់តែធ្វើបច្ចុប្បន្នភាពព័ត៌មានសម្រាប់ការជជែកនេះ។

បន្ទាប់មក យើងនឹងប្រើមុខងារទាំងនេះនៅក្នុងវិធី និងតម្រងរបស់ bot ។

វិធីសាស្រ្តបូត

ជំហានបន្ទាប់ក្នុងការបង្កើត bot របស់យើងគឺបង្កើតវិធីសាស្រ្ត។ ប្រសិនបើអ្នកបានទាញយកគម្រោងពី GitHubបន្ទាប់មកវិធីសាស្រ្តទាំងអស់គឺនៅក្នុងឯកសារ bot_methods.R.

កូដវិធីសាស្ត្រ Bot

# ###########################################################
# 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')
  }

}

យើងបានបង្កើតវិធីសាស្រ្តចំនួន ៥៖

• ចាប់ផ្តើម - ចាប់ផ្តើមប្រអប់
• រដ្ឋ - ទទួលបានស្ថានភាពជជែកបច្ចុប្បន្ន
• កំណត់ឡើងវិញ - កំណត់ស្ថានភាពជជែកបច្ចុប្បន្នឡើងវិញ
• enter_name - bot សួររកឈ្មោះរបស់អ្នក។
• enter_age — bot សួររកអាយុរបស់អ្នក។

វិធីសាស្រ្ត start សួររកឈ្មោះរបស់អ្នក ហើយប្តូរស្ថានភាពជជែកទៅ wait_name, i.e. ដើម្បីរង់ចាំសម្រាប់ការបញ្ចូលឈ្មោះរបស់អ្នក។

បន្ទាប់អ្នកផ្ញើឈ្មោះហើយវាត្រូវបានដំណើរការដោយវិធីសាស្ត្រ enter_namebot ស្វាគមន៍អ្នក សរសេរឈ្មោះដែលទទួលបានទៅក្នុងមូលដ្ឋានទិន្នន័យ ហើយប្តូរការជជែកទៅជាស្ថានភាព រង់ចាំ_អាយុ.

នៅដំណាក់កាលនេះ bot រំពឹងថាអ្នកនឹងចូលអាយុរបស់អ្នក។ អ្នកផ្ញើអាយុរបស់អ្នក bot ពិនិត្យសារ ប្រសិនបើអ្នកផ្ញើអត្ថបទមួយចំនួនជំនួសឱ្យលេខ វានឹងនិយាយថា៖ Ты ввёл некорректные данные, введи числоហើយនឹងរង់ចាំឱ្យអ្នកបញ្ចូលទិន្នន័យរបស់អ្នកឡើងវិញ។ ប្រសិនបើអ្នកបានផ្ញើលេខមួយ bot នឹងរាយការណ៍ថាវាបានទទួលយកអាយុរបស់អ្នក សរសេរទិន្នន័យដែលទទួលបានទៅមូលដ្ឋានទិន្នន័យ រាយការណ៍ទិន្នន័យទាំងអស់ដែលទទួលបានពីអ្នក ហើយត្រឡប់ស្ថានភាពជជែកទៅទីតាំងដើមរបស់វា ពោលគឺឧ។ វ start.

ដោយហៅវិធីសាស្ត្រ state អ្នក​អាច​ស្នើ​សុំ​ស្ថានភាព​ជជែក​កំសាន្ត​បច្ចុប្បន្ន​នៅ​ពេល​ណា​ក៏​បាន ហើយ​ដោយ​ប្រើ​ពាក្យ​បញ្ជា reset ត្រឡប់ការជជែកទៅសភាពដើមរបស់វា។

តម្រងសារ

ក្នុងករណីរបស់យើងនេះគឺជាផ្នែកមួយដ៏សំខាន់បំផុតក្នុងការបង្កើត bot ។ វាគឺដោយមានជំនួយពីតម្រងសារដែល bot នឹងយល់ពីព័ត៌មានដែលវារំពឹងទុកពីអ្នក និងរបៀបដែលវាគួរតែត្រូវបានដំណើរការ។

នៅក្នុងគម្រោងនៅលើ GitHub តម្រងត្រូវបានចុះឈ្មោះក្នុងឯកសារ message_filters.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 អាគុយម៉ង់ លេខសម្គាល់ការជជែក។

តម្រងបន្ទាប់ wait_name ដំណើរការសារនៅពេលដែលការជជែកស្ថិតក្នុងស្ថានភាពមួយ។ wait_nameហើយយោងទៅតាមតម្រង រង់ចាំ_អាយុ ដំណើរការសារនៅពេលដែលការជជែកស្ថិតក្នុងស្ថានភាពមួយ។ wait_age.

អ្នកដោះស្រាយ

ឯកសារដែលមានអ្នកដោះស្រាយត្រូវបានគេហៅថា អ្នកដោះស្រាយ.Rនិងមានលេខកូដដូចខាងក្រោមៈ

# ###########################################################
# 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ដូច្នេះយើងអាចប្រើពាក្យបញ្ជាក្នុងស្ថានភាពជជែកណាមួយ។

កូដបើកដំណើរការបូត

ឥឡូវនេះយើងមានអ្វីគ្រប់យ៉ាងដែលត្រៀមរួចជាស្រេចដើម្បីបើកដំណើរការ កូដចម្បងសម្រាប់ការបើកដំណើរការ bot គឺនៅក្នុងឯកសារ bot.R.

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()

ជាលទ្ធផលយើងទទួលបាន bot នេះ៖

នៅពេលណាមួយដោយប្រើពាក្យបញ្ជា /state យើងអាចសួរស្ថានភាពជជែកបច្ចុប្បន្ន និងដោយប្រើពាក្យបញ្ជា /reset ត្រឡប់ការជជែកទៅសភាពដើមរបស់វា ហើយចាប់ផ្តើមការសន្ទនាម្តងទៀត។

សេចក្តីសន្និដ្ឋាន

នៅក្នុងអត្ថបទនេះ យើងបានស្វែងយល់ពីរបៀបប្រើមូលដ្ឋានទិន្នន័យនៅខាងក្នុង bot និងរបៀបបង្កើតការសន្ទនាតក្កវិជ្ជាតាមលំដាប់លំដោយដោយកត់ត្រាស្ថានភាពជជែក។

ក្នុងករណីនេះ យើងបានក្រឡេកមើលឧទាហរណ៍បឋមបំផុត ដើម្បីអោយអ្នកយល់កាន់តែច្បាស់ពីគំនិតនៃការបង្កើត bots បែបនេះ ហើយនៅក្នុងការអនុវត្ត អ្នកអាចបង្កើតការសន្ទនាដែលស្មុគស្មាញជាងនេះ។

នៅក្នុងអត្ថបទបន្ទាប់នៅក្នុងស៊េរីនេះ យើងនឹងរៀនពីរបៀបដាក់កម្រិតសិទ្ធិរបស់អ្នកប្រើ bot ដើម្បីប្រើវិធីសាស្រ្តផ្សេងៗរបស់វា។

ប្រភព: www.habr.com