Merge examples/sqlite_remember.rs with redis_remember.rs

Cargo.toml

@@ -128,17 +128,13 @@ required-features = ["sqlite-storage", "cbor-serializer", "bincode-serializer"]
 name = "dialogue"
 required-features = ["macros"]
 
-[[example]]
-name = "sqlite_remember"
-required-features = ["sqlite-storage", "bincode-serializer", "redis-storage", "macros"]
-
 [[example]]
 name = "simple_commands"
 required-features = ["macros"]
 
 [[example]]
-name = "redis_remember"
+name = "db_remember"
-required-features = ["redis-storage", "bincode-serializer", "macros"]
+required-features = ["sqlite-storage", "redis-storage", "bincode-serializer", "macros"]
 
 [[example]]
 name = "inline"

examples/db_remember.rs

@@ -1,24 +1,9 @@
-use teloxide::{
+use teloxide::{macros::DialogueState, prelude2::*, types::Me, utils::command::BotCommand};
-    dispatching2::dialogue::{serializer::Json, SqliteStorage, Storage},
-    macros::DialogueState,
-    prelude2::*,
-    types::Me,
-    utils::command::BotCommand,
-    RequestError,
-};
-use thiserror::Error;
 
-type MyDialogue = Dialogue<State, SqliteStorage<Json>>;
+// include!("redis_config.in");
-type StorageError = <SqliteStorage<Json> as Storage<State>>::Error;
+include!("sqlite_config.in");
 
-#[derive(Debug, Error)]
+type MyDialogue = Dialogue<State, MyStorage>;
-enum Error {
-    #[error("error from Telegram: {0}")]
-    TelegramError(#[from] RequestError),
-
-    #[error("error from storage: {0}")]
-    StorageError(#[from] StorageError),
-}
 
 #[derive(DialogueState, Clone, serde::Serialize, serde::Deserialize)]
 #[handler_out(anyhow::Result<()>)]
@@ -48,10 +33,10 @@ pub enum Command {
 #[tokio::main]
 async fn main() {
     let bot = Bot::from_env().auto_send();
-    let storage = SqliteStorage::open("db.sqlite", Json).await.unwrap();
 
+    let storage = open_storage().await;
     let handler = Update::filter_message()
-        .enter_dialogue::<Message, SqliteStorage<Json>, State>()
+        .enter_dialogue::<Message, MyStorage, State>()
         .dispatch_by::<State>();
 
     Dispatcher::builder(bot, handler)

examples/redis_config.in

@@ -0,0 +1,7 @@
+use teloxide::dispatching2::dialogue::{RedisStorage, serializer::Bincode};
+
+type MyStorage = RedisStorage<Bincode>;
+
+async fn open_storage() -> std::sync::Arc<MyStorage> {
+    RedisStorage::open("redis://127.0.0.1:6379", Bincode).await.unwrap()
+}

examples/redis_remember.rs

@@ -1,116 +0,0 @@
-use teloxide::{
-    dispatching2::dialogue::{serializer::Bincode, RedisStorage, Storage},
-    macros::DialogueState,
-    prelude2::*,
-    types::Me,
-    utils::command::BotCommand,
-    RequestError,
-};
-use thiserror::Error;
-
-type MyDialogue = Dialogue<State, RedisStorage<Bincode>>;
-type StorageError = <RedisStorage<Bincode> as Storage<State>>::Error;
-
-#[derive(Debug, Error)]
-enum Error {
-    #[error("error from Telegram: {0}")]
-    TelegramError(#[from] RequestError),
-
-    #[error("error from storage: {0}")]
-    StorageError(#[from] StorageError),
-}
-
-#[derive(DialogueState, Clone, serde::Serialize, serde::Deserialize)]
-#[handler_out(anyhow::Result<()>)]
-pub enum State {
-    #[handler(handle_start)]
-    Start,
-
-    #[handler(handle_got_number)]
-    GotNumber(i32),
-}
-
-impl Default for State {
-    fn default() -> Self {
-        Self::Start
-    }
-}
-
-#[derive(BotCommand)]
-#[command(rename = "lowercase", description = "These commands are supported:")]
-pub enum Command {
-    #[command(description = "get your number.")]
-    Get,
-    #[command(description = "reset your number.")]
-    Reset,
-}
-#[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 = Update::filter_message()
-        .enter_dialogue::<Message, RedisStorage<Bincode>, State>()
-        .dispatch_by::<State>();
-
-    Dispatcher::builder(bot, handler)
-        .dependencies(dptree::deps![storage])
-        .build()
-        .setup_ctrlc_handler()
-        .dispatch()
-        .await;
-}
-
-async fn handle_start(
-    bot: AutoSend<Bot>,
-    msg: Message,
-    dialogue: MyDialogue,
-) -> anyhow::Result<()> {
-    match msg.text().unwrap().parse() {
-        Ok(number) => {
-            dialogue.update(State::GotNumber(number)).await?;
-            bot.send_message(
-                msg.chat.id,
-                format!("Remembered number {}. Now use /get or /reset", number),
-            )
-            .await?;
-        }
-        _ => {
-            bot.send_message(msg.chat.id, "Please, send me a number").await?;
-        }
-    }
-
-    Ok(())
-}
-
-async fn handle_got_number(
-    bot: AutoSend<Bot>,
-    msg: Message,
-    dialogue: MyDialogue,
-    num: i32,
-    me: Me,
-) -> anyhow::Result<()> {
-    let ans = msg.text().unwrap();
-    let bot_name = me.user.username.unwrap();
-
-    match Command::parse(ans, bot_name) {
-        Ok(cmd) => match cmd {
-            Command::Get => {
-                bot.send_message(msg.chat.id, format!("Here is your number: {}", num)).await?;
-            }
-            Command::Reset => {
-                dialogue.reset().await?;
-                bot.send_message(msg.chat.id, "Number resetted").await?;
-            }
-        },
-        Err(_) => {
-            bot.send_message(msg.chat.id, "Please, send /get or /reset").await?;
-        }
-    }
-
-    Ok(())
-}

examples/sqlite_config.in

@@ -0,0 +1,7 @@
+use teloxide::dispatching2::dialogue::{SqliteStorage, serializer::Json};
+
+type MyStorage = SqliteStorage<Json>;
+
+async fn open_storage() -> std::sync::Arc<MyStorage> {
+    SqliteStorage::open("db.sqlite", Json).await.unwrap()
+}