Update

src/bots/approved_bot/modules/annotations/commands.rs

@@ -13,9 +13,8 @@ impl CommandParse<Self> for AnnotationCommand {
     fn parse(s: &str, bot_name: &str) -> Result<Self, CommandParseError> {
         Regex::new(r"^/(?P<an_type>[ab])_an_(?P<id>\d+)$")
             .unwrap_or_else(|_| panic!("Broken AnnotationCommand regexp!"))
-            .captures(
+            .captures(&s.replace(&format!("@{bot_name}"), ""))
-                &s.replace(&format!("@{bot_name}"), "")
+            .ok_or(CommandParseError)
-            ).ok_or(CommandParseError)
             .map(|caps| (
                 caps["an_type"].to_string(),
                 caps["id"].parse::<u32>().unwrap_or_else(|_| panic!("Can't get id from AnnotationCommand!"))

src/bots/approved_bot/modules/annotations/mod.rs

@@ -32,6 +32,7 @@ async fn download_image(
     Ok(reqwest::get(file).await?.error_for_status()?)
 }
 
+
 pub async fn send_annotation_handler<T, Fut>(
     message: Message,
     bot: CacheMe<Throttle<Bot>>,
@@ -108,6 +109,7 @@ where
     Ok(())
 }
 
+
 pub async fn annotation_pagination_handler<T, Fut>(
     cq: CallbackQuery,
     bot: CacheMe<Throttle<Bot>>,
@@ -158,6 +160,7 @@ where
     Ok(())
 }
 
+
 pub fn get_annotations_handler() -> crate::bots::BotHandler {
     dptree::entry()
         .branch(

src/bots/approved_bot/modules/book/callback_data.rs

@@ -2,7 +2,7 @@ use std::str::FromStr;
 
 use regex::Regex;
 
-use crate::bots::approved_bot::modules::utils::pagination::GetPaginationCallbackData;
+use crate::bots::approved_bot::modules::utils::{pagination::GetPaginationCallbackData, errors::CallbackQueryParseError};
 
 
 #[derive(Clone)]
@@ -13,27 +13,26 @@ pub enum BookCallbackData {
 }
 
 impl FromStr for BookCallbackData {
-    type Err = strum::ParseError;
+    type Err = CallbackQueryParseError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let re = Regex::new(r"^b(?P<an_type>[ats])_(?P<id>\d+)_(?P<page>\d+)$").unwrap();
+        Regex::new(r"^b(?P<an_type>[ats])_(?P<id>\d+)_(?P<page>\d+)$")
-
+            .unwrap_or_else(|_| panic!("Broken BookCallbackData regex pattern!"))
-        let caps = re.captures(s);
+            .captures(s)
-        let caps = match caps {
+            .ok_or(CallbackQueryParseError)
-            Some(v) => v,
+            .map(|caps| (
-            None => return Err(strum::ParseError::VariantNotFound),
+                caps["an_type"].to_string(),
-        };
+                caps["id"].parse::<u32>().unwrap(),
-
+                caps["page"].parse::<u32>().unwrap()
-        let annotation_type = &caps["an_type"];
+            ))
-        let id = caps["id"].parse::<u32>().unwrap();
+            .map(|(annotation_type, id, page)|
-        let page = caps["page"].parse::<u32>().unwrap();
+                match annotation_type.as_str() {
-
+                    "a" => Ok(BookCallbackData::Author { id, page }),
-        match annotation_type {
+                    "t" => Ok(BookCallbackData::Translator { id, page }),
-            "a" => Ok(BookCallbackData::Author { id, page }),
+                    "s" => Ok(BookCallbackData::Sequence { id, page }),
-            "t" => Ok(BookCallbackData::Translator { id, page }),
+                    _ => panic!("Unknown BookCallbackData type: {}!", annotation_type),
-            "s" => Ok(BookCallbackData::Sequence { id, page }),
+                }
-            _ => Err(strum::ParseError::VariantNotFound),
+            )?
-        }
     }
 }
 

src/bots/approved_bot/modules/book/commands.rs

@@ -12,25 +12,21 @@ pub enum BookCommand {
 
 impl CommandParse<Self> for BookCommand {
     fn parse(s: &str, bot_name: &str) -> Result<Self, CommandParseError> {
-        let re = Regex::new(r"^/(?P<an_type>[ats])_(?P<id>\d+)$").unwrap();
+        Regex::new(r"^/(?P<an_type>[ats])_(?P<id>\d+)$")
-
+            .unwrap_or_else(|_| panic!("Broken BookCommand regexp!"))
-        let full_bot_name = format!("@{bot_name}");
+            .captures(&s.replace(&format!("@{bot_name}"), ""))
-        let after_replace = s.replace(&full_bot_name, "");
+            .ok_or(CommandParseError)
-
+            .map(|caps| (
-        let caps = re.captures(&after_replace);
+                caps["an_type"].to_string(),
-        let caps = match caps {
+                caps["id"].parse().unwrap()
-            Some(v) => v,
+            ))
-            None => return Err(CommandParseError),
+            .map(|(annotation_type, id)| {
-        };
+                match annotation_type.as_str() {
-
+                    "a" => Ok(BookCommand::Author { id }),
-        let annotation_type = &caps["an_type"];
+                    "t" => Ok(BookCommand::Translator { id }),
-        let id: u32 = caps["id"].parse().unwrap();
+                    "s" => Ok(BookCommand::Sequence { id }),
-
+                    _ => panic!("Unknown BookCommand type: {}!", annotation_type),
-        match annotation_type {
+                }
-            "a" => Ok(BookCommand::Author { id }),
+            })?
-            "t" => Ok(BookCommand::Translator { id }),
-            "s" => Ok(BookCommand::Sequence { id }),
-            _ => Err(CommandParseError),
-        }
     }
 }

src/bots/approved_bot/modules/download/callback_data.rs

@@ -3,6 +3,8 @@ use std::str::FromStr;
 use regex::Regex;
 use strum_macros::EnumIter;
 
+use crate::bots::approved_bot::modules::utils::errors::CommandParseError;
+
 
 #[derive(Clone, EnumIter)]
 pub enum DownloadQueryData {
@@ -20,21 +22,20 @@ impl ToString for DownloadQueryData {
 }
 
 impl FromStr for DownloadQueryData {
-    type Err = strum::ParseError;
+    type Err = CommandParseError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let re = Regex::new(r"^d_(?P<book_id>\d+)_(?P<file_type>\w+)$").unwrap();
+        Regex::new(r"^d_(?P<book_id>\d+)_(?P<file_type>\w+)$")
-
+            .unwrap_or_else(|_| panic!("Broken DownloadQueryData regexp!"))
-        let caps = re.captures(s);
+            .captures(s)
-        let caps = match caps {
+            .ok_or(CommandParseError)
-            Some(v) => v,
+            .map(|caps| (
-            None => return Err(strum::ParseError::VariantNotFound),
+                caps["book_id"].parse().unwrap(),
-        };
+                caps["file_type"].to_string()
-
+            ))
-        let book_id: u32 = caps["book_id"].parse().unwrap();
+            .map(|(book_id, file_type)| {
-        let file_type: String = caps["file_type"].to_string();
+                DownloadQueryData::DownloadData { book_id, file_type }
-
+            })
-        Ok(DownloadQueryData::DownloadData { book_id, file_type })
     }
 }