teloxide/examples/redis_remember.rs

use teloxide::{
    dispatching2::dialogue::{serializer::Bincode, RedisStorage, Storage},
    prelude2::*,
    RequestError,
};
use thiserror::Error;

type BotDialogue = Dialogue<DialogueState, RedisStorage<Bincode>>;
type StorageError = <RedisStorage<Bincode> as Storage<DialogueState>>::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 DialogueState {
    Start,
    HaveNumber(i32),
}

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

async fn handle_message(
    bot: AutoSend<Bot>,
    mes: Message,
    dialogue: BotDialogue,
) -> Result<(), Error> {
    match mes.text() {
        None => {
            bot.send_message(mes.chat.id, "Send me a text message.").await?;
        }
        Some(ans) => {
            let state = dialogue.get_or_default().await?;
            match state {
                DialogueState::Start => {
                    if let Ok(number) = ans.parse() {
                        dialogue.update(DialogueState::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?;
                    }
                }
                DialogueState::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 = Bot::from_env().auto_send();
    // You can also choose serializer::JSON or serializer::CBOR
    // All serializers but JSON require enabling feature
    // "serializer-<name>", e. g. "serializer-cbor"
    // or "serializer-bincode"
    let storage = RedisStorage::open("redis://127.0.0.1:6379", Bincode).await.unwrap();

    let handler = dptree::entry()
        .add_dialogue::<Message, RedisStorage<Bincode>, DialogueState>()
        .branch(dptree::endpoint(handle_message));

    DispatcherBuilder::new(bot, handler)
        .dependencies(dptree::deps![storage])
        .build()
        .dispatch()
        .await;
}