Dialogues

[Lucky-49]

Hello everyone I am studying teloxide and trying to implement transitions in various dialog states. I took this exercise as a basis for an example https://github.com/teloxide/teloxide/blob/master/crates/teloxide/examples/purchase.rs
but I added two more dialog states.
After execution fn receive_product_selection the bot should go into the state ReceiveFullName2and execute fn receive_full_name_2, but this is not happening. What am I doing wrong?

use teloxide::{
    dispatching::{dialogue, dialogue::InMemStorage, UpdateHandler},
    prelude::*,
    types::{InlineKeyboardButton, InlineKeyboardMarkup},
    utils::command::BotCommands,
};

type MyDialogue = Dialogue<State, InMemStorage<State>>;
type HandlerResult = Result<(), Box<dyn std::error::Error + Send + Sync>>;

#[derive(Clone, Default)]
pub enum State {
    #[default]
    Start,
    ReceiveFullName,
    ReceiveProductChoice {
        full_name: String,
    },
    ReceiveFullName2,
    AnotherState,
}

/// These commands are supported:
#[derive(BotCommands, Clone)]
#[command(rename_rule = "lowercase")]
enum Command {
    /// Display this text.
    Help,
    /// Start the purchase procedure.
    Start,
    /// Cancel the purchase procedure.
    Cancel,
}

#[tokio::main]
async fn main() {
    pretty_env_logger::init();
    log::info!("Starting purchase bot...");

    let bot = Bot::new(" ");

    Dispatcher::builder(bot, schema())
        .dependencies(dptree::deps![InMemStorage::<State>::new()])
        .enable_ctrlc_handler()
        .build()
        .dispatch()
        .await;
}

fn schema() -> UpdateHandler<Box<dyn std::error::Error + Send + Sync + 'static>> {
    use dptree::case;

    let command_handler = teloxide::filter_command::<Command, _>()
        .branch(
            case![State::Start]
                .branch(case![Command::Help].endpoint(help))
                .branch(case![Command::Start].endpoint(start)),
        )
        .branch(case![Command::Cancel].endpoint(cancel));

    let message_handler = Update::filter_message()
        .branch(command_handler)
        .branch(case![State::ReceiveFullName].endpoint(receive_full_name))
        .branch(dptree::endpoint(invalid_state));

    let callback_query_handler = Update::filter_callback_query().branch(
        case![State::ReceiveProductChoice { full_name }].endpoint(receive_product_selection),
    );

    let message_handler_2 = Update::filter_message()
        .branch(case![State::ReceiveFullName2].endpoint(receive_full_name_2))
        .branch(case![State::AnotherState].endpoint(another_state));

    dialogue::enter::<Update, InMemStorage<State>, State, _>()
        .branch(message_handler)
        .branch(callback_query_handler)
        .branch(message_handler_2)
}

async fn start(bot: Bot, dialogue: MyDialogue, msg: Message) -> HandlerResult {
    bot.send_message(msg.chat.id, "Let's start! What's your full name?")
        .await?;
    dialogue.update(State::ReceiveFullName).await?;
    Ok(())
}

async fn help(bot: Bot, msg: Message) -> HandlerResult {
    bot.send_message(msg.chat.id, Command::descriptions().to_string())
        .await?;
    Ok(())
}

async fn cancel(bot: Bot, dialogue: MyDialogue, msg: Message) -> HandlerResult {
    bot.send_message(msg.chat.id, "Cancelling the dialogue.")
        .await?;
    dialogue.exit().await?;
    Ok(())
}

async fn invalid_state(bot: Bot, msg: Message) -> HandlerResult {
    bot.send_message(
        msg.chat.id,
        "Unable to handle the message. Type /help to see the usage.",
    )
    .await?;
    Ok(())
}

async fn receive_full_name(bot: Bot, dialogue: MyDialogue, msg: Message) -> HandlerResult {
    match msg.text().map(ToOwned::to_owned) {
        Some(full_name) => {
            let products = ["Apple", "Banana", "Orange", "Potato"]
                .map(|product| InlineKeyboardButton::callback(product, product));
            bot.send_message(msg.chat.id, "select a product")
                .reply_markup(InlineKeyboardMarkup::new([products]))
                .await?;
            dialogue
                .update(State::ReceiveProductChoice { full_name })
                .await?;
        }
        None => {
            bot.send_message(msg.chat.id, "Please, send me your full name.")
                .await?;
        }
    }

    Ok(())
}

async fn receive_product_selection(
    bot: Bot,
    dialogue: MyDialogue,
    full_name: String, // Available from `State::ReceiveProductChoice`.
    q: CallbackQuery,
) -> HandlerResult {
    if let Some(product) = &q.data {
        bot.send_message(
            dialogue.chat_id(),
            format!("{full_name}, product '{product}' has been purchased successfully!"),
        )
        .await?;
        dialogue.update(State::ReceiveFullName2).await?;
        println!("test")
    }

    Ok(())
}

async fn receive_full_name_2(bot: Bot, dialogue: MyDialogue, msg: Message) -> HandlerResult {
    println!("test_2");
    bot.send_message(msg.chat.id, "test_2");
    match msg.text() {
        Some(text_2) => {
            bot.send_message(msg.chat.id, format!("test_2 text: {}", text_2))
                .await?;
            dialogue.update(State::AnotherState).await?;
        }
        None => {
            bot.send_message(msg.chat.id, "*******").await?;
        }
    }

    Ok(())
}

async fn another_state(bot: Bot, dialogue: MyDialogue, msg: Message) -> HandlerResult {
    println!("test_3");
    bot.send_message(msg.chat.id, "test_3");
    match msg.text() {
        Some(text_3) => {
            bot.send_message(msg.chat.id, format!("test_3 text: {}", text_3))
                .await?;
            dialogue.exit().await?;
        }
        None => {
            bot.send_message(msg.chat.id, "*******").await?;
        }
    }

    Ok(())
}

`

[TheAwiteb]

First of all, revoke your bot token from botfather, don't publish it again, because through it you can fully control the bot.

You already has a message filter, so it will filter all the coming messages, and the one you created will not be considered. So you must add your new cases to it like this

let message_handler = Update::filter_message()
    .branch(command_handler)
    .branch(case![State::ReceiveFullName].endpoint(receive_full_name))
    .branch(case![State::ReceiveFullName2].endpoint(receive_full_name_2))
    .branch(case![State::AnotherState].endpoint(another_state))
    .branch(dptree::endpoint(invalid_state));

And remove your new handler, also you need to await the send message request like this

-bot.send_message(msg.chat.id, "test_2");
+bot.send_message(msg.chat.id, "test_2").await;

Also is better to send a message to the user before update the dialogue state, for example send to the user "Send your second full name" and then update the dialogue.

[Lucky-49]

My friend, thank you very much!!!