ನೀವು ಈಗಾಗಲೇ ಹಿಂದಿನದನ್ನು ಓದಿದ್ದರೆ ಮೂರು ಲೇಖನಗಳು ಈ ಸರಣಿಯಿಂದ, ಕೀಬೋರ್ಡ್‌ನೊಂದಿಗೆ ಪೂರ್ಣ ಪ್ರಮಾಣದ ಟೆಲಿಗ್ರಾಮ್ ಬಾಟ್‌ಗಳನ್ನು ಹೇಗೆ ಬರೆಯುವುದು ಎಂದು ನಿಮಗೆ ಈಗಾಗಲೇ ತಿಳಿದಿದೆ.

ಈ ಲೇಖನದಲ್ಲಿ, ಸ್ಥಿರವಾದ ಸಂಭಾಷಣೆಯನ್ನು ನಿರ್ವಹಿಸುವ ಬೋಟ್ ಅನ್ನು ಹೇಗೆ ಬರೆಯಬೇಕೆಂದು ನಾವು ಕಲಿಯುತ್ತೇವೆ. ಆ. ಬೋಟ್ ನಿಮಗೆ ಪ್ರಶ್ನೆಗಳನ್ನು ಕೇಳುತ್ತದೆ ಮತ್ತು ನೀವು ಕೆಲವು ಮಾಹಿತಿಯನ್ನು ನಮೂದಿಸಲು ಕಾಯುತ್ತದೆ. ನೀವು ನಮೂದಿಸಿದ ಡೇಟಾವನ್ನು ಅವಲಂಬಿಸಿ, ಬೋಟ್ ಕೆಲವು ಕ್ರಿಯೆಗಳನ್ನು ಮಾಡುತ್ತದೆ.

ಈ ಲೇಖನದಲ್ಲಿ ನಾವು ಬೋಟ್ನ ಹುಡ್ ಅಡಿಯಲ್ಲಿ ಡೇಟಾಬೇಸ್ ಅನ್ನು ಹೇಗೆ ಬಳಸಬೇಕೆಂದು ಕಲಿಯುತ್ತೇವೆ, ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ ಅದು SQLite ಆಗಿರುತ್ತದೆ, ಆದರೆ ನೀವು ಯಾವುದೇ DBMS ಅನ್ನು ಬಳಸಬಹುದು. R ಭಾಷೆಯಲ್ಲಿ ಡೇಟಾಬೇಸ್‌ಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುವ ಕುರಿತು ನಾನು ಹೆಚ್ಚು ವಿವರವಾಗಿ ಬರೆದಿದ್ದೇನೆ ಈ ಲೇಖನ.

"R ನಲ್ಲಿ ಟೆಲಿಗ್ರಾಮ್ ಬಾಟ್ ಅನ್ನು ಬರೆಯುವುದು" ಸರಣಿಯ ಎಲ್ಲಾ ಲೇಖನಗಳು

ಪರಿವಿಡಿ

ನೀವು ಡೇಟಾ ವಿಶ್ಲೇಷಣೆಯಲ್ಲಿ ಆಸಕ್ತಿ ಹೊಂದಿದ್ದರೆ, ನೀವು ನನ್ನ ಬಗ್ಗೆ ಆಸಕ್ತಿ ಹೊಂದಿರಬಹುದು ಟೆಲಿಗ್ರಾಮ್ и YouTube ವಾಹಿನಿಗಳು. ಹೆಚ್ಚಿನ ವಿಷಯವನ್ನು 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 - ಬೋಟ್ ಡೇಟಾಬೇಸ್

ನೀವು ಸಂಪೂರ್ಣ ಬೋಟ್ ಯೋಜನೆಯನ್ನು ವೀಕ್ಷಿಸಬಹುದು, ಅಥವಾ скачать ನನ್ನ ಬಳಿಯಿಂದ GitHub ನಲ್ಲಿ ರೆಪೊಸಿಟರಿ.

ಬಾಟ್ ಕಾನ್ಫಿಗರ್

ನಾವು ಸಾಮಾನ್ಯವಾದದನ್ನು ಕಾನ್ಫಿಗರ್ ಆಗಿ ಬಳಸುತ್ತೇವೆ ini ಫೈಲ್, ಕೆಳಗಿನ ರೂಪ:

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

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

ಸಂರಚನೆಯಲ್ಲಿ ನಾವು ಬೋಟ್ ಟೋಕನ್ ಮತ್ತು ಡೇಟಾಬೇಸ್ಗೆ ಮಾರ್ಗವನ್ನು ಬರೆಯುತ್ತೇವೆ, ಅಂದರೆ. bot.db ಫೈಲ್‌ಗೆ; ಮುಂದಿನ ಹಂತದಲ್ಲಿ ನಾವು ಫೈಲ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ.

ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಬಾಟ್‌ಗಳಿಗಾಗಿ, ನೀವು ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಸಂರಚನೆಗಳನ್ನು ರಚಿಸಬಹುದು, ಜೊತೆಗೆ, ini ಸಂರಚನೆಯನ್ನು ಬರೆಯುವ ಅಗತ್ಯವಿಲ್ಲ, ನೀವು 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
);

ನೀವು ಬೋಟ್ ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿದ್ದರೆ 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 ನಿಮ್ಮ ಹೆಸರನ್ನು ಕೇಳುತ್ತದೆ ಮತ್ತು ಚಾಟ್ ಸ್ಥಿತಿಯನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ ನಿರೀಕ್ಷಿಸಿ_ಹೆಸರು, ಅಂದರೆ ನಿಮ್ಮ ಹೆಸರನ್ನು ನಮೂದಿಸಲು ಸ್ಟ್ಯಾಂಡ್‌ಬೈ ಮಾಡಲು.

ಮುಂದೆ, ನೀವು ಹೆಸರನ್ನು ಕಳುಹಿಸಿ ಮತ್ತು ಅದನ್ನು ವಿಧಾನದಿಂದ ಸಂಸ್ಕರಿಸಲಾಗುತ್ತದೆ enter_name, ಬೋಟ್ ನಿಮ್ಮನ್ನು ಸ್ವಾಗತಿಸುತ್ತದೆ, ಸ್ವೀಕರಿಸಿದ ಹೆಸರನ್ನು ಡೇಟಾಬೇಸ್‌ಗೆ ಬರೆಯುತ್ತದೆ ಮತ್ತು ಚಾಟ್ ಅನ್ನು ರಾಜ್ಯಕ್ಕೆ ಬದಲಾಯಿಸುತ್ತದೆ ಕಾಯುವ_ವಯಸ್ಸು.

ಈ ಹಂತದಲ್ಲಿ, ನಿಮ್ಮ ವಯಸ್ಸನ್ನು ನೀವು ನಮೂದಿಸಬೇಕೆಂದು ಬೋಟ್ ನಿರೀಕ್ಷಿಸುತ್ತದೆ. ನೀವು ನಿಮ್ಮ ವಯಸ್ಸನ್ನು ಕಳುಹಿಸುತ್ತೀರಿ, ಬೋಟ್ ಸಂದೇಶವನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ, ನೀವು ಸಂಖ್ಯೆಯ ಬದಲಿಗೆ ಕೆಲವು ಪಠ್ಯವನ್ನು ಕಳುಹಿಸಿದರೆ, ಅದು ಹೇಳುತ್ತದೆ: Ты ввёл некорректные данные, введи число, ಮತ್ತು ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಮರು-ನಮೂದಿಸಲು ನೀವು ನಿರೀಕ್ಷಿಸುತ್ತೀರಿ. ನೀವು ಸಂಖ್ಯೆಯನ್ನು ಕಳುಹಿಸಿದರೆ, ಅದು ನಿಮ್ಮ ವಯಸ್ಸನ್ನು ಒಪ್ಪಿಕೊಂಡಿದೆ ಎಂದು ಬೋಟ್ ವರದಿ ಮಾಡುತ್ತದೆ, ಸ್ವೀಕರಿಸಿದ ಡೇಟಾವನ್ನು ಡೇಟಾಬೇಸ್‌ಗೆ ಬರೆಯಿರಿ, ನಿಮ್ಮಿಂದ ಸ್ವೀಕರಿಸಿದ ಎಲ್ಲಾ ಡೇಟಾವನ್ನು ವರದಿ ಮಾಡಿ ಮತ್ತು ಚಾಟ್ ಸ್ಥಿತಿಯನ್ನು ಅದರ ಮೂಲ ಸ್ಥಾನಕ್ಕೆ ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಅಂದರೆ. ವಿ 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(), ಚಾಟ್‌ನ ಪ್ರಸ್ತುತ ಸ್ಥಿತಿಯನ್ನು ವಿನಂತಿಸಲು. ಈ ಕಾರ್ಯಕ್ಕೆ ಕೇವಲ 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): ಬೋಟ್‌ನೊಂದಿಗೆ ಸ್ಥಿರವಾದ, ತಾರ್ಕಿಕ ಸಂವಾದವನ್ನು ನಿರ್ಮಿಸುವುದು