మీరు ఇప్పటికే మునుపటిది చదివి ఉంటే ఈ సిరీస్ నుండి, కీబోర్డ్‌తో పూర్తి స్థాయి టెలిగ్రామ్ బాట్లను ఎలా వ్రాయాలో మీకు ఇప్పటికే తెలుసు.
ఈ వ్యాసంలో, స్థిరమైన సంభాషణను నిర్వహించే బాట్‌ను ఎలా వ్రాయాలో నేర్చుకుంటాము. ఆ. బోట్ మిమ్మల్ని ప్రశ్నలు అడుగుతుంది మరియు మీరు కొంత సమాచారాన్ని నమోదు చేసే వరకు వేచి ఉంటుంది. మీరు నమోదు చేసిన డేటాపై ఆధారపడి, బోట్ కొన్ని చర్యలను చేస్తుంది.
ఈ కథనంలో బాట్ యొక్క హుడ్ కింద డేటాబేస్ను ఎలా ఉపయోగించాలో నేర్చుకుంటాము, మా ఉదాహరణలో ఇది SQLite అవుతుంది, కానీ మీరు ఏదైనా ఇతర DBMS ను ఉపయోగించవచ్చు. R భాషలో డేటాబేస్‌లతో పరస్పర చర్య చేయడం గురించి నేను మరింత వివరంగా వ్రాసాను .
“R లో టెలిగ్రామ్ బాట్ రాయడం” సిరీస్‌లోని అన్ని కథనాలు
కంటెంట్
మీకు డేటా విశ్లేషణపై ఆసక్తి ఉంటే, మీరు నాపై ఆసక్తి కలిగి ఉండవచ్చు и ఛానెల్‌లు. చాలా కంటెంట్ R భాషకు అంకితం చేయబడింది.
పరిచయం
బోట్ మీ నుండి డేటాను అభ్యర్థించడానికి మరియు మీరు ఏదైనా సమాచారాన్ని నమోదు చేయడానికి వేచి ఉండటానికి, మీరు డైలాగ్ యొక్క ప్రస్తుత స్థితిని రికార్డ్ చేయాలి. SQLite వంటి కొన్ని రకాల పొందుపరిచిన డేటాబేస్ను ఉపయోగించడం దీనికి ఉత్తమ మార్గం.
ఆ. లాజిక్ ఈ క్రింది విధంగా ఉంటుంది. మేము బాట్ పద్ధతిని పిలుస్తాము మరియు బోట్ మా నుండి కొంత సమాచారాన్ని క్రమంగా అభ్యర్థిస్తుంది మరియు ప్రతి దశలో ఈ సమాచారం నమోదు చేయబడటానికి వేచి ఉంటుంది మరియు దానిని తనిఖీ చేయవచ్చు.
మేము సాధ్యమైనంత సరళమైన బాట్‌ను వ్రాస్తాము, మొదట అది మీ పేరును అడుగుతుంది, ఆపై మీ వయస్సు, మరియు అందుకున్న డేటాను డేటాబేస్కు సేవ్ చేస్తుంది. వయస్సు కోసం అడుగుతున్నప్పుడు, నమోదు చేసిన డేటా సంఖ్య అని మరియు వచనం కాదని తనిఖీ చేస్తుంది.
అటువంటి సాధారణ సంభాషణలో మూడు రాష్ట్రాలు మాత్రమే ఉంటాయి:
- ప్రారంభం అనేది బాట్ యొక్క సాధారణ స్థితి, దీనిలో అది మీ నుండి ఎటువంటి సమాచారాన్ని ఆశించదు
- wait_name - పేరు నమోదు చేయడానికి బాట్ వేచి ఉండే స్థితి
- wait_age అనేది మీ వయస్సును నమోదు చేయడానికి బోట్ వేచి ఉండే స్థితి, పూర్తి సంవత్సరాల సంఖ్య.
బాట్ నిర్మాణ ప్రక్రియ
వ్యాసం సమయంలో, మేము దశలవారీగా బాట్‌ను నిర్మిస్తాము; మొత్తం ప్రక్రియను ఈ క్రింది విధంగా క్రమపద్ధతిలో చిత్రీకరించవచ్చు:
- మేము బోట్ కాన్ఫిగరేషన్‌ను సృష్టిస్తాము, దీనిలో మేము కొన్ని సెట్టింగ్‌లను నిల్వ చేస్తాము. మా విషయంలో, బోట్ టోకెన్ మరియు డేటాబేస్ ఫైల్‌కి మార్గం.
- మేము పర్యావరణ వేరియబుల్‌ని సృష్టిస్తాము, దీనిలో బోట్‌తో ప్రాజెక్ట్‌కు మార్గం నిల్వ చేయబడుతుంది.
- మేము డేటాబేస్ను మరియు అనేక ఫంక్షన్లను సృష్టిస్తాము, తద్వారా బోట్ దానితో పరస్పర చర్య చేయవచ్చు.
- మేము బోట్ పద్ధతులను వ్రాస్తాము, అనగా. అది నిర్వర్తించే విధులు.
- సందేశ ఫిల్టర్‌లను జోడిస్తోంది. చాట్ యొక్క ప్రస్తుత స్థితిని బట్టి బోట్ అవసరమైన పద్ధతులను యాక్సెస్ చేసే సహాయంతో.
- మేము అవసరమైన బాట్ పద్ధతులతో ఆదేశాలు మరియు సందేశాలను కనెక్ట్ చేసే హ్యాండ్లర్‌లను జోడిస్తాము.
- బాట్‌ను ప్రారంభిద్దాం.
బాట్ ప్రాజెక్ట్ నిర్మాణం
సౌలభ్యం కోసం, మేము మా బాట్ యొక్క కోడ్‌ను మరియు ఇతర సంబంధిత ఫైల్‌లను క్రింది నిర్మాణంగా విభజిస్తాము.
- బోట్.ఆర్ - మా బాట్ యొక్క ప్రధాన కోడ్
- db_bot_function.R — డేటాబేస్తో పని చేయడానికి ఫంక్షన్లతో కూడిన కోడ్ బ్లాక్
- bot_methods.R - బోట్ పద్ధతుల కోడ్
- message_filters.R - సందేశ ఫిల్టర్లు
- నిర్వాహకులు.ఆర్ - హ్యాండ్లర్లు
- config.cfg - బోట్ కాన్ఫిగరేషన్
- create_db_data.sql — డేటాబేస్‌లో చాట్ డేటాతో పట్టికను రూపొందించడానికి SQL స్క్రిప్ట్
- create_db_state.sql — డేటాబేస్‌లో ప్రస్తుత చాట్ స్థితి యొక్క పట్టికను రూపొందించడానికి SQL స్క్రిప్ట్
- bot.db - బోట్ డేటాబేస్
మీరు మొత్తం బోట్ ప్రాజెక్ట్‌ను వీక్షించవచ్చు లేదా నా నుంచి .
బాట్ కాన్ఫిగరేషన్
మేము సాధారణ దానిని కాన్ఫిగరేషన్‌గా ఉపయోగిస్తాము , క్రింది రూపం:
[bot_settings]
bot_token=ТОКЕН_ВАШЕГО_БОТА
[db_settings]
db_path=C:/ПУТЬ/К/ПАПКЕ/ПРОЕКТА/bot.dbకాన్ఫిగరేషన్‌లో మేము బోట్ టోకెన్ మరియు డేటాబేస్కు మార్గాన్ని వ్రాస్తాము, అనగా. bot.db ఫైల్‌కు; మేము తదుపరి దశలో ఫైల్‌ను సృష్టిస్తాము.
మరింత సంక్లిష్టమైన బాట్‌ల కోసం, మీరు మరింత సంక్లిష్టమైన కాన్ఫిగర్‌లను సృష్టించవచ్చు, అంతేకాకుండా, ini configని వ్రాయవలసిన అవసరం లేదు, మీరు JSONతో సహా ఏదైనా ఇతర ఆకృతిని ఉపయోగించవచ్చు.
పర్యావరణ వేరియబుల్‌ను సృష్టించండి
ప్రతి PCలో, బోట్ ప్రాజెక్ట్‌తో ఉన్న ఫోల్డర్ వేర్వేరు డైరెక్టరీలలో మరియు విభిన్న డ్రైవ్‌లలో ఉంటుంది, కాబట్టి కోడ్‌లో ప్రాజెక్ట్ ఫోల్డర్‌కు మార్గం పర్యావరణ వేరియబుల్ ద్వారా సెట్ చేయబడుతుంది 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.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 మీ పేరు కోసం అడుగుతుంది మరియు చాట్ స్థితిని మారుస్తుంది వెయిట్_పేరు, అనగా మీ పేరు నమోదు చేయడానికి సిద్ధంగా ఉండండి.
తరువాత, మీరు పేరును పంపండి మరియు అది పద్ధతి ద్వారా ప్రాసెస్ చేయబడుతుంది enter_name, బోట్ మిమ్మల్ని పలకరించి, అందుకున్న పేరును డేటాబేస్‌లో వ్రాసి, చాట్‌ను స్థితికి మారుస్తుంది వేచి_వయస్సు.
ఈ దశలో, మీరు మీ వయస్సులోకి ప్రవేశించాలని బోట్ ఆశిస్తోంది. మీరు మీ వయస్సును పంపండి, బోట్ సందేశాన్ని తనిఖీ చేస్తుంది, మీరు సంఖ్యకు బదులుగా కొంత వచనాన్ని పంపినట్లయితే, అది ఇలా చెబుతుంది: Ты ввёл некорректные данные, введи число, మరియు మీరు మీ డేటాను మళ్లీ నమోదు చేయడానికి వేచి ఉంటారు. మీరు నంబర్‌ను పంపినట్లయితే, బోట్ మీ వయస్సును అంగీకరించినట్లు నివేదిస్తుంది, అందుకున్న డేటాను డేటాబేస్కు వ్రాసి, మీ నుండి స్వీకరించిన మొత్తం డేటాను నివేదించండి మరియు చాట్ స్థితిని దాని అసలు స్థానానికి తిరిగి ఇస్తుంది, అనగా. వి start.
పద్ధతిని కాల్ చేయడం ద్వారా state మీరు ఏ సమయంలోనైనా ప్రస్తుత చాట్ స్థితిని అభ్యర్థించవచ్చు మరియు reset చాట్‌ను దాని అసలు స్థితికి తిరిగి ఇవ్వండి.
సందేశ ఫిల్టర్లు
మా విషయంలో, బోట్‌ను నిర్మించడంలో ఇది చాలా ముఖ్యమైన భాగాలలో ఒకటి. మెసేజ్ ఫిల్టర్‌ల సహాయంతో బోట్ మీ నుండి ఏ సమాచారాన్ని ఆశిస్తున్నదో మరియు దానిని ఎలా ప్రాసెస్ చేయాలో అర్థం చేసుకుంటుంది.
న ప్రాజెక్ట్ లో ఫిల్టర్లు ఫైల్‌లో నమోదు చేయబడ్డాయి 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_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