Merge pull request #38 from Infamous-Hydra/Infamous-Hydra-patch-10

Mikobot/plugins/mute.py

@@ -1,697 +1,261 @@
 # <============================================== IMPORTS =========================================================>
-from random import choice
-from traceback import format_exc
-
-from pyrogram import enums
-from pyrogram.errors import (
-    ChatAdminRequired,
-    RightForbidden,
-    RPCError,
-    UserNotParticipant,
+import html
+from typing import Union
+
+from telegram import Bot, Chat, ChatMember, ChatPermissions, Update
+from telegram.constants import ParseMode
+from telegram.error import BadRequest
+from telegram.ext import CommandHandler, ContextTypes
+from telegram.helpers import mention_html
+
+from Mikobot import LOGGER, function
+from Mikobot.plugins.helper_funcs.chat_status import (
+    check_admin,
+    connection_status,
+    is_user_admin,
 )
-from pyrogram.filters import regex
-from pyrogram.types import (
-    CallbackQuery,
-    ChatPermissions,
-    InlineKeyboardButton,
-    InlineKeyboardMarkup,
-    Message,
-)
-
-from Infamous.karma import MUTE_GIFS
-from Mikobot import BOT_ID, LOGGER, MESSAGE_DUMP, OWNER_ID, SUPPORT_STAFF, app
-from Mikobot.utils.caching import ADMIN_CACHE, admin_cache_reload
-from Mikobot.utils.custom_filters import command, restrict_filter
-from Mikobot.utils.extract_user import extract_user
-from Mikobot.utils.parser import mention_html
-from Mikobot.utils.string import extract_time
+from Mikobot.plugins.helper_funcs.extraction import extract_user, extract_user_and_text
+from Mikobot.plugins.helper_funcs.string_handling import extract_time
+from Mikobot.plugins.log_channel import loggable
 
 # <=======================================================================================================>
 
 
 # <================================================ FUNCTION =======================================================>
-@app.on_message(command("tmute") & restrict_filter)
-async def tmute_usr(c: app, m: Message):
-    if len(m.text.split()) == 1 and not m.reply_to_message:
-        await m.reply_text("I can't mute nothing!")
-        return
-
-    try:
-        user_id, user_first_name, _ = await extract_user(c, m)
-    except Exception:
-        return
-
+async def check_user(user_id: int, bot: Bot, chat: Chat) -> Union[str, None]:
     if not user_id:
-        await m.reply_text("Cannot find user to mute !")
-        return
-    if user_id == BOT_ID:
-        await m.reply_text("Huh, why would I mute myself?")
-        return
-
-    if user_id in SUPPORT_STAFF:
-        LOGGER.info(
-            f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}",
-        )
-        await m.reply_text(
-            text="This user is in my support staff, cannot restrict them."
-        )
-        return
+        reply = "You don't seem to be referring to a user or the ID specified is incorrect.."
+        return reply
 
     try:
-        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
-    except KeyError:
-        admins_group = await admin_cache_reload(m, "mute")
-
-    if user_id in admins_group:
-        await m.reply_text(text="This user is an admin, I cannot mute them!")
-        return
-
-    r_id = m.reply_to_message.id if m.reply_to_message else m.id
-
-    if m.reply_to_message and len(m.text.split()) >= 2:
-        reason = m.text.split(None, 1)[1]
-    elif not m.reply_to_message and len(m.text.split()) >= 3:
-        reason = m.text.split(None, 2)[2]
-    else:
-        await m.reply_text("Read /help !!")
-        return
-
-    if not reason:
-        await m.reply_text("You haven't specified a time to mute this user for!")
-        return
-
-    split_reason = reason.split(None, 1)
-    time_val = split_reason[0].lower()
-    reason = split_reason[1] if len(split_reason) > 1 else ""
-    mutetime = await extract_time(m, time_val)
-
-    if not mutetime:
-        return
-
-    try:
-        await m.chat.restrict_member(
-            user_id,
-            ChatPermissions(),
-            mutetime,
-        )
-        LOGGER.info(f"{m.from_user.id} tmuted {user_id} in {m.chat.id}")
-        admin = await mention_html(m.from_user.first_name, m.from_user.id)
-        muted = await mention_html(user_first_name, user_id)
-        txt = f"Admin {admin} muted {muted}!"
-        if reason:
-            txt += f"\n<b>Reason</b>: {reason}"
+        member = await chat.get_member(user_id)
+    except BadRequest as excp:
+        if excp.message == "User not found":
+            reply = "I can't seem to find this user"
+            return reply
         else:
-            txt += "\n<b>Reason</b>: Not Specified"
-        if mutetime:
-            txt += f"\n<b>Muted for</b>: {time_val}"
-        keyboard = InlineKeyboardMarkup(
-            [
-                [
-                    InlineKeyboardButton(
-                        "UNMUTE",
-                        callback_data=f"unmute_={user_id}",
-                    ),
-                ],
-            ],
-        )
-        mutt = choice(MUTE_GIFS)
-        try:
-            await m.reply_animation(
-                animation=str(mutt),
-                caption=txt,
-                reply_markup=keyboard,
-                reply_to_message_id=r_id,
-            )
-        except Exception:
-            await m.reply_text(txt, reply_markup=keyboard, reply_to_message_id=r_id)
-            await c.send_message(MESSAGE_DUMP, f"#REMOVE from MUTE_GIFS\n{mutt}")
-    except ChatAdminRequired:
-        await m.reply_text(text="I'm not admin or I don't have rights.")
-    except RightForbidden:
-        await m.reply_text(text="I don't have enough rights to ban this user.")
-    except UserNotParticipant:
-        await m.reply_text("How can I mute a user who is not a part of this chat?")
-    except RPCError as ef:
-        await m.reply_text(
-            text=f"""Some error occured, report it using `/bug`
-
-      <b>Error:</b> <code>{ef}</code>"""
-        )
-        LOGGER.error(ef)
-
-    return
-
+            raise
 
-@app.on_message(command("dtmute") & restrict_filter)
-async def dtmute_usr(c: app, m: Message):
-    if len(m.text.split()) == 1 and not m.reply_to_message:
-        await m.reply_text("I can't mute nothing!")
-        return
+    if user_id == bot.id:
+        reply = "I'm not gonna MUTE myself, How high are you?"
+        return reply
 
-    if not m.reply_to_message:
-        return await m.reply_text("No replied message and user to delete and mute!")
-
-    reason = None
-    user_id = m.reply_to_message.from_user.id
-    user_first_name = m.reply_to_message.from_user.first_name
-
-    if not user_id:
-        await m.reply_text("Cannot find user to mute !")
-        return
-    if user_id == BOT_ID:
-        await m.reply_text("Huh, why would I mute myself?")
-        return
-
-    if user_id in SUPPORT_STAFF:
-        LOGGER.info(
-            f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}",
-        )
-        await m.reply_text(
-            text="This user is in my support staff, cannot restrict them."
-        )
-        return
+    if await is_user_admin(chat, user_id, member):
+        reply = "Sorry can't do that, this user is admin here."
+        return reply
 
-    try:
-        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
-    except KeyError:
-        admins_group = await admin_cache_reload(m, "mute")
-
-    if user_id in admins_group:
-        await m.reply_text(text="This user is an admin, I cannot mute them!")
-        return
-
-    if m.reply_to_message and len(m.text.split()) >= 2:
-        reason = m.text.split(None, 1)[1]
-    elif not m.reply_to_message and len(m.text.split()) >= 3:
-        reason = m.text.split(None, 2)[2]
-    else:
-        await m.reply_text("Read /help !!")
-        return
+    return None
 
-    if not reason:
-        await m.reply_text("You haven't specified a time to mute this user for!")
-        return
 
-    split_reason = reason.split(None, 1)
-    time_val = split_reason[0].lower()
-    reason = split_reason[1] if len(split_reason) > 1 else ""
+@connection_status
+@loggable
+@check_admin(permission="can_restrict_members", is_both=True)
+async def mute(update: Update, context: ContextTypes.DEFAULT_TYPE) -> str:
+    bot = context.bot
+    args = context.args
 
-    mutetime = await extract_time(m, time_val)
+    chat = update.effective_chat
+    user = update.effective_user
+    message = update.effective_message
 
-    if not mutetime:
-        return
-    try:
-        await m.chat.restrict_member(
-            user_id,
-            ChatPermissions(),
-            mutetime,
-        )
-        LOGGER.info(f"{m.from_user.id} dtmuted {user_id} in {m.chat.id}")
-        await m.reply_to_message.delete()
-        admin = await mention_html(m.from_user.first_name, m.from_user.id)
-        muted = await mention_html(user_first_name, user_id)
-        txt = f"Admin {admin} muted {muted}!"
-        if reason:
-            txt += f"\n<b>Reason</b>: {reason}"
-        else:
-            txt += "\n<b>Reason</b>: Not Specified"
-        if mutetime:
-            txt += f"\n<b>Muted for</b>: {time_val}"
-        keyboard = InlineKeyboardMarkup(
-            [
-                [
-                    InlineKeyboardButton(
-                        "UNMUTE",
-                        callback_data=f"unmute_={user_id}",
-                    ),
-                ],
-            ],
-        )
-        mutt = choice(MUTE_GIFS)
-        try:
-            await m.reply_animation(
-                animation=str(mutt),
-                caption=txt,
-                reply_markup=keyboard,
-            )
-        except Exception:
-            await m.reply_text(txt, reply_markup=keyboard)
-            await c.send_message(MESSAGE_DUMP, f"#REMOVE from MUTE_GIFS\n{mutt}")
-    except ChatAdminRequired:
-        await m.reply_text(text="I'm not admin or I don't have rights.")
-    except RightForbidden:
-        await m.reply_text(text="I don't have enough rights to ban this user.")
-    except UserNotParticipant:
-        await m.reply_text("How can I mute a user who is not a part of this chat?")
-    except RPCError as ef:
-        await m.reply_text(
-            text=f"""Some error occured, report it using `/bug`
-
-      <b>Error:</b> <code>{ef}</code>"""
-        )
-        LOGGER.error(ef)
+    user_id, reason = await extract_user_and_text(message, context, args)
+    reply = await check_user(user_id, bot, chat)
 
-    return
+    if reply:
+        await message.reply_text(reply)
+        return ""
 
+    member = await chat.get_member(user_id)
 
-@app.on_message(command("stmute") & restrict_filter)
-async def stmute_usr(c: app, m: Message):
-    if len(m.text.split()) == 1 and not m.reply_to_message:
-        await m.reply_text("I can't mute nothing!")
-        return
+    log = (
+        f"<b>{html.escape(chat.title)}:</b>\n"
+        f"#MUTE\n"
+        f"<b>Admin:</b> {mention_html(user.id, user.first_name)}\n"
+        f"<b>User:</b> {mention_html(member.user.id, member.user.first_name)}"
+    )
 
-    try:
-        user_id, _, _ = await extract_user(c, m)
-    except Exception:
-        return
+    if reason:
+        log += f"\n<b>Reason:</b> {reason}"
 
-    if not user_id:
-        await m.reply_text("Cannot find user to mute !")
-        return
-    if user_id == BOT_ID:
-        await m.reply_text("Huh, why would I mute myself?")
-        return
-
-    if user_id in SUPPORT_STAFF:
-        LOGGER.info(
-            f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}",
-        )
-        await m.reply_text(
-            text="This user is in my support staff, cannot restrict them."
+    if member.status in [ChatMember.RESTRICTED, ChatMember.MEMBER]:
+        chat_permissions = ChatPermissions(can_send_messages=False)
+        await bot.restrict_chat_member(chat.id, user_id, chat_permissions)
+        await bot.sendMessage(
+            chat.id,
+            f"Muted <b>{html.escape(member.user.first_name)}</b> with no expiration date!",
+            parse_mode=ParseMode.HTML,
+            message_thread_id=message.message_thread_id if chat.is_forum else None,
         )
-        return
+        return log
 
-    try:
-        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
-    except KeyError:
-        admins_group = await admin_cache_reload(m, "mute")
-
-    if user_id in admins_group:
-        await m.reply_text(text="This user is an admin, I cannot mute them!")
-        return
-
-    if m.reply_to_message and len(m.text.split()) >= 2:
-        reason = m.text.split(None, 1)[1]
-    elif not m.reply_to_message and len(m.text.split()) >= 3:
-        reason = m.text.split(None, 2)[2]
     else:
-        await m.reply_text("Read /help !!")
-        return
-
-    if not reason:
-        await m.reply_text("You haven't specified a time to mute this user for!")
-        return
-
-    split_reason = reason.split(None, 1)
-    time_val = split_reason[0].lower()
-    reason = split_reason[1] if len(split_reason) > 1 else ""
-
-    mutetime = await extract_time(m, time_val)
-
-    if not mutetime:
-        return
+        await message.reply_text("This user is already muted!")
 
-    try:
-        await m.chat.restrict_member(
-            user_id,
-            ChatPermissions(),
-            mutetime,
-        )
-        LOGGER.info(f"{m.from_user.id} stmuted {user_id} in {m.chat.id}")
-        await m.delete()
-        if m.reply_to_message:
-            await m.reply_to_message.delete()
-    except ChatAdminRequired:
-        await m.reply_text(text="I'm not admin or I don't have rights.")
-    except RightForbidden:
-        await m.reply_text(text="I don't have enough rights to ban this user.")
-    except UserNotParticipant:
-        await m.reply_text("How can I mute a user who is not a part of this chat?")
-    except RPCError as ef:
-        await m.reply_text(
-            text=f"""Some error occured, report it using `/bug`
-
-      <b>Error:</b> <code>{ef}</code>"""
-        )
-        LOGGER.error(ef)
+    return ""
 
-    return
 
+@connection_status
+@loggable
+@check_admin(permission="can_restrict_members", is_both=True)
+async def unmute(update: Update, context: ContextTypes.DEFAULT_TYPE) -> str:
+    bot, args = context.bot, context.args
+    chat = update.effective_chat
+    user = update.effective_user
+    message = update.effective_message
 
-@app.on_message(command("mute") & restrict_filter)
-async def mute_usr(c: app, m: Message):
-    if len(m.text.split()) == 1 and not m.reply_to_message:
-        await m.reply_text("I can't mute nothing!")
-        return
-
-    reason = None
-    if m.reply_to_message:
-        r_id = m.reply_to_message.id
-        if len(m.text.split()) >= 2:
-            reason = m.text.split(None, 1)[1]
-    else:
-        r_id = m.id
-        if len(m.text.split()) >= 3:
-            reason = m.text.split(None, 2)[2]
-    try:
-        user_id, user_first_name, _ = await extract_user(c, m)
-    except Exception:
-        return
-
+    user_id = await extract_user(message, context, args)
     if not user_id:
-        await m.reply_text("Cannot find user to mute")
-        return
-    if user_id == BOT_ID:
-        await m.reply_text("Huh, why would I mute myself?")
-        return
-
-    if user_id in SUPPORT_STAFF:
-        LOGGER.info(
-            f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        await message.reply_text(
+            "You'll need to either give me a username to unmute, or reply to someone to be unmuted.",
         )
-        await m.reply_text(
-            text="This user is in my support staff, cannot restrict them."
-        )
-        return
-
-    try:
-        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
-    except KeyError:
-        admins_group = await admin_cache_reload(m, "mute")
+        return ""
 
-    if user_id in admins_group:
-        await m.reply_text(text="This user is an admin, I cannot mute them!")
-        return
+    member = await chat.get_member(int(user_id))
 
-    try:
-        await m.chat.restrict_member(
-            user_id,
-            ChatPermissions(),
-        )
-        LOGGER.info(f"{m.from_user.id} muted {user_id} in {m.chat.id}")
-        admin = await mention_html(m.from_user.first_name, m.from_user.id)
-        muted = await mention_html(user_first_name, user_id)
-        txt = f"Admin {admin} muted {muted}!"
-        if reason:
-            txt += f"\n<b>Reason</b>: {reason}"
+    if member.status not in [ChatMember.LEFT, ChatMember.BANNED]:
+        if member.status != ChatMember.RESTRICTED:
+            await message.reply_text("This user already has the right to speak.")
         else:
-            txt += "\n<b>Reason</b>: Not Specified"
-        keyboard = InlineKeyboardMarkup(
-            [
-                [
-                    InlineKeyboardButton(
-                        "UNMUTE",
-                        callback_data=f"unmute_={user_id}",
-                    ),
-                ],
-            ],
-        )
-        mutt = choice(MUTE_GIFS)
-        try:
-            await m.reply_animation(
-                animation=str(mutt),
-                caption=txt,
-                reply_markup=keyboard,
-                reply_to_message_id=r_id,
+            chat_permissions = ChatPermissions(
+                can_send_messages=True,
+                can_invite_users=True,
+                can_pin_messages=True,
+                can_send_polls=True,
+                can_change_info=True,
+                can_send_media_messages=True,
+                can_send_other_messages=True,
+                can_add_web_page_previews=True,
+            )
+            try:
+                await bot.restrict_chat_member(chat.id, int(user_id), chat_permissions)
+            except BadRequest:
+                pass
+            await bot.sendMessage(
+                chat.id,
+                f"I shall allow <b>{html.escape(member.user.first_name)}</b> to text!",
+                parse_mode=ParseMode.HTML,
+                message_thread_id=message.message_thread_id if chat.is_forum else None,
+            )
+            return (
+                f"<b>{html.escape(chat.title)}:</b>\n"
+                f"#UNMUTE\n"
+                f"<b>Admin:</b> {mention_html(user.id, user.first_name)}\n"
+                f"<b>User:</b> {mention_html(member.user.id, member.user.first_name)}"
             )
-        except Exception:
-            await m.reply_text(txt, reply_markup=keyboard, reply_to_message_id=r_id)
-            await c.send_message(MESSAGE_DUMP, f"#REMOVE from MUTE_GIFS\n{mutt}")
-    except ChatAdminRequired:
-        await m.reply_text(text="I'm not admin or I don't have rights.")
-    except RightForbidden:
-        await m.reply_text(text="I don't have enough rights to ban this user.")
-    except UserNotParticipant:
-        await m.reply_text("How can I mute a user who is not a part of this chat?")
-    except RPCError as ef:
-        await m.reply_text(
-            text=f"""Some error occured, report it using `/bug`
-
-      <b>Error:</b> <code>{ef}</code>"""
+    else:
+        await message.reply_text(
+            "This user isn't even in the chat, unmuting them won't make them talk more than they "
+            "already do!",
         )
-        LOGGER.error(ef)
 
-    return
+    return ""
 
 
-@app.on_message(command("smute") & restrict_filter)
-async def smute_usr(c: app, m: Message):
-    if len(m.text.split()) == 1 and not m.reply_to_message:
-        await m.reply_text("I can't mute nothing!")
-        return
+@connection_status
+@loggable
+@check_admin(permission="can_restrict_members", is_both=True)
+async def temp_mute(update: Update, context: ContextTypes.DEFAULT_TYPE) -> str:
+    bot, args = context.bot, context.args
+    chat = update.effective_chat
+    user = update.effective_user
+    message = update.effective_message
 
-    try:
-        user_id, _, _ = await extract_user(c, m)
-    except Exception:
-        return
+    user_id, reason = await extract_user_and_text(message, context, args)
+    reply = await check_user(user_id, bot, chat)
 
-    if not user_id:
-        await m.reply_text("Cannot find user to mute")
-        return
-    if user_id == BOT_ID:
-        await m.reply_text("Huh, why would I mute myself?")
-        return
-
-    if user_id in SUPPORT_STAFF:
-        LOGGER.info(
-            f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}",
-        )
-        await m.reply_text(
-            text="This user is in my support staff, cannot restrict them."
-        )
-        return
-
-    try:
-        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
-    except KeyError:
-        admins_group = await admin_cache_reload(m, "mute")
-
-    if user_id in admins_group:
-        await m.reply_text(text="This user is an admin, I cannot mute them!")
-        return
-
-    try:
-        await m.chat.restrict_member(
-            user_id,
-            ChatPermissions(),
-        )
-        LOGGER.info(f"{m.from_user.id} smuted {user_id} in {m.chat.id}")
-        await m.delete()
-        if m.reply_to_message:
-            await m.reply_to_message.delete()
-            return
-        return
-    except ChatAdminRequired:
-        await m.reply_text(text="I'm not admin or I don't have rights.")
-    except RightForbidden:
-        await m.reply_text(text="I don't have enough rights to ban this user.")
-    except UserNotParticipant:
-        await m.reply_text("How can I mute a user who is not a part of this chat?")
-    except RPCError as ef:
-        await m.reply_text(
-            text=f"""Some error occured, report it using `/bug`
-
-      <b>Error:</b> <code>{ef}</code>"""
-        )
-        LOGGER.error(ef)
+    if reply:
+        await message.reply_text(reply)
+        return ""
 
-    return
+    member = await chat.get_member(user_id)
 
+    if not reason:
+        await message.reply_text("You haven't specified a time to mute this user for!")
+        return ""
 
-@app.on_message(command("dmute") & restrict_filter)
-async def dmute_usr(c: app, m: Message):
-    if len(m.text.split()) == 1 and not m.reply_to_message:
-        await m.reply_text("I can't mute nothing!")
-        return
-    if not m.reply_to_message:
-        return await m.reply_text("No replied message and user to delete and mute!")
+    split_reason = reason.split(None, 1)
 
-    reason = None
-    if m.reply_to_message:
-        if len(m.text.split()) >= 2:
-            reason = m.text.split(None, 1)[1]
+    time_val = split_reason[0].lower()
+    if len(split_reason) > 1:
+        reason = split_reason[1]
     else:
-        if len(m.text.split()) >= 3:
-            reason = m.text.split(None, 2)[2]
-    user_id = m.reply_to_message.from_user.id
-    user_first_name = m.reply_to_message.from_user.first_name
+        reason = ""
 
-    if not user_id:
-        await m.reply_text("Cannot find user to mute")
-        return
-    if user_id == BOT_ID:
-        await m.reply_text("Huh, why would I mute myself?")
-        return
-
-    if user_id in SUPPORT_STAFF:
-        LOGGER.info(
-            f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}",
-        )
-        await m.reply_text(
-            text="This user is in my support staff, cannot restrict them."
-        )
-        return
-
-    try:
-        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
-    except KeyError:
-        admins_group = await admin_cache_reload(m, "mute")
+    mutetime = await extract_time(message, time_val)
 
-    if user_id in admins_group:
-        await m.reply_text(text="This user is an admin, I cannot mute them!")
-        return
+    if not mutetime:
+        return ""
+
+    log = (
+        f"<b>{html.escape(chat.title)}:</b>\n"
+        f"#TEMP MUTED\n"
+        f"<b>Admin:</b> {mention_html(user.id, user.first_name)}\n"
+        f"<b>User:</b> {mention_html(member.user.id, member.user.first_name)}\n"
+        f"<b>Time:</b> {time_val}"
+    )
+    if reason:
+        log += f"\n<b>Reason:</b> {reason}"
 
     try:
-        await m.chat.restrict_member(
-            user_id,
-            ChatPermissions(),
-        )
-        LOGGER.info(f"{m.from_user.id} dmuted {user_id} in {m.chat.id}")
-        await m.reply_to_message.delete()
-        admin = await mention_html(m.from_user.first_name, m.from_user.id)
-        muted = await mention_html(user_first_name, user_id)
-        txt = f"Admin {admin} muted {muted}!"
-        if reason:
-            txt += f"\n<b>Reason</b>: {reason}"
-        else:
-            txt += "\n<b>Reason</b>: Not Specified"
-        keyboard = InlineKeyboardMarkup(
-            [
-                [
-                    InlineKeyboardButton(
-                        "UNMUTE",
-                        callback_data=f"unmute_={user_id}",
-                    ),
-                ],
-            ],
-        )
-        mutt = choice(MUTE_GIFS)
-        try:
-            await m.reply_animation(
-                animation=str(mutt),
-                caption=txt,
-                reply_markup=keyboard,
+        if member.status in [ChatMember.RESTRICTED, ChatMember.MEMBER]:
+            chat_permissions = ChatPermissions(can_send_messages=False)
+            await bot.restrict_chat_member(
+                chat.id,
+                user_id,
+                chat_permissions,
+                until_date=mutetime,
             )
-        except Exception:
-            await m.reply_text(txt, reply_markup=keyboard)
-            await c.send_message(MESSAGE_DUMP, f"#REMOVE from MUTE_GIFS\n{mutt}")
-    except ChatAdminRequired:
-        await m.reply_text(text="I'm not admin or I don't have rights.")
-    except RightForbidden:
-        await m.reply_text(text="I don't have enough rights to ban this user.")
-    except UserNotParticipant:
-        await m.reply_text("How can I mute a user who is not a part of this chat?")
-    except RPCError as ef:
-        await m.reply_text(
-            text=f"""Some error occured, report it using `/bug`
-
-      <b>Error:</b> <code>{ef}</code>"""
-        )
-        LOGGER.error(ef)
-
-    return
-
-
-@app.on_message(command("unmute") & restrict_filter)
-async def unmute_usr(c: app, m: Message):
-    if len(m.text.split()) == 1 and not m.reply_to_message:
-        await m.reply_text("I can't unmute nothing!")
-        return
-
-    try:
-        user_id, user_first_name, _ = await extract_user(c, m)
-    except Exception:
-        return
-
-    if user_id == BOT_ID:
-        await m.reply_text("Huh, why would I unmute myself if you are using me?")
-        return
-    try:
-        statu = (await m.chat.get_member(user_id)).status
-        if statu not in [
-            enums.ChatMemberStatus.BANNED,
-            enums.ChatMemberStatus.RESTRICTED,
-        ]:
-            await m.reply_text(
-                "User is not muted in this chat\nOr using this command as reply to his message"
+            await bot.sendMessage(
+                chat.id,
+                f"Muted <b>{html.escape(member.user.first_name)}</b> for {time_val}!",
+                parse_mode=ParseMode.HTML,
+                message_thread_id=message.message_thread_id if chat.is_forum else None,
             )
-            return
-    except Exception as e:
-        LOGGER.error(e)
-        LOGGER.exception(format_exc())
-    try:
-        await m.chat.unban_member(user_id)
-        LOGGER.info(f"{m.from_user.id} unmuted {user_id} in {m.chat.id}")
-        admin = await mention_html(m.from_user.first_name, m.from_user.id)
-        unmuted = await mention_html(user_first_name, user_id)
-        await m.reply_text(text=f"Admin {admin} unmuted {unmuted}!")
-    except ChatAdminRequired:
-        await m.reply_text(text="I'm not admin or I don't have rights.")
-    except UserNotParticipant:
-        await m.reply_text("How can I unmute a user who is not a part of this chat?")
-    except RightForbidden:
-        await m.reply_text(text="I don't have enough rights to ban this user.")
-    except RPCError as ef:
-        await m.reply_text(
-            text=f"""Some error occured, report it using `/bug`
-
-      <b>Error:</b> <code>{ef}</code>"""
-        )
-        LOGGER.error(ef)
-    return
-
-
-@app.on_callback_query(regex("^unmute_"))
-async def unmutebutton(c: app, q: CallbackQuery):
-    splitter = (str(q.data).replace("unmute_", "")).split("=")
-    user_id = int(splitter[1])
-    user = await q.message.chat.get_member(q.from_user.id)
+            return log
+        else:
+            await message.reply_text("This user is already muted.")
 
-    if not user:
-        await q.answer(
-            "You don't have enough permission to do this!\nStay in your limits!",
-            show_alert=True,
-        )
-        return
+    except BadRequest as excp:
+        if excp.message == "Reply message not found":
+            # Do not reply
+            await message.reply_text(f"Muted for {time_val}!", quote=False)
+            return log
+        else:
+            LOGGER.warning(update)
+            LOGGER.exception(
+                "ERROR muting user %s in chat %s (%s) due to %s",
+                user_id,
+                chat.title,
+                chat.id,
+                excp.message,
+            )
+            await message.reply_text("Well damn, I can't mute that user.")
 
-    if not user.privileges.can_restrict_members and user.id != OWNER_ID:
-        await q.answer(
-            "You don't have enough permission to do this!\nStay in your limits!",
-            show_alert=True,
-        )
-        return
-    whoo = await c.get_users(user_id)
-    try:
-        await q.message.chat.unban_member(user_id)
-    except RPCError as e:
-        await q.message.edit_text(f"Error: {e}")
-        return
-    await q.message.edit_text(f"{q.from_user.mention} unmuted {whoo.mention}!")
-    return
+    return ""
 
 
 # <=================================================== HELP ====================================================>
 
 
 __help__ = """
-➠ *Admin only:*
-
-» /mute: Mute the user replied to or mentioned.
-
-» /smute: silences a user without notifying. Can also be used as a reply, muting the replied to user.
-
-» /dmute: Mute a user by reply, and delete their message.
+➠ *Admins only:*
 
-» /tmute <userhandle> x(m/h/d): mutes a user for x time. (via handle, or reply). m = minutes, h = hours, d = days.
+» /mute <userhandle>: silences a user. Can also be used as a reply, muting the replied to user.
 
-» /stmute <userhandle> x(m/h/d): mutes a user for x time without notifying. (via handle, or reply). m = minutes, h = hours, d = days.
+» /tmute <userhandle> x(m/h/d): mutes a user for x time. (via handle, or reply). `m` = `minutes`, `h` = `hours`, `d` = `days`.
 
-» /dtmute <userhandle> x(m/h/d): Mute the replied user, and delete the replied message. (via reply). m = minutes, h = hours, d = days.
+» /unmute <userhandle>: unmutes a user. Can also be used as a reply, muting the replied to user.
+"""
 
-» /unmute: Unmutes the user mentioned or replied to.
+# <================================================ HANDLER =======================================================>
+MUTE_HANDLER = CommandHandler("mute", mute, block=False)
+UNMUTE_HANDLER = CommandHandler("unmute", unmute, block=False)
+TEMPMUTE_HANDLER = CommandHandler(["tmute", "tempmute"], temp_mute, block=False)
 
-➠ *Example:*
-» `/mute @username`; this mutes a user."""
+function(MUTE_HANDLER)
+function(UNMUTE_HANDLER)
+function(TEMPMUTE_HANDLER)
 
 __mod_name__ = "MUTE"
+__handlers__ = [MUTE_HANDLER, UNMUTE_HANDLER, TEMPMUTE_HANDLER]
 # <================================================ END =======================================================>