ਜੇਕਰ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਪਿਛਲੇ ਪੜ੍ਹ ਚੁੱਕੇ ਹੋ ਤਿੰਨ ਲੇਖ ਇਸ ਲੜੀ ਤੋਂ, ਫਿਰ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਜਾਣਦੇ ਹੋ ਕਿ ਕੀਬੋਰਡ ਨਾਲ ਪੂਰੇ ਟੈਲੀਗ੍ਰਾਮ ਬੋਟਾਂ ਨੂੰ ਕਿਵੇਂ ਲਿਖਣਾ ਹੈ।

ਇਸ ਲੇਖ ਵਿਚ, ਅਸੀਂ ਸਿਖਾਂਗੇ ਕਿ ਇਕ ਬੋਟ ਕਿਵੇਂ ਲਿਖਣਾ ਹੈ ਜੋ ਇਕਸਾਰ ਸੰਵਾਦ ਕਾਇਮ ਰੱਖੇਗਾ। ਉਹ. ਬੋਟ ਤੁਹਾਨੂੰ ਸਵਾਲ ਪੁੱਛੇਗਾ ਅਤੇ ਤੁਹਾਡੇ ਕੁਝ ਜਾਣਕਾਰੀ ਦਾਖਲ ਕਰਨ ਦੀ ਉਡੀਕ ਕਰੇਗਾ। ਤੁਹਾਡੇ ਦੁਆਰਾ ਦਾਖਲ ਕੀਤੇ ਗਏ ਡੇਟਾ 'ਤੇ ਨਿਰਭਰ ਕਰਦਿਆਂ, ਬੋਟ ਕੁਝ ਕਾਰਵਾਈਆਂ ਕਰੇਗਾ।

ਇਸ ਲੇਖ ਵਿੱਚ ਅਸੀਂ ਇਹ ਵੀ ਸਿਖਾਂਗੇ ਕਿ ਬੋਟ ਦੇ ਹੁੱਡ ਦੇ ਹੇਠਾਂ ਇੱਕ ਡੇਟਾਬੇਸ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ, ਸਾਡੀ ਉਦਾਹਰਣ ਵਿੱਚ ਇਹ SQLite ਹੋਵੇਗਾ, ਪਰ ਤੁਸੀਂ ਕਿਸੇ ਹੋਰ DBMS ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਮੈਂ ਵਿੱਚ ਆਰ ਭਾਸ਼ਾ ਵਿੱਚ ਡੇਟਾਬੇਸ ਨਾਲ ਗੱਲਬਾਤ ਕਰਨ ਬਾਰੇ ਵਧੇਰੇ ਵਿਸਥਾਰ ਵਿੱਚ ਲਿਖਿਆ ਇਸ ਲੇਖ.

ਲੜੀ ਦੇ ਸਾਰੇ ਲੇਖ “R ਵਿੱਚ ਟੈਲੀਗ੍ਰਾਮ ਬੋਟ ਲਿਖਣਾ”

1. ਅਸੀਂ ਇੱਕ ਬੋਟ ਬਣਾਉਂਦੇ ਹਾਂ ਅਤੇ ਇਸਨੂੰ ਟੈਲੀਗ੍ਰਾਮ ਵਿੱਚ ਸੰਦੇਸ਼ ਭੇਜਣ ਲਈ ਵਰਤਦੇ ਹਾਂ
2. ਬੋਟ ਵਿੱਚ ਕਮਾਂਡ ਸਹਾਇਤਾ ਅਤੇ ਸੁਨੇਹਾ ਫਿਲਟਰ ਸ਼ਾਮਲ ਕਰੋ
3. ਇੱਕ ਬੋਟ ਵਿੱਚ ਕੀਬੋਰਡ ਸਮਰਥਨ ਕਿਵੇਂ ਜੋੜਨਾ ਹੈ
4. ਬੋਟ ਨਾਲ ਇਕਸਾਰ, ਤਰਕਪੂਰਨ ਸੰਵਾਦ ਬਣਾਉਣਾ

ਸਮੱਗਰੀ

ਜੇ ਤੁਸੀਂ ਡੇਟਾ ਵਿਸ਼ਲੇਸ਼ਣ ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਮੇਰੇ ਵਿੱਚ ਦਿਲਚਸਪੀ ਹੋ ਸਕਦੀ ਹੈ ਤਾਰ и YouTube ਚੈਨਲ। ਜ਼ਿਆਦਾਤਰ ਸਮੱਗਰੀ ਆਰ ਭਾਸ਼ਾ ਨੂੰ ਸਮਰਪਿਤ ਹੈ।

1. ਜਾਣ ਪਛਾਣ
2. ਬੋਟ ਬਣਾਉਣ ਦੀ ਪ੍ਰਕਿਰਿਆ
3. ਬੋਟ ਪ੍ਰੋਜੈਕਟ ਬਣਤਰ
4. ਬੋਟ ਸੰਰਚਨਾ
5. ਇੱਕ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਬਣਾਓ
6. ਇੱਕ ਡਾਟਾਬੇਸ ਬਣਾਉਣਾ
7. ਡਾਟਾਬੇਸ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ ਲਿਖਣਾ
8. ਬੋਟ ਢੰਗ
9. ਸੁਨੇਹਾ ਫਿਲਟਰ
10. ਹੈਂਡਲਰ
11. ਬੋਟ ਲਾਂਚ ਕੋਡ
12. ਸਿੱਟਾ

ਜਾਣ ਪਛਾਣ

ਬੋਟ ਨੂੰ ਤੁਹਾਡੇ ਤੋਂ ਡੇਟਾ ਦੀ ਬੇਨਤੀ ਕਰਨ ਅਤੇ ਤੁਹਾਡੇ ਦੁਆਰਾ ਕੋਈ ਜਾਣਕਾਰੀ ਦਰਜ ਕਰਨ ਦੀ ਉਡੀਕ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਸੰਵਾਦ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਨੂੰ ਰਿਕਾਰਡ ਕਰਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ। ਅਜਿਹਾ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਤਰੀਕਾ ਹੈ ਕਿਸੇ ਕਿਸਮ ਦੇ ਏਮਬੈਡਡ ਡੇਟਾਬੇਸ ਦੀ ਵਰਤੋਂ ਕਰਨਾ, ਜਿਵੇਂ ਕਿ SQLite.

ਉਹ. ਤਰਕ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਹੋਵੇਗਾ। ਅਸੀਂ ਬੋਟ ਵਿਧੀ ਨੂੰ ਕਾਲ ਕਰਦੇ ਹਾਂ, ਅਤੇ ਬੋਟ ਕ੍ਰਮਵਾਰ ਸਾਡੇ ਤੋਂ ਕੁਝ ਜਾਣਕਾਰੀ ਦੀ ਬੇਨਤੀ ਕਰਦਾ ਹੈ, ਅਤੇ ਹਰ ਪੜਾਅ 'ਤੇ ਇਹ ਇਸ ਜਾਣਕਾਰੀ ਦੇ ਦਾਖਲ ਹੋਣ ਦੀ ਉਡੀਕ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸਦੀ ਜਾਂਚ ਕਰ ਸਕਦਾ ਹੈ।

ਅਸੀਂ ਸਭ ਤੋਂ ਸਰਲ ਸੰਭਵ ਬੋਟ ਲਿਖਾਂਗੇ, ਪਹਿਲਾਂ ਇਹ ਤੁਹਾਡਾ ਨਾਮ ਪੁੱਛੇਗਾ, ਫਿਰ ਤੁਹਾਡੀ ਉਮਰ, ਅਤੇ ਪ੍ਰਾਪਤ ਕੀਤੇ ਡੇਟਾ ਨੂੰ ਡੇਟਾਬੇਸ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕਰੇਗਾ। ਉਮਰ ਬਾਰੇ ਪੁੱਛਣ 'ਤੇ, ਇਹ ਜਾਂਚ ਕਰੇਗਾ ਕਿ ਦਾਖਲ ਕੀਤਾ ਡੇਟਾ ਇੱਕ ਨੰਬਰ ਹੈ ਨਾ ਕਿ ਟੈਕਸਟ।

ਅਜਿਹੇ ਸਧਾਰਨ ਸੰਵਾਦ ਦੇ ਸਿਰਫ ਤਿੰਨ ਰਾਜ ਹੋਣਗੇ:

1. ਸ਼ੁਰੂਆਤ ਬੋਟ ਦੀ ਆਮ ਸਥਿਤੀ ਹੈ, ਜਿਸ ਵਿੱਚ ਇਹ ਤੁਹਾਡੇ ਤੋਂ ਕਿਸੇ ਜਾਣਕਾਰੀ ਦੀ ਉਮੀਦ ਨਹੀਂ ਕਰਦਾ ਹੈ
2. ਉਡੀਕ_ਨਾਮ - ਉਹ ਸਥਿਤੀ ਜਿਸ ਵਿੱਚ ਬੋਟ ਇੱਕ ਨਾਮ ਦਰਜ ਕੀਤੇ ਜਾਣ ਦੀ ਉਡੀਕ ਕਰਦਾ ਹੈ
3. wait_age ਉਹ ਅਵਸਥਾ ਹੈ ਜਿਸ ਵਿੱਚ ਬੋਟ ਤੁਹਾਡੀ ਉਮਰ ਦੇ ਦਾਖਲ ਹੋਣ ਦੀ ਉਡੀਕ ਕਰਦਾ ਹੈ, ਪੂਰੇ ਸਾਲਾਂ ਦੀ ਸੰਖਿਆ।

ਬੋਟ ਬਣਾਉਣ ਦੀ ਪ੍ਰਕਿਰਿਆ

ਲੇਖ ਦੇ ਦੌਰਾਨ, ਅਸੀਂ ਕਦਮ-ਦਰ-ਕਦਮ ਇੱਕ ਬੋਟ ਬਣਾਵਾਂਗੇ; ਪੂਰੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਯੋਜਨਾਬੱਧ ਰੂਪ ਵਿੱਚ ਹੇਠਾਂ ਦਰਸਾਇਆ ਜਾ ਸਕਦਾ ਹੈ:

1. ਅਸੀਂ ਇੱਕ ਬੋਟ ਸੰਰਚਨਾ ਬਣਾਉਂਦੇ ਹਾਂ ਜਿਸ ਵਿੱਚ ਅਸੀਂ ਕੁਝ ਸੈਟਿੰਗਾਂ ਨੂੰ ਸਟੋਰ ਕਰਾਂਗੇ। ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਬੋਟ ਟੋਕਨ, ਅਤੇ ਡੇਟਾਬੇਸ ਫਾਈਲ ਦਾ ਮਾਰਗ.
2. ਅਸੀਂ ਇੱਕ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਬਣਾਉਂਦੇ ਹਾਂ ਜਿਸ ਵਿੱਚ ਬੋਟ ਦੇ ਨਾਲ ਪ੍ਰੋਜੈਕਟ ਦਾ ਮਾਰਗ ਸਟੋਰ ਕੀਤਾ ਜਾਵੇਗਾ।
3. ਅਸੀਂ ਖੁਦ ਡੇਟਾਬੇਸ ਬਣਾਉਂਦੇ ਹਾਂ, ਅਤੇ ਕਈ ਫੰਕਸ਼ਨ ਤਾਂ ਜੋ ਬੋਟ ਇਸ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰ ਸਕੇ।
4. ਅਸੀਂ ਬੋਟ ਵਿਧੀਆਂ ਲਿਖਦੇ ਹਾਂ, ਯਾਨੀ. ਫੰਕਸ਼ਨ ਜੋ ਇਹ ਕਰੇਗਾ।
5. ਸੁਨੇਹਾ ਫਿਲਟਰ ਜੋੜ ਰਿਹਾ ਹੈ। ਜਿਸ ਦੀ ਮਦਦ ਨਾਲ ਬੋਟ ਚੈਟ ਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਦੇ ਆਧਾਰ 'ਤੇ ਜ਼ਰੂਰੀ ਤਰੀਕਿਆਂ ਤੱਕ ਪਹੁੰਚ ਕਰੇਗਾ।
6. ਅਸੀਂ ਹੈਂਡਲਰ ਜੋੜਦੇ ਹਾਂ ਜੋ ਜ਼ਰੂਰੀ ਬੋਟ ਤਰੀਕਿਆਂ ਨਾਲ ਕਮਾਂਡਾਂ ਅਤੇ ਸੰਦੇਸ਼ਾਂ ਨੂੰ ਜੋੜਨਗੇ।
7. ਆਉ ਬੋਟ ਨੂੰ ਲਾਂਚ ਕਰੀਏ।

ਬੋਟ ਪ੍ਰੋਜੈਕਟ ਬਣਤਰ

ਸਹੂਲਤ ਲਈ, ਅਸੀਂ ਆਪਣੇ ਬੋਟ ਦੇ ਕੋਡ ਅਤੇ ਹੋਰ ਸੰਬੰਧਿਤ ਫਾਈਲਾਂ ਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਢਾਂਚੇ ਵਿੱਚ ਵੰਡਾਂਗੇ।

• ਬੋਟ.ਆਰ - ਸਾਡੇ ਬੋਟ ਦਾ ਮੁੱਖ ਕੋਡ
• db_bot_function.R - ਡੇਟਾਬੇਸ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨਾਂ ਵਾਲਾ ਕੋਡ ਦਾ ਇੱਕ ਬਲਾਕ
• bot_methods.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
);

ਜੇਕਰ ਤੁਸੀਂ ਬੋਟ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਇਸ ਤੋਂ ਡਾਊਨਲੋਡ ਕੀਤਾ ਹੈ 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 ਤਰੀਕੇ ਬਣਾਏ:

• start — ਇੱਕ ਡਾਇਲਾਗ ਸ਼ੁਰੂ ਕਰੋ
• ਰਾਜ - ਮੌਜੂਦਾ ਚੈਟ ਸਥਿਤੀ ਪ੍ਰਾਪਤ ਕਰੋ
• ਰੀਸੈਟ - ਮੌਜੂਦਾ ਚੈਟ ਸਥਿਤੀ ਨੂੰ ਰੀਸੈਟ ਕਰੋ
• enter_name — ਬੋਟ ਤੁਹਾਡਾ ਨਾਮ ਪੁੱਛਦਾ ਹੈ
• enter_age — ਬੋਟ ਤੁਹਾਡੀ ਉਮਰ ਪੁੱਛਦਾ ਹੈ

.ੰਗ start ਤੁਹਾਡਾ ਨਾਮ ਪੁੱਛਦਾ ਹੈ, ਅਤੇ ਚੈਟ ਸਥਿਤੀ ਨੂੰ ਇਸ ਵਿੱਚ ਬਦਲਦਾ ਹੈ ਉਡੀਕ_ਨਾਮ, i.e. ਤੁਹਾਡਾ ਨਾਮ ਦਰਜ ਕਰਨ ਲਈ ਸਟੈਂਡਬਾਏ ਹੋਣ ਲਈ।

ਅੱਗੇ, ਤੁਸੀਂ ਨਾਮ ਭੇਜਦੇ ਹੋ ਅਤੇ ਇਹ ਵਿਧੀ ਦੁਆਰਾ ਪ੍ਰਕਿਰਿਆ ਕੀਤੀ ਜਾਂਦੀ ਹੈ enter_name, ਬੋਟ ਤੁਹਾਨੂੰ ਸ਼ੁਭਕਾਮਨਾਵਾਂ ਦਿੰਦਾ ਹੈ, ਪ੍ਰਾਪਤ ਹੋਏ ਨਾਮ ਨੂੰ ਡੇਟਾਬੇਸ ਵਿੱਚ ਲਿਖਦਾ ਹੈ, ਅਤੇ ਚੈਟ ਨੂੰ ਸਟੇਟ ਵਿੱਚ ਬਦਲਦਾ ਹੈ ਉਡੀਕ_ਉਮਰ.

ਇਸ ਪੜਾਅ 'ਤੇ, ਬੋਟ ਤੁਹਾਡੇ ਤੋਂ ਤੁਹਾਡੀ ਉਮਰ ਵਿੱਚ ਦਾਖਲ ਹੋਣ ਦੀ ਉਮੀਦ ਕਰਦਾ ਹੈ। ਤੁਸੀਂ ਆਪਣੀ ਉਮਰ ਭੇਜਦੇ ਹੋ, ਬੋਟ ਸੰਦੇਸ਼ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ, ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਨੰਬਰ ਦੀ ਬਜਾਏ ਕੁਝ ਟੈਕਸਟ ਭੇਜਿਆ ਹੈ, ਤਾਂ ਇਹ ਕਹੇਗਾ: Ты ввёл некорректные данные, введи число, ਅਤੇ ਤੁਹਾਡੇ ਡੇਟਾ ਨੂੰ ਦੁਬਾਰਾ ਦਰਜ ਕਰਨ ਦੀ ਉਡੀਕ ਕਰੇਗਾ। ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਨੰਬਰ ਭੇਜਿਆ ਹੈ, ਤਾਂ ਬੋਟ ਰਿਪੋਰਟ ਕਰੇਗਾ ਕਿ ਉਸਨੇ ਤੁਹਾਡੀ ਉਮਰ ਨੂੰ ਸਵੀਕਾਰ ਕਰ ਲਿਆ ਹੈ, ਪ੍ਰਾਪਤ ਡੇਟਾ ਨੂੰ ਡੇਟਾਬੇਸ ਵਿੱਚ ਲਿਖੋ, ਤੁਹਾਡੇ ਤੋਂ ਪ੍ਰਾਪਤ ਕੀਤੇ ਸਾਰੇ ਡੇਟਾ ਦੀ ਰਿਪੋਰਟ ਕਰੋ ਅਤੇ ਚੈਟ ਸਥਿਤੀ ਨੂੰ ਇਸਦੀ ਅਸਲ ਸਥਿਤੀ ਵਿੱਚ ਵਾਪਸ ਕਰੋ, ਜਿਵੇਂ ਕਿ. ਵੀ start.

ਵਿਧੀ ਨੂੰ ਬੁਲਾ ਕੇ state ਤੁਸੀਂ ਕਿਸੇ ਵੀ ਸਮੇਂ ਮੌਜੂਦਾ ਚੈਟ ਸਥਿਤੀ ਦੀ ਬੇਨਤੀ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਵਰਤ ਕੇ reset ਚੈਟ ਨੂੰ ਇਸਦੀ ਅਸਲ ਸਥਿਤੀ ਵਿੱਚ ਵਾਪਸ ਕਰੋ।

ਸੁਨੇਹਾ ਫਿਲਟਰ

ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਇਹ ਇੱਕ ਬੋਟ ਬਣਾਉਣ ਵਿੱਚ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਭਾਗਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ. ਇਹ ਸੁਨੇਹਾ ਫਿਲਟਰਾਂ ਦੀ ਮਦਦ ਨਾਲ ਹੈ ਕਿ ਬੋਟ ਸਮਝੇਗਾ ਕਿ ਉਹ ਤੁਹਾਡੇ ਤੋਂ ਕਿਹੜੀ ਜਾਣਕਾਰੀ ਦੀ ਉਮੀਦ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸ 'ਤੇ ਕਿਵੇਂ ਕਾਰਵਾਈ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ।

'ਤੇ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ GitHub ਫਿਲਟਰ ਫਾਈਲ ਵਿੱਚ ਦਰਜ ਹਨ ਸੁਨੇਹਾ_ਫਿਲਟਰ.ਆਰ.

ਸੁਨੇਹਾ ਫਿਲਟਰ ਕੋਡ:

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