blazegram 0.4.2

Telegram bot framework: clean chats, zero garbage, declarative screens, pure Rust MTProto.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

//! Conversation bot — demonstrates branching conversations.
//!
//! A simple onboarding flow that branches based on user role.

use std::sync::Arc;

use blazegram::{handler, prelude::*};

#[tokio::main]
async fn main() {
    tracing_subscriber::fmt::init();

    let onboarding = Conversation::builder("onboarding")
        .step(
            "name",
            |_data, _lang| Screen::text("conv_name", "👋 What's your name?").build(),
            None,
        )
        .step(
            "role",
            |_data, _lang| {
                Screen::text("conv_role", "Are you a *student* or *teacher*?")
                    .keyboard(|kb| kb.button("Student", "student").button("Teacher", "teacher"))
                    .build()
            },
            None,
        )
        .branch(
            "role",
            Arc::new(|data| match data.get("role").and_then(|v| v.as_str()) {
                Some("student") => "student_year".to_string(),
                _ => "teacher_subject".to_string(),
            }),
        )
        .step(
            "student_year",
            |_data, _lang| Screen::text("conv_year", "📚 What year are you in?").build(),
            None,
        )
        .step(
            "teacher_subject",
            |_data, _lang| Screen::text("conv_subject", "📖 What subject do you teach?").build(),
            None,
        )
        .end_at("student_year")
        .end_at("teacher_subject")
        .on_complete(Arc::new(|ctx, data| {
            Box::pin(async move {
                let name = data.get("name").and_then(|v| v.as_str()).unwrap_or("?");
                let role = data.get("role").and_then(|v| v.as_str()).unwrap_or("?");
                let text = format!("✅ Welcome, {} ({}). All set!", name, role);
                ctx.navigate(Screen::text("done", text).build()).await
            })
        }))
        .build()
        .expect("valid conversation");

    App::builder(std::env::var("BOT_TOKEN").expect("BOT_TOKEN"))
        .conversation(onboarding)
        .command("start", handler!(ctx => {
            ctx.navigate(Screen::text("home", "Welcome! Type /onboard to begin.").build()).await
        }))
        .command("onboard", handler!(ctx => {
            // NOTE: In a real app you'd pass the conversations map.
            // Here we just set the state manually for demonstration.
            ctx.set("__conv_id", &"onboarding".to_string());
            ctx.set("__conv_step", &0usize);
            ctx.set("__conv_data", &std::collections::HashMap::<String, serde_json::Value>::new());
            ctx.navigate(Screen::text("conv_name", "👋 What's your name?").build()).await
        }))
        .run()
        .await;
}