אם כבר קראת את הקודם שלושה מאמרים מהסדרה הזו, אז אתה כבר יודע איך לכתוב בוטים של טלגרם מן המניין עם מקלדת.

במאמר זה נלמד כיצד לכתוב בוט שישמור על דיאלוג עקבי. הָהֵן. הבוט ישאל אותך שאלות ויחכה שתזין קצת מידע. בהתאם לנתונים שתזין, הבוט יבצע כמה פעולות.

גם במאמר זה נלמד כיצד להשתמש במסד נתונים מתחת למכסה המנוע של הבוט, בדוגמה שלנו זה יהיה SQLite, אבל אתה יכול להשתמש בכל DBMS אחר. כתבתי בפירוט רב יותר על אינטראקציה עם מסדי נתונים בשפת R ב מאמר זה.

כל הכתבות מהסדרה "כתיבת בוט טלגרם ב-R"

1. אנו יוצרים בוט ומשתמשים בו כדי לשלוח הודעות בטלגרם
2. הוסף תמיכה בפקודות ומסנני הודעות לבוט
3. כיצד להוסיף תמיכה במקלדת לבוט
4. בניית דיאלוג עקבי והגיוני עם הבוט

תוכן

אם אתה מעוניין בניתוח נתונים, אולי אתה מעוניין ב- שלי מברק и YouTube ערוצים. רוב התוכן מוקדש לשפת R.

1. מבוא
2. תהליך בניית בוט
3. מבנה פרויקט בוט
4. תצורת בוט
5. צור משתנה סביבה
6. יצירת מסד נתונים
7. כתיבת פונקציות לעבודה עם מסד הנתונים
8. שיטות בוט
9. מסנני הודעות
10. מטפלים
11. קוד השקת בוט
12. מסקנה

מבוא

על מנת שהבוט יבקש ממך נתונים וימתין שתזין מידע כלשהו, ​​תצטרך לתעד את המצב הנוכחי של הדיאלוג. הדרך הטובה ביותר לעשות זאת היא להשתמש בסוג של מסד נתונים משובץ, כגון SQLite.

הָהֵן. ההיגיון יהיה כדלקמן. אנו קוראים לשיטת הבוט, והבוט מבקש מאיתנו ברצף מידע כלשהו, ​​ובכל שלב הוא ממתין להזנת המידע הזה ויכול לבדוק אותו.

נכתוב את הבוט הפשוט ביותר האפשרי, קודם הוא יבקש את שמך, אחר כך את גילך, וישמור את הנתונים שהתקבלו במסד הנתונים. כאשר מבקשים גיל, הוא יבדוק שהנתונים שהוזנו הם מספר ולא טקסט.

לדיאלוג פשוט כזה יהיו רק שלושה מצבים:

1. start הוא המצב הרגיל של הבוט, שבו הוא לא מצפה לשום מידע ממך
2. wait_name - מצב שבו הבוט מחכה להזנת שם
3. wait_age הוא המצב שבו הבוט מחכה להזנת גילך, מספר השנים המלאות.

תהליך בניית בוט

במהלך המאמר, נבנה בוט צעד אחר צעד; התהליך כולו יכול להיות מתואר באופן סכמטי באופן הבא:

1. אנו יוצרים תצורת בוט שבה נאחסן כמה הגדרות. במקרה שלנו, אסימון הבוט, והנתיב לקובץ מסד הנתונים.
2. אנו יוצרים משתנה סביבה בו יאוחסן הנתיב לפרויקט עם הבוט.
3. אנו יוצרים את בסיס הנתונים עצמו, ומספר פונקציות כדי שהבוט יוכל ליצור איתו אינטראקציה.
4. אנחנו כותבים שיטות בוטים, כלומר. הפונקציות שהוא יבצע.
5. הוספת מסנני הודעות. בעזרתו הבוט ייגש לשיטות הדרושות, בהתאם למצב הנוכחי של הצ'אט.
6. אנו מוסיפים מטפלים שיחברו פקודות והודעות עם שיטות הבוט הנדרשות.
7. בואו נפעיל את הבוט.

מבנה פרויקט בוט

מטעמי נוחות, נחלק את הקוד של הבוט שלנו, וקבצים קשורים אחרים, למבנה הבא.

• bot.R - הקוד הראשי של הבוט שלנו
• 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.

צור משתנה סביבה

בכל PC ניתן לאתר את התיקיה עם פרויקט הבוט בספריות שונות ובכוננים שונים, כך שבקוד הנתיב לתיקיית הפרויקט יוגדר באמצעות משתנה סביבה TG_BOT_PATH.

ישנן מספר דרכים ליצור משתנה סביבה, הפשוטה ביותר היא לכתוב אותו בקובץ .Renviron.

אתה יכול ליצור או לערוך קובץ זה באמצעות הפקודה file.edit(path.expand(file.path("~", ".Renviron"))). בצע אותו והוסף שורה אחת לקובץ:

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

לאחר מכן שמור את הקובץ .Renviron והפעל מחדש את 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, הבוט מברך אותך, כותב את השם שהתקבל למסד הנתונים, ומעביר את הצ'אט למצב wait_age.

בשלב זה, הבוט מצפה ממך להזין את הגיל שלך. אתה שולח את הגיל שלך, הבוט בודק את ההודעה, אם שלחת טקסט במקום מספר, הוא יגיד: Ты ввёл некорректные данные, введи число, וימתין שתזין מחדש את הנתונים שלך. אם שלחת מספר, הבוט ידווח שהוא קיבל את גילך, יכתוב את הנתונים שהתקבלו למאגר, ידווח על כל הנתונים שהתקבלו ממך ויחזיר את מצב הצ'אט למקומו המקורי, כלומר. V start.

על ידי קריאה לשיטה state אתה יכול לבקש את סטטוס הצ'אט הנוכחי בכל עת, ובאמצעות reset להחזיר את הצ'אט למצבו המקורי.

מסנני הודעות

במקרה שלנו, זהו אחד החלקים החשובים ביותר בבניית בוט. בעזרת מסנני מסרים הבוט יבין איזה מידע הוא מצפה ממך וכיצד יש לעבד אותו.

בפרויקט על 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(), כדי לבקש את המצב הנוכחי של הצ'אט. פונקציה זו דורשת רק ארגומנט אחד, מזהה צ'אט.

המסנן הבא wait_name מעבד הודעות כאשר הצ'אט נמצא במצב wait_name, ובהתאם לכך הפילטר wait_age מעבד הודעות כאשר הצ'אט נמצא במצב 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, כדי שנוכל להשתמש בפקודות בכל מצב צ'אט.

קוד השקת בוט

כעת יש לנו הכל מוכן להפעלה, הקוד הראשי להפעלת הבוט נמצא בקובץ 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()

כתוצאה מכך, קיבלנו את הבוט הזה:

בכל עת באמצעות הפקודה /state אנו יכולים לשאול את מצב הצ'אט הנוכחי, ובאמצעות הפקודה /reset להחזיר את הצ'אט למצבו המקורי ולהתחיל את הדיאלוג שוב.

מסקנה

במאמר זה, הבנו כיצד להשתמש במסד נתונים בתוך בוט, וכיצד לבנות דיאלוגים לוגיים עוקבים על ידי הקלטת מצב הצ'אט.

במקרה זה, הסתכלנו על הדוגמה הפרימיטיבית ביותר, כדי שיהיה לך קל יותר להבין את הרעיון של בניית בוטים כאלה; בפועל, אתה יכול לבנות דיאלוגים הרבה יותר מורכבים.

במאמר הבא בסדרה זו נלמד כיצד להגביל את הזכויות של משתמשי הבוט להשתמש בשיטות שונות שלו.

מקור: www.habr.com