நீங்கள் ஏற்கனவே முந்தையதைப் படித்திருந்தால் மூன்று கட்டுரைகள் இந்தத் தொடரிலிருந்து, விசைப்பலகை மூலம் முழு அளவிலான டெலிகிராம் போட்களை எப்படி எழுதுவது என்பது உங்களுக்கு ஏற்கனவே தெரியும்.

இந்த கட்டுரையில், ஒரு நிலையான உரையாடலைப் பராமரிக்கும் ஒரு போட் எழுதுவது எப்படி என்பதைக் கற்றுக்கொள்வோம். அந்த. போட் உங்களிடம் கேள்விகளைக் கேட்கும் மற்றும் நீங்கள் சில தகவல்களை உள்ளிடும் வரை காத்திருக்கும். நீங்கள் உள்ளிடும் தரவைப் பொறுத்து, போட் சில செயல்களைச் செய்யும்.

இந்த கட்டுரையில் போட் ஹூட்டின் கீழ் ஒரு தரவுத்தளத்தை எவ்வாறு பயன்படுத்துவது என்பதைக் கற்றுக்கொள்வோம், எங்கள் எடுத்துக்காட்டில் இது SQLite ஆக இருக்கும், ஆனால் நீங்கள் வேறு எந்த DBMS ஐப் பயன்படுத்தலாம். R மொழியில் தரவுத்தளங்களுடன் தொடர்புகொள்வது பற்றி விரிவாக எழுதினேன் இந்த கட்டுரையில்.

"R இல் டெலிகிராம் போட் எழுதுதல்" தொடரின் அனைத்து கட்டுரைகளும்

உள்ளடக்கம்

நீங்கள் தரவு பகுப்பாய்வில் ஆர்வமாக இருந்தால், நீங்கள் என் மீது ஆர்வமாக இருக்கலாம் தந்தி и YouTube சேனல்கள். பெரும்பாலான உள்ளடக்கம் R மொழிக்கு அர்ப்பணிக்கப்பட்டுள்ளது.

அறிமுகம்
பாட் கட்டுமான செயல்முறை
பாட் திட்ட அமைப்பு
பாட் கட்டமைப்பு
சூழல் மாறியை உருவாக்கவும்
ஒரு தரவுத்தளத்தை உருவாக்குதல்
தரவுத்தளத்துடன் வேலை செய்வதற்கான செயல்பாடுகளை எழுதுதல்
பாட் முறைகள்
செய்தி வடிப்பான்கள்
கையாளுபவர்கள்
பாட் வெளியீட்டு குறியீடு
முடிவுக்கு

அறிமுகம்

போட் உங்களிடமிருந்து தரவைக் கோருவதற்கும், நீங்கள் எந்த தகவலை உள்ளிடுவதற்கும் காத்திருக்க, உரையாடலின் தற்போதைய நிலையை நீங்கள் பதிவு செய்ய வேண்டும். இதைச் செய்வதற்கான சிறந்த வழி, SQLite போன்ற உட்பொதிக்கப்பட்ட தரவுத்தளத்தைப் பயன்படுத்துவதாகும்.

அந்த. தர்க்கம் பின்வருமாறு இருக்கும். நாம் போட் முறையை அழைக்கிறோம், மேலும் போட் எங்களிடமிருந்து சில தகவல்களை தொடர்ச்சியாகக் கோருகிறது, மேலும் ஒவ்வொரு படியிலும் இந்தத் தகவல் உள்ளிடப்படும் வரை காத்திருக்கிறது மற்றும் அதைச் சரிபார்க்க முடியும்.

சாத்தியமான எளிய போட்களை நாங்கள் எழுதுவோம், முதலில் அது உங்கள் பெயரையும், பின்னர் உங்கள் வயதையும் கேட்கும், மேலும் பெறப்பட்ட தரவை தரவுத்தளத்தில் சேமிக்கும். வயதைக் கேட்கும் போது, உள்ளிடப்பட்ட தரவு எண்ணாக உள்ளதா மற்றும் உரை அல்ல என்பதைச் சரிபார்க்கும்.

அத்தகைய எளிய உரையாடலில் மூன்று நிலைகள் மட்டுமே இருக்கும்:

தொடக்கம் என்பது போட்டின் இயல்பான நிலை, அதில் அது உங்களிடமிருந்து எந்த தகவலையும் எதிர்பார்க்காது
காத்திரு_பெயர் - ஒரு பெயரை உள்ளிடுவதற்கு போட் காத்திருக்கும் நிலை
wait_age என்பது உங்கள் வயதை உள்ளிடுவதற்கு போட் காத்திருக்கும் நிலை, முழு ஆண்டுகளின் எண்ணிக்கை.

பாட் கட்டுமான செயல்முறை

கட்டுரையின் போது, படிப்படியாக ஒரு போட் கட்டுவோம்; முழு செயல்முறையையும் பின்வருமாறு சித்தரிக்கலாம்:

நாங்கள் ஒரு போட் கட்டமைப்பை உருவாக்குகிறோம், அதில் சில அமைப்புகளை சேமிப்போம். எங்கள் விஷயத்தில், போட் டோக்கன் மற்றும் தரவுத்தள கோப்பிற்கான பாதை.
பாட் உடன் திட்டத்திற்கான பாதை சேமிக்கப்படும் சூழல் மாறியை உருவாக்குகிறோம்.
நாங்கள் தரவுத்தளத்தை உருவாக்குகிறோம், மேலும் பல செயல்பாடுகளை போட் அதனுடன் தொடர்பு கொள்ள முடியும்.
நாங்கள் போட் முறைகளை எழுதுகிறோம், அதாவது. அது செய்யும் செயல்பாடுகள்.
செய்தி வடிப்பான்களைச் சேர்த்தல். அரட்டையின் தற்போதைய நிலையைப் பொறுத்து, தேவையான முறைகளை போட் அணுகும்.
கட்டளைகள் மற்றும் செய்திகளை தேவையான போட் முறைகளுடன் இணைக்கும் ஹேண்ட்லர்களை நாங்கள் சேர்க்கிறோம்.
போட் தொடங்குவோம்.

பாட் திட்ட அமைப்பு

வசதிக்காக, எங்கள் போட் மற்றும் பிற தொடர்புடைய கோப்புகளின் குறியீட்டை பின்வரும் கட்டமைப்பில் பிரிப்போம்.

போட்.ஆர் - எங்கள் போட்டின் முக்கிய குறியீடு
db_bot_function.R — தரவுத்தளத்துடன் பணிபுரிவதற்கான செயல்பாடுகளைக் கொண்ட குறியீட்டின் தொகுதி
bot_methods.ஆர் - போட் முறைகளின் குறியீடு
செய்தி_வடிப்பான்கள்.ஆர் - செய்தி வடிப்பான்கள்
கையாளுபவர்கள்.ஆர் - கையாளுபவர்கள்
config.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 config ஐ எழுத வேண்டிய அவசியமில்லை, 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
);

நீங்கள் போட் திட்டத்தை பதிவிறக்கம் செய்திருந்தால் மகிழ்ச்சியா, பின்னர் தரவுத்தளத்தை உருவாக்க நீங்கள் 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'))

தரவுத்தளத்துடன் வேலை செய்வதற்கான செயல்பாடுகளை எழுதுதல்

எங்களிடம் ஏற்கனவே உள்ளமைவு கோப்பு தயாராக உள்ளது மற்றும் ஒரு தரவுத்தளம் உருவாக்கப்பட்டுள்ளது. இந்த தரவுத்தளத்தில் தரவைப் படிக்கவும் எழுதவும் இப்போது நீங்கள் செயல்பாடுகளை எழுத வேண்டும்.

நீங்கள் திட்டத்தை பதிவிறக்கம் செய்திருந்தால் மகிழ்ச்சியா, பின்னர் நீங்கள் கோப்பில் செயல்பாடுகளைக் காணலாம் 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 ஒரு தனித்துவக் கட்டுப்பாடு உள்ளது மற்றும் அட்டவணைகளின் முதன்மை விசையாகும். ஆரம்பத்தில், அட்டவணையில் தகவலைச் சேர்க்க முயற்சிப்போம், தற்போதைய அரட்டைக்கான தரவு ஏற்கனவே இருந்தால் பிழையைப் பெறுவோம், இந்தச் சந்தர்ப்பத்தில் இந்த அரட்டைக்கான தகவலைப் புதுப்பிப்போம்.

அடுத்து, இந்த செயல்பாடுகளை போட் முறைகள் மற்றும் வடிப்பான்களில் பயன்படுத்துவோம்.

பாட் முறைகள்

எங்கள் போட்டை உருவாக்குவதற்கான அடுத்த படி முறைகளை உருவாக்குவது. நீங்கள் திட்டத்தை பதிவிறக்கம் செய்திருந்தால் மகிழ்ச்சியா, பின்னர் அனைத்து முறைகளும் கோப்பில் உள்ளன bot_methods.ஆர்.

பாட் முறை குறியீடு

# ###########################################################
# 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 உங்கள் பெயரைக் கேட்கிறது மற்றும் அரட்டை நிலையை மாற்றுகிறது காத்திரு_பெயர், அதாவது உங்கள் பெயரை உள்ளிடுவதற்கு காத்திருக்க வேண்டும்.

அடுத்து, நீங்கள் பெயரை அனுப்பவும், அது முறையால் செயலாக்கப்படும் enter_name, போட் உங்களை வாழ்த்துகிறது, பெறப்பட்ட பெயரை தரவுத்தளத்தில் எழுதுகிறது மற்றும் அரட்டையை மாநிலத்திற்கு மாற்றுகிறது காத்திருப்பு_வயது.

இந்த கட்டத்தில், நீங்கள் உங்கள் வயதை உள்ளிடுவீர்கள் என்று போட் எதிர்பார்க்கிறது. நீங்கள் உங்கள் வயதை அனுப்புகிறீர்கள், போட் செய்தியை சரிபார்க்கிறது, நீங்கள் எண்ணுக்கு பதிலாக சில உரையை அனுப்பினால், அது கூறுகிறது: Ты ввёл некорректные данные, введи число, மற்றும் உங்கள் தரவை மீண்டும் உள்ளிட நீங்கள் காத்திருக்கும். நீங்கள் எண்ணை அனுப்பினால், அது உங்கள் வயதை ஏற்றுக்கொண்டதாக போட் தெரிவிக்கும், பெறப்பட்ட தரவை தரவுத்தளத்தில் எழுதி, உங்களிடமிருந்து பெறப்பட்ட எல்லா தரவையும் புகாரளித்து, அரட்டை நிலையை அதன் அசல் நிலைக்குத் திருப்பிவிடும், அதாவது. வி start.

முறை அழைப்பதன் மூலம் state நீங்கள் எந்த நேரத்திலும் தற்போதைய அரட்டை நிலையைக் கோரலாம் reset அரட்டையை அதன் அசல் நிலைக்குத் திரும்பு.

செய்தி வடிப்பான்கள்

எங்கள் விஷயத்தில், இது ஒரு போட்டை உருவாக்குவதில் மிக முக்கியமான பகுதிகளில் ஒன்றாகும். செய்தி வடிப்பான்களின் உதவியுடன் தான் உங்களிடமிருந்து என்ன தகவலை எதிர்பார்க்கிறது மற்றும் அதை எவ்வாறு செயலாக்க வேண்டும் என்பதை போட் புரிந்து கொள்ளும்.

அன்று திட்டத்தில் மகிழ்ச்சியா வடிப்பான்கள் கோப்பில் பதிவு செய்யப்பட்டுள்ளன செய்தி_வடிப்பான்கள்.ஆர்.

செய்தி வடிகட்டி குறியீடு:

# ###########################################################
# 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_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

R இல் டெலிகிராம் போட் எழுதுதல் (பகுதி 4): போட் உடன் நிலையான, தர்க்கரீதியான உரையாடலை உருவாக்குதல்