നിങ്ങൾ മുമ്പത്തേത് ഇതിനകം വായിച്ചിട്ടുണ്ടെങ്കിൽ മൂന്ന് ലേഖനങ്ങൾ ഈ ശ്രേണിയിൽ നിന്ന്, കീബോർഡ് ഉപയോഗിച്ച് പൂർണ്ണമായ ടെലിഗ്രാം ബോട്ടുകൾ എങ്ങനെ എഴുതാമെന്ന് നിങ്ങൾക്ക് ഇതിനകം അറിയാം.

ഈ ലേഖനത്തിൽ, സ്ഥിരമായ സംഭാഷണം നിലനിർത്തുന്ന ഒരു ബോട്ട് എങ്ങനെ എഴുതാമെന്ന് നമ്മൾ പഠിക്കും. ആ. ബോട്ട് നിങ്ങളോട് ചോദ്യങ്ങൾ ചോദിക്കുകയും നിങ്ങൾ ചില വിവരങ്ങൾ നൽകുന്നതിനായി കാത്തിരിക്കുകയും ചെയ്യും. നിങ്ങൾ നൽകുന്ന ഡാറ്റയെ ആശ്രയിച്ച്, ബോട്ട് ചില പ്രവർത്തനങ്ങൾ നടത്തും.

ഈ ലേഖനത്തിൽ ബോട്ടിന്റെ ഹൂഡിന് കീഴിൽ ഒരു ഡാറ്റാബേസ് എങ്ങനെ ഉപയോഗിക്കാമെന്ന് ഞങ്ങൾ പഠിക്കും, ഞങ്ങളുടെ ഉദാഹരണത്തിൽ ഇത് 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 - ബോട്ട് രീതികളുടെ കോഡ്
• message_filters.R - സന്ദേശ ഫിൽട്ടറുകൾ
• കൈകാര്യം ചെയ്യുന്നവർ.ആർ - കൈകാര്യം ചെയ്യുന്നവർ
• 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 കോൺഫിഗറേഷൻ എഴുതേണ്ട ആവശ്യമില്ല, നിങ്ങൾക്ക് 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.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