Various Fixes

wbb/modules/admin.py

@@ -1,6 +1,6 @@
 from pyrogram import filters
 from pyrogram.types import ChatPermissions
-from wbb import OWNER_ID, SUDO_USER_ID, app
+from wbb import OWNER_ID, SUDOERS, app
 from wbb.utils.botinfo import BOT_ID
 from wbb.utils.errors import capture_err
 
@@ -15,17 +15,30 @@ __HELP__ = '''/ban - Ban A User
 /mute - Mute A User
 /unmute - Unmute A User'''
 
-SUDO = [OWNER_ID, SUDO_USER_ID]
 
-# Get List Of Admins In A Chat
 
 
-async def list_admins(group_id):
-    list_of_admins = []
-    async for member in app.iter_chat_members(
-            group_id, filter="administrators"):
-        list_of_admins.append(member.user.id)
-    return list_of_admins
+async def member_permissions(chat_id, user_id):
+    perms = []
+    member = (await app.get_chat_member(chat_id, user_id))
+    if member.can_post_messages:
+        perms.append("can_post_messages")
+    if member.can_edit_messages:
+        perms.append("can_edit_messages")
+    if member.can_delete_messages:
+        perms.append("can_delete_messages")
+    if member.can_restrict_members:
+        perms.append("can_restrict_members")
+    if member.can_promote_members:
+        perms.append("can_promote_members")
+    if member.can_change_info:
+        perms.append("can_change_info")
+    if member.can_invite_users:
+        perms.append("can_invite_users")
+    if member.can_pin_messages:
+        perms.append("can_pin_messages")
+    return perms
+
 
 # Get List Of Members In A Chat
 
@@ -34,6 +47,7 @@ async def list_members(group_id):
     list_of_members = []
     async for member in app.iter_chat_members(group_id):
         list_of_members.append(member.user.id)
+
     return list_of_members
 
 # Purge Messages
@@ -43,45 +57,36 @@ async def list_members(group_id):
 @capture_err
 async def purge(client, message):
     message_ids = []
+    chat_id = message.chat.id
+    user_id = message.from_user.id
     if message.chat.type not in ("supergroup", "channel"):
         return
 
-    admins = await list_admins(message.chat.id)
-
-    if message.from_user.id in admins \
-            or message.from_user.id in SUDO:
-
-        chat_id = message.chat.id
-        from_user_id = message.from_user.id
-        if (await app.get_chat_member(chat_id,
-                                      from_user_id)).can_delete_messages \
-                or (await app.get_chat_member(chat_id, from_user_id)).status \
-                == 'creator' \
-                or message.from_user.id in SUDO:
-
-            if message.reply_to_message:
-                for a_s_message_id in range(
-                    message.reply_to_message.message_id,
-                    message.message_id
-                ):
-                    message_ids.append(a_s_message_id)
-                    if len(message_ids) == 100:
-                        await client.delete_messages(
-                            chat_id=message.chat.id,
-                            message_ids=message_ids,
-                            revoke=True
-                        )
-                        message_ids = []
-                if len(message_ids) > 0:
-                    await client.delete_messages(
-                        chat_id=message.chat.id,
+    permissions = await member_permissions(chat_id, user_id)
+
+    if "can_delete_messages" in permissions or user_id in SUDOERS:
+        if message.reply_to_message:
+            for a_s_message_id in range(
+                message.reply_to_message.message_id,
+                message.message_id
+            ):
+                message_ids.append(a_s_message_id)
+                if len(message_ids) == 100:
+                    await client.delete_messages(chat_id=chat_id,
                         message_ids=message_ids,
-                        revoke=True
-                    )
-            else:
-                await message.reply_text(
-                    "Reply To A Message To Delete It,"
-                    " Don't Make Fun Of Yourself!")
+                        revoke=True)
+
+                    message_ids = []
+            if len(message_ids) > 0:
+                await client.delete_messages(
+                    chat_id=chat_id,
+                    message_ids=message_ids,
+                    revoke=True
+                )
+        else:
+            await message.reply_text(
+                "Reply To A Message To Delete It,"
+                " Don't Make Fun Of Yourself!")
     else:
         await message.reply_text("Your Don't Have Enough Permissions!")
     await message.delete()
@@ -94,19 +99,17 @@ async def purge(client, message):
 @capture_err
 async def kick(_, message):
     try:
-        if (await app.get_chat_member(
-            message.chat.id, message.from_user.id)).status == 'creator' \
-            or (await app.get_chat_member(
-                message.chat.id, message.from_user.id)).can_restrict_members \
-                is True or message.from_user.id in SUDO:
-
+        from_user_id = message.from_user.id
+        chat_id = message.chat.id
+        permissions = await member_permissions(chat_id, from_user_id)
+        if "can_restrict_members" in permissions or from_user_id in SUDO:
             if len(message.command) == 2:
-                username = (message.text.split(None, 1)[1])
+                username = message.text.split(None, 1)[1]
                 if (await app.get_users(username)).id in SUDO:
                     await message.reply_text("You Wanna Kick The Elevated One?")
                 else:
                     if (await app.get_users(username)).id in \
-                            await list_members(message.chat.id):
+                            await list_members(chat_):
                         await message.chat.kick_member(username)
                         await message.chat.unban_member(username)
                         await message.reply_text(f"Kicked {username}")
@@ -115,12 +118,11 @@ async def kick(_, message):
                                                  " consider kicking yourself.")
 
             if len(message.command) == 1 and message.reply_to_message:
-                if message.reply_to_message.from_user.id in SUDO:
+                user_id = message.reply_to_message.from_user.id
+                if user_id in SUDO:
                     await message.reply_text("You Wanna Kick The Elevated One?")
                 else:
-                    if message.reply_to_message.from_user.id in \
-                            await list_members(message.chat.id):
-                        user_id = message.reply_to_message.from_user.id
+                    if user_id in await list_members(chat_id):
                         await message.reply_to_message.chat.kick_member(user_id)
                         await message.reply_to_message.chat.unban_member(user_id)
                         await message.reply_text("Kicked!")
@@ -136,19 +138,17 @@ async def kick(_, message):
 @capture_err
 async def ban(_, message):
     try:
-        if (await app.get_chat_member(
-            message.chat.id, message.from_user.id)).status == 'creator' \
-            or (await app.get_chat_member(
-                message.chat.id, message.from_user.id)).can_restrict_members \
-                is True or message.from_user.id in SUDO:
-
+        from_user_id = message.from_user.id
+        chat_id = message.chat.id
+        permissions = await member_permissions(chat_id, from_user_id)
+        if "can_restrict_members" in permissions or from_user_id in SUDO:
             if len(message.command) == 2:
-                username = (message.text.split(None, 1)[1])
+                username = message.text.split(None, 1)[1]
                 if (await app.get_users(username)).id in SUDO:
                     await message.reply_text("You Wanna Ban The Elevated One?")
                 else:
                     if (await app.get_users(username)).id in \
-                            await list_members(message.chat.id):
+                            await list_members(chat_id):
                         await message.chat.kick_member(username)
                         await message.reply_text(f"Banned! {username}")
                     else:
@@ -156,12 +156,11 @@ async def ban(_, message):
                                                  " consider banning yourself.")
 
             if len(message.command) == 1 and message.reply_to_message:
-                if message.reply_to_message.from_user.id in SUDO:
+                user_id = message.reply_to_message.from_user.id
+                if user_id in SUDO:
                     await message.reply_text("You Wanna Ban The Elevated One?")
                 else:
-                    if message.reply_to_message.from_user.id in \
-                            await list_members(message.chat.id):
-                        user_id = message.reply_to_message.from_user.id
+                    if user_id in await list_members(chat_id):
                         await message.reply_to_message.chat.kick_member(user_id)
                         await message.reply_text("Banned!")
                     else:
@@ -177,14 +176,12 @@ async def ban(_, message):
 @capture_err
 async def unban(_, message):
     try:
-        if (await app.get_chat_member(
-            message.chat.id, message.from_user.id)).status == 'creator' \
-            or (await app.get_chat_member(
-                message.chat.id, message.from_user.id)).can_restrict_members \
-                is True or message.from_user.id in SUDO:
-
+        from_user_id = message.from_user.id
+        chat_id = message.chat.id
+        permissions = await member_permissions(chat_id, from_user_id)
+        if "can_restrict_members" in permissions or from_user_id in sudo:
             if len(message.command) == 2:
-                username = (message.text.split(None, 1)[1])
+                username = message.text.split(None, 1)[1]
                 if (await app.get_users(username)).id not in \
                         await list_members(message.chat.id):
                     await message.chat.unban_member(username)
@@ -194,9 +191,9 @@ async def unban(_, message):
                                              " consider banning yourself.")
 
             if len(message.command) == 1 and message.reply_to_message:
-                if message.reply_to_message.from_user.id not in \
-                        await list_members(message.chat.id):
-                    user_id = message.reply_to_message.from_user.id
+                user_id = message.reply_to_message.from_user.id
+                if user_id not in \
+                        await list_members(chat_id):
                     await message.chat.unban_member(user_id)
                     await message.reply_text("Unbanned!")
                 else:
@@ -208,29 +205,22 @@ async def unban(_, message):
 # Delete messages
 
 
-@app.on_message(filters.command("del"))
+@app.on_message(filters.command("del") & ~filters.edited)
 @capture_err
 async def delete(_, message):
     if not message.reply_to_message:
         await message.reply_text("Reply To A Message To Delete It")
         return
     try:
-        admins = await list_admins(message.chat.id)
-        chat_id = message.chat.id
         from_user_id = message.from_user.id
-
-        if message.from_user.id in admins \
-                or message.from_user.id in SUDO:
-            if (await app.get_chat_member(chat_id,
-                                          from_user_id)).can_delete_messages \
-                or (await app.get_chat_member(chat_id, from_user_id)).status \
-                == 'creator' \
-                    or message.from_user.id in SUDO:
-                await message.reply_to_message.delete()
-                await message.delete()
+        chat_id = message.chat.id
+        permissions = await member_permissions(chat_id, from_user_id)
+        if "can_delete_messages" in permissions or from_user_id in sudo:
+            await message.reply_to_message.delete()
+            await message.delete()
         else:
             await message.reply_text("You Don't Have Enough Permissions,"
-                                     + " Consider Wiping Yourself Off The Existence!")
+                                     + " Consider Deleting Yourself!")
     except Exception as e:
         await message.reply_text(str(e))
 
@@ -241,55 +231,39 @@ async def delete(_, message):
 @capture_err
 async def promote(_, message):
     try:
-        admins = await list_admins(message.chat.id)
-        chat_id = message.chat.id
         from_user_id = message.from_user.id
-
-        if (await app.get_chat_member(chat_id,
-                                      BOT_ID)).can_promote_members:
-            if message.from_user.id in admins \
-                    or message.from_user.id in SUDO:
-                if (await app.get_chat_member(chat_id,
-                                              from_user_id)).can_promote_members \
-                    or (await app.get_chat_member(chat_id, from_user_id)).status \
-                    == 'creator' \
-                        or message.from_user.id in SUDO:
-
-                    if not message.reply_to_message and len(message.command) == 2:
-                        username = message.text.split(None, 1)[1]
-                        user_id = (await app.get_users(username)).id
-                        await message.chat.promote_member(
-                            user_id=user_id,
-                            can_change_info=True,
-                            can_invite_users=True,
-                            can_delete_messages=True,
-                            can_restrict_members=False,
-                            can_pin_messages=True,
-                            can_promote_members=True)
-                        await message.reply_text('Promoted!')
-
-                    elif message.reply_to_message:
-                        user_id = message.reply_to_message.from_user.id
-                        await message.chat.promote_member(
-                            user_id=user_id,
-                            can_change_info=True,
-                            can_invite_users=True,
-                            can_delete_messages=True,
-                            can_restrict_members=False, 
-                            can_pin_messages=True, 
-                            can_promote_members=True)
-                        await message.reply_text('Promoted!')
-                    else:
-                        await message.reply_text("Reply To A User's Message Or Give A Username To Promote.")
-                else:
-                    await message.reply_text("Yeah, I Can See You're An Admin,"
-                                             + " But You Don't Have Permissions"
-                                             + " To Promote Someone.")
+        chat_id = message.chat.id
+        permissions = await member_permissions(chat_id, from_user_id)
+        if "can_promote_members" in permissions or from_user_id in sudo:
+            if len(message.command) == 2:
+                username = message.text.split(None, 1)[1]
+                user_id = (await app.get_users(username)).id
+                await message.chat.promote_member(
+                    user_id=user_id,
+                    can_change_info=True,
+                    can_invite_users=True,
+                    can_delete_messages=True,
+                    can_restrict_members=False,
+                    can_pin_messages=True,
+                    can_promote_members=True)
+                await message.reply_text('Promoted!')
+
+            elif len(message.command) == 1 and message.reply_to_message:
+                user_id = message.reply_to_message.from_user.id
+                await message.chat.promote_member(
+                    user_id=user_id,
+                    can_change_info=True,
+                    can_invite_users=True,
+                    can_delete_messages=True,
+                    can_restrict_members=False, 
+                    can_pin_messages=True, 
+                    can_promote_members=True)
+                await message.reply_text('Promoted!')
             else:
-                await message.reply_text("You're Not An Admin, Want A Good Ban?")
+                await message.reply_text("Reply To A User's Message Or Give A Username To Promote.")
+
         else:
-            await message.reply_text("Well, Your Know What?, I'M NOT AN ADMIN!"
-                                     + " MAKE ME ADMIN!")
+            await message.reply_text("You're Not An Admin, Want A Good Ban?")
     except Exception as e:
         await message.reply_text(str(e))
 
@@ -303,19 +277,11 @@ async def pin(_, message):
         await message.reply_text("Reply To A Message To Pin.")
         return
     try:
-        admins = await list_admins(message.chat.id)
-        chat_id = message.chat.id
         from_user_id = message.from_user.id
-
-        if message.from_user.id in admins \
-                or message.from_user.id in SUDO:
-            if (await app.get_chat_member(chat_id,
-                                          from_user_id)).can_pin_messages \
-                or (await app.get_chat_member(chat_id, from_user_id)).status \
-                == 'creator' \
-                    or message.from_user.id in SUDO:
-
-                await message.reply_to_message.pin(disable_notification=True)
+        chat_id = message.chat.id
+        permissions = await member_permissions(chat_id, from_user_id)
+        if "can_pin_messages" in permissions or from_user_id in sudo:
+            await message.reply_to_message.pin(disable_notification=True)
         else:
             await message.reply_text("You're Not An Admin, Stop Spamming!")
     except Exception as e:
@@ -328,20 +294,16 @@ async def pin(_, message):
 @app.on_message(filters.command("mute") & ~filters.edited)
 @capture_err
 async def mute(_, message):
+    if not message.reply_to_message:
+        await message.reply_text("Reply To A User's Message!")
+        return
     try:
         chat_id = message.chat.id
         from_user_id = message.from_user.id
-        if not message.reply_to_message:
-            await message.reply_text("Reply To A User's Message!")
-            return
-
-        if (await app.get_chat_member(chat_id,
-                                      from_user_id)).can_restrict_members \
-            or (await app.get_chat_member(chat_id, from_user_id)).status \
-            == 'creator' \
-                or message.from_user.id in SUDO:
-            victim = message.reply_to_message.from_user.id
-            await message.chat.restrict_member(victim,
+        permissions = await member_permissions(chat_id, from_user_id)
+        if "can_restrict_members" in permissions or from_user_id in sudo:
+            user_id = message.reply_to_message.from_user.id
+            await message.chat.restrict_member(user_id,
                                                permissions=ChatPermissions())
             await message.reply_text("Muted!")
         else:
@@ -355,21 +317,52 @@ async def mute(_, message):
 @app.on_message(filters.command("unmute") & ~filters.edited)
 @capture_err
 async def unmute(_, message):
+    if not message.reply_to_message:
+        await message.reply_text("Reply To A User's Message!")
+        return
     try:
         chat_id = message.chat.id
         from_user_id = message.from_user.id
-        if not message.reply_to_message:
-            await message.reply_text("Reply To A User's Message!")
-            return
-        if (await app.get_chat_member(chat_id,
-                                      from_user_id)).can_restrict_members \
-            or (await app.get_chat_member(chat_id, from_user_id)).status \
-            == 'creator' \
-                or message.from_user.id in SUDO:
-            victim = message.reply_to_message.from_user.id
-            await message.chat.unban_member(victim)
+        permissions = await member_permissions(chat_id, from_user_id)
+        if "can_restrict_members" in permissions or from_user_id in sudo:
+            user_id = message.reply_to_message.from_user.id
+            await message.chat.unban_member(user_id)
             await message.reply_text("Unmuted!")
         else:
             await message.reply_text("Get Yourself An Admin Tag!")
     except Exception as e:
         await message.reply_text(str(e))
+
+
+# Ban deleted accounts
+
+
+@app.on_message(filters.command("ban_ghosts"))
+async def ban_deleted_accounts(_, message)
+    try:
+        from_user_id = message.from_user.id
+        chat_id = message.chat.id
+        permissions = await member_permissions(chat_id, from_user_id)
+        if "can_restrict_members" in permissions or from_user_id in SUDO:
+            deleted_users = []
+            banned_users = 0
+            async for i in app.iter_chat_members(chat_id):
+                if i.user.is_deleted:
+                    deleted_users.append(i.user.id)
+            if len(deleted_users) > 0:
+                for deleted_user in deleted_users:
+                    try:
+                        await message.chat.kick_member(deleted_user)
+                    except Exception as e:
+                        print(str(e))
+                        pass
+                    banned_users += 1
+                await message.reply_text(f"Banned {banned_users} Deleted Accounts")
+            else:
+                await message.reply_text("No Deleted Accounts In This Chat")
+                return
+        else:
+            await message.reply_text("You Don't Have Enough Permissions")
+    except Exception as e:
+        await message.reply_text(str(e))
+        print(str(e))