teloxide/examples/sqlite_remember_bot/src/main.rs

use teloxide::{
    dispatching2::dialogue::{serializer::Json, SqliteStorage, Storage},
    prelude::*,
    RequestError,
};
use thiserror::Error;
use std::sync::Arc;

type Store = SqliteStorage<Json>;
// FIXME: naming
type MyDialogue = Dialogue<BotDialogue, Store>;
type StorageError = <SqliteStorage<Json> as Storage<BotDialogue>>::Error;

#[derive(Debug, Error)]
enum Error {
    #[error("error from Telegram: {0}")]
    TelegramError(#[from] RequestError),
    #[error("error from storage: {0}")]
    StorageError(#[from] StorageError),
}

#[derive(serde::Serialize, serde::Deserialize)]
pub enum BotDialogue {
    Start,
    HaveNumber(i32),
}

impl Default for BotDialogue {
    fn default() -> Self {
        Self::Start
    }
}

async fn handle_message(
    bot: Arc<AutoSend<Bot>>,
    mes: Arc<Message>,
    dialogue: Arc<MyDialogue>,
) -> Result<(), Error> {
    match mes.text() {
        None => {
            bot.send_message(mes.chat.id, "Send me a text message.").await?;
        }
        Some(ans) => {
            let state = dialogue.current_state_or_default().await?;
            match state {
                BotDialogue::Start => {
                    if let Ok(number) = ans.parse() {
                        dialogue.next(BotDialogue::HaveNumber(number)).await?;
                        bot.send_message(mes.chat.id, format!("Remembered number {}. Now use /get or /reset", number)).await?;
                    } else {
                        bot.send_message(mes.chat.id, "Please, send me a number").await?;
                    }
                }
                BotDialogue::HaveNumber(num) => {
                    if ans.starts_with("/get") {
                        bot.send_message(mes.chat.id, format!("Here is your number: {}", num)).await?;
                    } else if ans.starts_with("/reset") {
                        dialogue.reset().await?;
                        bot.send_message(mes.chat.id, "Resetted number").await?;
                    } else {
                        bot.send_message(mes.chat.id, "Please, send /get or /reset").await?;
                    }
                }
            }
        },
    }
    Ok(())
}

#[tokio::main]
async fn main() {
    let bot = Arc::new(Bot::from_env().auto_send());
    let storage = SqliteStorage::open("db.sqlite", Json).await.unwrap();

    Dispatcher::new(bot)
        .dependencies({
            let mut map = dptree::di::DependencyMap::new();
            map.insert_arc(storage);
            map
        })
        .messages_handler(|h| {
            h.add_dialogue::<Message, Store, BotDialogue>()
                .branch(dptree::endpoint(handle_message))
        })
        .dispatch()
        .await;
}