Refactor

src/bots/approved_bot/mod.rs

@@ -20,18 +20,17 @@ use super::{ignore_channel_messages, BotCommands, BotHandler, bots_manager::get_
 
 async fn _update_activity(me: teloxide::types::Me, user: teloxide::types::User) -> Option<()> {
     tokio::spawn(async move {
-        if let Err(_) = update_user_activity(user.id).await {
+        if update_user_activity(user.id).await.is_err() {
             let allowed_langs = get_user_or_default_lang_codes(user.id).await;
 
-            if let Ok(_) = create_or_update_user_settings(
+            if create_or_update_user_settings(
                 user.id,
                 user.last_name.clone().unwrap_or("".to_string()),
                 user.first_name.clone(),
                 user.username.clone().unwrap_or("".to_string()),
                 me.username.clone().unwrap(),
                 allowed_langs,
-            )
-            .await
+            ).await.is_ok()
             {
                 #[allow(unused_must_use)]
                 {

src/bots/approved_bot/modules/download.rs

@@ -100,15 +100,13 @@ async fn _send_downloaded_file(
 
     let document: InputFile = InputFile::read(data).file_name(filename);
 
-    match bot
+    bot
         .send_document(message.chat.id, document)
         .caption(caption)
         .send()
-        .await
-    {
-        Ok(_) => Ok(()),
-        Err(err) => Err(Box::new(err)),
-    }
+        .await?;
+
+    Ok(())
 }
 
 async fn send_with_download_from_channel(

src/bots/approved_bot/modules/settings.rs

@@ -25,17 +25,17 @@ enum SettingsCommand {
 
 #[derive(Clone)]
 enum SettingsCallbackData {
-    LangSettings,
-    LangOn { code: String },
-    LangOff { code: String },
+    Settings,
+    On { code: String },
+    Off { code: String },
 }
 
 impl FromStr for SettingsCallbackData {
     type Err = strum::ParseError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        if s == SettingsCallbackData::LangSettings.to_string().as_str() {
-            return Ok(SettingsCallbackData::LangSettings);
+        if s == SettingsCallbackData::Settings.to_string().as_str() {
+            return Ok(SettingsCallbackData::Settings);
         }
 
         let re = Regex::new(r"^lang_(?P<action>(off)|(on))_(?P<code>[a-zA-z]+)$").unwrap();
@@ -50,8 +50,8 @@ impl FromStr for SettingsCallbackData {
         let code = caps["code"].to_string();
 
         match action {
-            "on" => Ok(SettingsCallbackData::LangOn { code }),
-            "off" => Ok(SettingsCallbackData::LangOff { code }),
+            "on" => Ok(SettingsCallbackData::On { code }),
+            "off" => Ok(SettingsCallbackData::Off { code }),
             _ => Err(strum::ParseError::VariantNotFound),
         }
     }
@@ -60,9 +60,9 @@ impl FromStr for SettingsCallbackData {
 impl ToString for SettingsCallbackData {
     fn to_string(&self) -> String {
         match self {
-            SettingsCallbackData::LangSettings => "lang_settings".to_string(),
-            SettingsCallbackData::LangOn { code } => format!("lang_on_{code}"),
-            SettingsCallbackData::LangOff { code } => format!("lang_off_{code}"),
+            SettingsCallbackData::Settings => "lang_settings".to_string(),
+            SettingsCallbackData::On { code } => format!("lang_on_{code}"),
+            SettingsCallbackData::Off { code } => format!("lang_off_{code}"),
         }
     }
 }
@@ -72,7 +72,7 @@ async fn settings_handler(message: Message, bot: CacheMe<Throttle<Bot>>) -> BotH
         inline_keyboard: vec![vec![InlineKeyboardButton {
             text: "Языки".to_string(),
             kind: teloxide::types::InlineKeyboardButtonKind::CallbackData(
-                SettingsCallbackData::LangSettings.to_string(),
+                SettingsCallbackData::Settings.to_string(),
             ),
         }]],
     };
@@ -95,11 +95,11 @@ fn get_lang_keyboard(all_langs: Vec<Lang>, allowed_langs: HashSet<String>) -> In
             let (emoji, callback_data) = match allowed_langs.contains(&lang.code) {
                 true => (
                     "🟢".to_string(),
-                    SettingsCallbackData::LangOff { code: lang.code }.to_string(),
+                    SettingsCallbackData::Off { code: lang.code }.to_string(),
                 ),
                 false => (
                     "🔴".to_string(),
-                    SettingsCallbackData::LangOn { code: lang.code }.to_string(),
+                    SettingsCallbackData::On { code: lang.code }.to_string(),
                 ),
             };
 
@@ -141,11 +141,11 @@ async fn settings_callback_handler(
     });
 
     match callback_data {
-        SettingsCallbackData::LangSettings => (),
-        SettingsCallbackData::LangOn { code } => {
+        SettingsCallbackData::Settings => (),
+        SettingsCallbackData::On { code } => {
             allowed_langs_set.insert(code);
         }
-        SettingsCallbackData::LangOff { code } => {
+        SettingsCallbackData::Off { code } => {
             allowed_langs_set.remove(&code);
         }
     };

src/bots/approved_bot/services/book_library/mod.rs

@@ -49,9 +49,8 @@ pub async fn get_random_book_by_genre(
 ) -> Result<types::Book, Box<dyn std::error::Error + Send + Sync>> {
     let mut params: Vec<(&str, String)> = get_allowed_langs_params(allowed_langs);
 
-    match genre {
-        Some(v) => params.push(("genre", v.to_string())),
-        None => (),
+    if let Some(v) = genre {
+        params.push(("genre", v.to_string()));
     }
 
     _make_request("/api/v1/books/random", params).await

src/bots_manager.rs

@@ -139,20 +139,21 @@ impl BotsManager {
         true
     }
 
+    async fn sd_token(token: &ShutdownToken) {
+        for _ in 1..10 {
+            if let Ok(v) = token.clone().shutdown() { return v.await }
+
+            sleep(Duration::from_millis(100)).await;
+        }
+    }
+
     async fn stop_bot(&mut self, bot_id: u32) {
         let shutdown_token = match self.bot_shutdown_token_map.remove(&bot_id) {
             Some(v) => v,
             None => return,
         };
 
-        for _ in 1..100 {
-            match shutdown_token.clone().shutdown() {
-                Ok(v) => return v.await,
-                Err(_) => (),
-            };
-
-            sleep(Duration::from_millis(100)).await;
-        }
+        BotsManager::sd_token(&shutdown_token).await;
     }
 
     async fn update_data(&mut self, bots_data: Vec<BotData>) {
@@ -202,15 +203,7 @@ impl BotsManager {
 
     async fn stop_all(&mut self) {
         for token in self.bot_shutdown_token_map.values() {
-            for _ in 1..100 {
-                match token.clone().shutdown() {
-                    Ok(v) => {
-                        v.await;
-                        break;
-                    }
-                    Err(_) => (),
-                }
-            }
+            BotsManager::sd_token(token).await;
         }
     }