flibusta-apps/book_bot
1
0
Fork 0
mirror of https://github.com/flibusta-apps/book_bot.git synced 2025-12-06 15:35:35 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Update

Browse Source
This commit is contained in:
Bulat Kurbanov
2023-09-24 04:09:24 +02:00
parent 95edba5e34
commit 0afe3acfcd
5 changed files with 54 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/bots/approved_bot/modules/annotations/commands.rs
View File

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

3
src/bots/approved_bot/modules/annotations/mod.rs
View File

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

31
src/bots/approved_bot/modules/book/callback_data.rs
View File

@@ -2,7 +2,7 @@ use std::str::FromStr;
use regex::Regex; 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)] #[derive(Clone)]
@@ -13,27 +13,26 @@ pub enum BookCallbackData {
} }
impl FromStr for BookCallbackData { impl FromStr for BookCallbackData {
type Err = strum::ParseError; type Err = CallbackQueryParseError;
fn from_str(s: &str) -> Result<Self, Self::Err> { 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() {
match annotation_type {
"a" => Ok(BookCallbackData::Author { id, page }), "a" => Ok(BookCallbackData::Author { id, page }),
"t" => Ok(BookCallbackData::Translator { id, page }), "t" => Ok(BookCallbackData::Translator { id, page }),
"s" => Ok(BookCallbackData::Sequence { id, page }), "s" => Ok(BookCallbackData::Sequence { id, page }),
_ => Err(strum::ParseError::VariantNotFound), _ => panic!("Unknown BookCallbackData type: {}!", annotation_type),
} }
)?
} }
} }

30
src/bots/approved_bot/modules/book/commands.rs
View File

@@ -12,25 +12,21 @@ pub enum BookCommand {
impl CommandParse<Self> for BookCommand { impl CommandParse<Self> for BookCommand {
fn parse(s: &str, bot_name: &str) -> Result<Self, CommandParseError> { 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() {
let annotation_type = &caps["an_type"];
let id: u32 = caps["id"].parse().unwrap();
match annotation_type {
"a" => Ok(BookCommand::Author { id }), "a" => Ok(BookCommand::Author { id }),
"t" => Ok(BookCommand::Translator { id }), "t" => Ok(BookCommand::Translator { id }),
"s" => Ok(BookCommand::Sequence { id }), "s" => Ok(BookCommand::Sequence { id }),
_ => Err(CommandParseError), _ => panic!("Unknown BookCommand type: {}!", annotation_type),
} }
})?
} }
} }

27
src/bots/approved_bot/modules/download/callback_data.rs
View File

@@ -3,6 +3,8 @@ use std::str::FromStr;
use regex::Regex; use regex::Regex;
use strum_macros::EnumIter; use strum_macros::EnumIter;
use crate::bots::approved_bot::modules::utils::errors::CommandParseError;
#[derive(Clone, EnumIter)] #[derive(Clone, EnumIter)]
pub enum DownloadQueryData { pub enum DownloadQueryData {
@@ -20,21 +22,20 @@ impl ToString for DownloadQueryData {
} }
impl FromStr for DownloadQueryData { impl FromStr for DownloadQueryData {
type Err = strum::ParseError; type Err = CommandParseError;
fn from_str(s: &str) -> Result<Self, Self::Err> { 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 })
} }
} }