src/handlers/commands/admin_commands.rs

@@ -1,29 +1,21 @@
-use std::{future::Future, ops::Deref, pin::Pin};
+use std::ops::Deref;
 
 use telers::{
-    errors::HandlerError,
+    event::{telegram::HandlerResult, EventReturn},
-    event::{service::BoxFuture, telegram::HandlerResult, EventReturn},
+    filters::CommandObject,
-    filters::{chat_type, CommandObject},
+    types::Message,
-    methods::{BanChatMember, RestrictChatMember, SendMessage, UnbanChatMember},
-    types::{ChatPermissions, Message},
     Bot,
 };
 
 use crate::{
     assets::files::{BAN_COMMAND_HELP, MUTE_COMMAND_HELP, UNBAN_COMMAND_HELP, UNMUTE_COMMAND_HELP},
-    types::enums::{target_user::TargetUser, time_metrics::TimeDuration},
+    utils::telegram::{args_parser::parse_args, senders::send_html},
-    utils::{
-        general::get_expiration_time::get_expiration_date,
-        telegram::{
-            args_parser::{parse_args, Argument},
-            member_rights::{demote_user, restrict},
-            senders::send_html,
-        },
-    },
 };
 
+#[allow(unused)]
 const USER_ID_NOT_FOUND: &str = "Для выполнение команды нужно знать ID пользователя, или ввести команду и выполнить её, ответив на сообщение пользователя";
-const DEMOTE_ERROR: &str = "Невозможно снять привелегий администратора в силу того, что права были выданы одним из администраторов или основателем";
+#[allow(unused)]
+const COMMAND_EXECUTION_REJECTED: &str = "Выполнение данной команды невозможно, поскольку пользователю были выданы права администратора модераторами или основателем";
 
 pub async fn admin_commands_endpoint(
     bot: Bot,
@@ -32,52 +24,11 @@ pub async fn admin_commands_endpoint(
 ) -> HandlerResult {
     let (command_type, args) = (command_object.command.deref(), command_object.args.deref());
 
-    if let Some(args) = parse_args(args, &message, command_type) {
+    let chat_id = message.chat().id();
-        match command_type {
-            "ban" => {
-                let ban_callback = async |chat_id: i64, user_id: i64| {
-                    bot.send(BanChatMember::new(chat_id, user_id)).await?;
-                    Ok(EventReturn::Finish)
-                };
 
-                execute_command(&bot, &message, ban_callback, args).await?;
+    if let Some(_args) = parse_args(args, &message, command_type) {
-            }
+        match command_type {
-            "unban" => {
+            "ban" | "unban" | "mute" | "unmute" => todo!(),
-                let unban_callback = async |chat_id: i64, user_id: i64| {
-                    bot.send(UnbanChatMember::new(chat_id, user_id)).await?;
-                    Ok(EventReturn::Finish)
-                };
-                execute_command(&bot, &message, unban_callback, args).await?;
-            }
-            "mute" => {
-                let duration = if let Some(Argument::Time(duration)) = args.get(1) {
-                    get_expiration_date(*duration)
-                } else {
-                    bot.send(SendMessage::new(
-                        message.chat().id(),
-                        "Не указана длительность мута.",
-                    ))
-                    .await?;
-                    return Err(HandlerError::from_display("Mute duration is not defined"));
-                };
-                let mute_callback = async |chat_id: i64, user_id: i64| {
-                    restrict(&bot, user_id, duration, chat_id).await?;
-                    Ok(EventReturn::Finish)
-                };
-                execute_command(&bot, &message, mute_callback, args).await?;
-            }
-            "unmute" => {
-                let unmute_callback = async |chat_id: i64, user_id: i64| {
-                    bot.send(RestrictChatMember::new(
-                        chat_id,
-                        user_id,
-                        ChatPermissions::new(),
-                    ))
-                    .await?;
-                    Ok(EventReturn::Finish)
-                };
-                execute_command(&bot, &message, unmute_callback, args).await?;
-            }
             _ => unreachable!(),
         };
     } else {
@@ -89,43 +40,7 @@ pub async fn admin_commands_endpoint(
             _ => unreachable!(),
         };
 
-        send_html(&bot, &message, help_txt).await?;
+        send_html(&bot, chat_id, help_txt).await?;
     }
     Ok(EventReturn::Finish)
 }
-
-pub async fn execute_command(
-    bot: &Bot,
-    message: &Message,
-    command: impl AsyncFnOnce(i64, i64) -> HandlerResult + Copy,
-    command_args: Vec<Argument>,
-) -> HandlerResult {
-    let chat_id = message.chat().id();
-
-    if let Some(Argument::User(user)) = command_args.first() {
-        if let TargetUser::None = user {
-            bot.send(SendMessage::new(chat_id, USER_ID_NOT_FOUND))
-                .await?;
-            return Err(HandlerError::from_display("Can't find user ID"));
-        }
-
-        let (user_name, user_id) = (
-            user.get_user_name(bot, message).await.unwrap(),
-            user.get_id().unwrap(),
-        );
-
-        if command(user_id, chat_id).await.is_err() {
-            if demote_user(bot, user_id, chat_id).await.is_err() {
-                bot.send(SendMessage::new(chat_id, DEMOTE_ERROR)).await?;
-                return Err(HandlerError::from_display("Can't demote chat member because he has permission that he got from another admin/chat owner"));
-            }
-            command(user_id, chat_id).await?;
-        } else {
-            bot.send(SendMessage::new(chat_id, "Command executed successful!"))
-                .await?;
-        }
-        Ok(EventReturn::Finish)
-    } else {
-        unreachable!()
-    }
-}

src/handlers/commands/info_commands.rs

@@ -18,9 +18,10 @@ pub async fn info_commands_endpoint(
     message: Message,
     command_object: CommandObject,
 ) -> HandlerResult {
+    let chat_id = message.chat().id();
     match command_object.command.deref() {
-        "help" => send_html(&bot, &message, HELP_COMMAND_TEXT).await,
+        "help" => send_html(&bot, chat_id, HELP_COMMAND_TEXT).await,
-        "privacy" => send_html(&bot, &message, PRIVACY_COMMAND_TEXT).await,
+        "privacy" => send_html(&bot, chat_id, PRIVACY_COMMAND_TEXT).await,
         _ => Ok(EventReturn::Cancel),
     }
 }

src/types/enums/target_user.rs

@@ -1,9 +1,6 @@
-use std::ops::Deref;
-
 use telers::{
     errors::SessionErrorKind,
     methods::GetChatMember,
-    types::User,
     types::{ChatMember, Message},
     Bot,
 };
@@ -56,14 +53,6 @@ impl TargetUser {
         }
     }
 
-    fn _inner_get_user_name(&self, user: User) -> Option<Box<str>> {
-        if let Some(user_name) = user.username.as_ref() {
-            return Some(user_name.clone());
-        } else {
-            return Some(Box::from(user.full_name()));
-        }
-    }
-
     pub async fn get_user_name(&self, bot: &Bot, msg: &Message) -> Option<Box<str>> {
         match self {
             Self::Id(id) => {
@@ -71,13 +60,13 @@ impl TargetUser {
                     bot.send(GetChatMember::new(msg.chat().id(), *id)).await;
 
                 if let Ok(member_kind) = get_chat_member_result {
-                    match member_kind {
+                    return match member_kind {
-                        ChatMember::Owner(member) => self._inner_get_user_name(member.user),
+                        ChatMember::Owner(member) => member.user.username,
-                        ChatMember::Administrator(member) => self._inner_get_user_name(member.user),
+                        ChatMember::Administrator(member) => member.user.username,
-                        ChatMember::Member(member) => self._inner_get_user_name(member.user),
+                        ChatMember::Member(member) => member.user.username,
-                        ChatMember::Restricted(member) => self._inner_get_user_name(member.user),
+                        ChatMember::Restricted(member) => member.user.username,
-                        ChatMember::Left(member) => self._inner_get_user_name(member.user),
+                        ChatMember::Left(member) => member.user.username,
-                        ChatMember::Banned(member) => self._inner_get_user_name(member.user),
+                        ChatMember::Banned(member) => member.user.username,
                     };
                 }
                 None

src/utils/telegram/mod.rs

@@ -3,3 +3,4 @@ pub mod args_parser;
 pub mod data_getters;
 pub mod member_rights;
 pub mod senders;
+pub mod try_admin_action;

src/utils/telegram/senders.rs

@@ -2,12 +2,11 @@ use telers::{
     enums::ParseMode,
     event::{telegram::HandlerResult, EventReturn},
     methods::SendMessage,
-    types::Message,
     Bot,
 };
 
-pub async fn send_html(bot: &Bot, message: &Message, text: &str) -> HandlerResult {
+pub async fn send_html(bot: &Bot, chat_id: i64, text: &str) -> HandlerResult {
-    bot.send(SendMessage::new(message.chat().id(), text).parse_mode(ParseMode::HTML))
+    bot.send(SendMessage::new(chat_id, text).parse_mode(ParseMode::HTML))
         .await?;
 
     Ok(EventReturn::Finish)

src/utils/telegram/try_admin_action.rs

@@ -0,0 +1,31 @@
+use telers::{
+    errors::{HandlerError, SessionErrorKind},
+    event::simple::HandlerResult,
+    methods::SendMessage,
+    Bot,
+};
+
+use super::member_rights::demote_user;
+
+const DEMOTE_ERROR: &str = "Невозможно снять привелегий администратора в силу того, что права были выданы одним из администраторов или основателем";
+
+pub async fn try_admin_action<F>(
+    callback: F,
+    bot: &Bot,
+    chat_id: i64,
+    user_id: i64,
+) -> HandlerResult
+where
+    F: Copy + AsyncFnOnce(i64) -> Result<bool, SessionErrorKind>,
+{
+    if callback(user_id).await.is_err() {
+        if demote_user(bot, user_id, chat_id).await.is_err() {
+            bot.send(SendMessage::new(chat_id, DEMOTE_ERROR)).await?;
+            return Err(HandlerError::from_display("DemoteFailure"));
+        } else {
+            callback(user_id).await;
+        }
+    }
+
+    Ok(())
+}