Add rust implementation

src/bots/approved_bot/modules/search.rs

@@ -0,0 +1,281 @@
+use std::str::FromStr;
+
+use regex::Regex;
+use strum_macros::EnumIter;
+use teloxide::{
+    prelude::*,
+    types::{InlineKeyboardButton, InlineKeyboardMarkup},
+};
+
+use crate::bots::{
+    approved_bot::{
+        services::{
+            book_library::{
+                formaters::Format, search_author, search_book, search_sequence, search_translator,
+                types::Page,
+            },
+            user_settings::get_user_or_default_lang_codes,
+        },
+        tools::filter_callback_query,
+    },
+    BotHandlerInternal,
+};
+
+use super::utils::{generic_get_pagination_keyboard, GetPaginationCallbackData};
+
+#[derive(Clone, EnumIter)]
+pub enum SearchCallbackData {
+    SearchBook { page: u32 },
+    SearchAuthors { page: u32 },
+    SearchSequences { page: u32 },
+    SearchTranslators { page: u32 },
+}
+
+impl ToString for SearchCallbackData {
+    fn to_string(&self) -> String {
+        match self {
+            SearchCallbackData::SearchBook { page } => format!("sb_{page}"),
+            SearchCallbackData::SearchAuthors { page } => format!("sa_{page}"),
+            SearchCallbackData::SearchSequences { page } => format!("ss_{page}"),
+            SearchCallbackData::SearchTranslators { page } => format!("st_{page}"),
+        }
+    }
+}
+
+impl FromStr for SearchCallbackData {
+    type Err = strum::ParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let re = Regex::new(r"^(?P<search_type>s[a|b|s|t])_(?P<page>\d+)$").unwrap();
+
+        let caps = re.captures(s);
+        let caps = match caps {
+            Some(v) => v,
+            None => return Err(strum::ParseError::VariantNotFound),
+        };
+
+        let search_type = &caps["search_type"];
+        let page: u32 = caps["page"].parse::<u32>().unwrap();
+
+        match search_type {
+            "sb" => Ok(SearchCallbackData::SearchBook { page }),
+            "sa" => Ok(SearchCallbackData::SearchAuthors { page }),
+            "ss" => Ok(SearchCallbackData::SearchSequences { page }),
+            "st" => Ok(SearchCallbackData::SearchTranslators { page }),
+            _ => Err(strum::ParseError::VariantNotFound),
+        }
+    }
+}
+
+impl GetPaginationCallbackData for SearchCallbackData {
+    fn get_pagination_callback_data(&self, target_page: u32) -> String {
+        match self {
+            SearchCallbackData::SearchBook { .. } => {
+                SearchCallbackData::SearchBook { page: target_page }
+            }
+            SearchCallbackData::SearchAuthors { .. } => {
+                SearchCallbackData::SearchAuthors { page: target_page }
+            }
+            SearchCallbackData::SearchSequences { .. } => {
+                SearchCallbackData::SearchSequences { page: target_page }
+            }
+            SearchCallbackData::SearchTranslators { .. } => {
+                SearchCallbackData::SearchTranslators { page: target_page }
+            }
+        }
+        .to_string()
+    }
+}
+
+fn get_query(cq: CallbackQuery) -> Option<String> {
+    cq.message
+        .map(|message| {
+            message
+                .reply_to_message()
+                .map(|reply_to_message| {
+                    reply_to_message
+                        .text()
+                        .map(|text| text.replace('/', "").replace('&', "").replace('?', ""))
+                })
+                .unwrap_or(None)
+        })
+        .unwrap_or(None)
+}
+
+async fn generic_search_pagination_handler<T, Fut>(
+    cq: CallbackQuery,
+    bot: AutoSend<Bot>,
+    search_data: SearchCallbackData,
+    items_getter: fn(query: String, page: u32, allowed_langs: Vec<String>) -> Fut,
+) -> BotHandlerInternal
+where
+    T: Format + Clone,
+    Fut: std::future::Future<Output = Result<Page<T>, Box<dyn std::error::Error + Send + Sync>>>,
+{
+    let chat_id = cq.message.as_ref().map(|message| message.chat.id);
+    let user_id = cq
+        .message
+        .as_ref()
+        .map(|message| message.from().map(|from| from.id))
+        .unwrap_or(None);
+    let message_id = cq.message.as_ref().map(|message| message.id);
+    let query = get_query(cq);
+
+    let (chat_id, user_id, query, message_id) = match (chat_id, user_id, query, message_id) {
+        (Some(chat_id), Some(user_id), Some(query), Some(message_id)) => {
+            (chat_id, user_id, query, message_id)
+        }
+        _ => {
+            return match chat_id {
+                Some(v) => match bot.send_message(v, "Повторите поиск сначала").send().await
+                {
+                    Ok(_) => Ok(()),
+                    Err(err) => Err(Box::new(err)),
+                },
+                None => return Ok(()),
+            }
+        }
+    };
+
+    let allowed_langs = get_user_or_default_lang_codes(user_id).await;
+
+    let page = match search_data {
+        SearchCallbackData::SearchBook { page } => page,
+        SearchCallbackData::SearchAuthors { page } => page,
+        SearchCallbackData::SearchSequences { page } => page,
+        SearchCallbackData::SearchTranslators { page } => page,
+    };
+
+    let mut items_page = match items_getter(query.clone(), page, allowed_langs.clone()).await {
+        Ok(v) => v,
+        Err(err) => {
+            match bot
+                .send_message(chat_id, "Ошибка! Попробуйте позже :(")
+                .send()
+                .await
+            {
+                Ok(_) => (),
+                Err(err) => log::error!("{:?}", err),
+            }
+            return Err(err);
+        }
+    };
+
+    if items_page.total_pages == 0 {
+        let message_text = match search_data {
+            SearchCallbackData::SearchBook { .. } => "Книги не найдены!",
+            SearchCallbackData::SearchAuthors { .. } => "Авторы не найдены!",
+            SearchCallbackData::SearchSequences { .. } => "Серии не найдены!",
+            SearchCallbackData::SearchTranslators { .. } => "Переводчики не найдены!",
+        };
+
+        match bot.send_message(chat_id, message_text).send().await {
+            Ok(_) => (),
+            Err(err) => return Err(Box::new(err)),
+        };
+    };
+
+    if page > items_page.total_pages {
+        items_page = match items_getter(
+            query.clone(),
+            items_page.total_pages,
+            allowed_langs.clone(),
+        )
+        .await
+        {
+            Ok(v) => v,
+            Err(err) => {
+                match bot
+                    .send_message(chat_id, "Ошибка! Попробуйте позже :(")
+                    .send()
+                    .await
+                {
+                    Ok(_) => (),
+                    Err(err) => log::error!("{:?}", err),
+                }
+                return Err(err);
+            }
+        };
+    }
+
+    let formated_items = items_page.format_items();
+
+    let total_pages = items_page.total_pages;
+
+    let footer = format!("\n\nСтраница {page}/{total_pages}");
+    let message_text = format!("{formated_items}{footer}");
+
+    let keyboard = generic_get_pagination_keyboard(page, total_pages, search_data, true);
+
+    match bot
+        .edit_message_text(chat_id, message_id, message_text)
+        .reply_markup(keyboard)
+        .send()
+        .await
+    {
+        Ok(_) => Ok(()),
+        Err(err) => Err(Box::new(err)),
+    }
+}
+
+pub async fn message_handler(message: Message, bot: AutoSend<Bot>) -> BotHandlerInternal {
+    let message_text = "Что ищем?";
+
+    let keyboard = InlineKeyboardMarkup {
+        inline_keyboard: vec![
+            vec![InlineKeyboardButton {
+                text: "Книгу".to_string(),
+                kind: teloxide::types::InlineKeyboardButtonKind::CallbackData(
+                    (SearchCallbackData::SearchBook { page: 1 }).to_string(),
+                ),
+            }],
+            vec![InlineKeyboardButton {
+                text: "Автора".to_string(),
+                kind: teloxide::types::InlineKeyboardButtonKind::CallbackData(
+                    (SearchCallbackData::SearchAuthors { page: 1 }).to_string(),
+                ),
+            }],
+            vec![InlineKeyboardButton {
+                text: "Серию".to_string(),
+                kind: teloxide::types::InlineKeyboardButtonKind::CallbackData(
+                    (SearchCallbackData::SearchSequences { page: 1 }).to_string(),
+                ),
+            }],
+            vec![InlineKeyboardButton {
+                text: "Переводчика".to_string(),
+                kind: teloxide::types::InlineKeyboardButtonKind::CallbackData(
+                    (SearchCallbackData::SearchTranslators { page: 1 }).to_string(),
+                ),
+            }],
+        ],
+    };
+
+    match bot
+        .send_message(message.chat.id, message_text)
+        .reply_to_message_id(message.id)
+        .reply_markup(keyboard)
+        .send()
+        .await
+    {
+        Ok(_) => Ok(()),
+        Err(err) => Err(Box::new(err)),
+    }
+}
+
+pub fn get_search_hanlder() -> crate::bots::BotHandler {
+    dptree::entry().branch(
+        Update::filter_message()
+            .endpoint(|message, bot| async move { message_handler(message, bot).await }),
+    ).branch(
+        Update::filter_callback_query()
+            .chain(filter_callback_query::<SearchCallbackData>())
+            .endpoint(|cq: CallbackQuery, callback_data: SearchCallbackData, bot: AutoSend<Bot>| async move {
+                match callback_data {
+                    SearchCallbackData::SearchBook { .. } => generic_search_pagination_handler(cq, bot, callback_data, search_book).await,
+                    SearchCallbackData::SearchAuthors { .. } => generic_search_pagination_handler(cq, bot, callback_data, search_author).await,
+                    SearchCallbackData::SearchSequences { .. } => generic_search_pagination_handler(cq, bot, callback_data, search_sequence).await,
+                    SearchCallbackData::SearchTranslators { .. } => generic_search_pagination_handler(cq, bot, callback_data, search_translator).await,
+                }
+            })
+    )
+}