fixes

Powers/plugins/bans.py

@@ -973,6 +973,13 @@ async def unbanbutton(c: Gojo, q: CallbackQuery):
     user_id = int(splitter[1])
     user = await q.message.chat.get_member(q.from_user.id)
 
+    if not user:
+        await q.answer(
+            "You don't have enough permission to do this!\nStay in your limits!",
+            show_alert=True,
+        )
+        return
+
     if not user.privileges.can_restrict_members and q.from_user.id != OWNER_ID:
         await q.answer(
             "You don't have enough permission to do this!\nStay in your limits!",

Powers/plugins/flood.py

@@ -330,30 +330,46 @@ dic = {}
 @Gojo.on_message(filters.all & ~filters.bot | ~filters.private, 10)
 async def flood_watcher(c: Gojo, m: Message):
     c_id = m.chat.id
+    
     if not m.chat:
         return
+    
     Flood = Floods()
+    
     try:
         u_id = m.from_user.id
     except AttributeError:
         return # Get this error when the message received is not by an user and return
+    
     is_flood = Flood.is_chat(c_id)
+    
     if not is_flood:
         return # return of chat is not in anti flood protection
+    
     app_users = Approve(m.chat.id).list_approved()
+    
     if u_id in {i[0] for i in app_users}:
         return #return if the user is approved
+    
     if not is_flood or u_id in SUPPORT_STAFF:
         return #return if the user is in support_staff
-    user_status = (await m.chat.get_member(m.from_user.id)).status
+    
+    try:
+        user_status = (await m.chat.get_member(m.from_user.id)).status
+    except Exception:
+        return
+    
     if user_status in [CMS.OWNER, CMS.ADMINISTRATOR]:
         return #return if the user is owner or admin
+    
     action = is_flood[2]
     limit = int(is_flood[0])
     within = int(is_flood[1])
+    
     if not len(dic):
         z = {c_id : {u_id : [[],[]]}}
         dic.update(z)
+    
     try:
       dic[c_id] # access and check weather the c_id present or not
     except KeyError:
@@ -365,14 +381,18 @@ async def flood_watcher(c: Gojo, m: Message):
     except KeyError:
       z = {u_id : [[],[]]}
       dic[c_id].update(z) # make the dic something like {c_id : {u_id : [[for time],[for msg]]}}
+    
     sec = round(time.time())
+    
     try:
         dic[c_id][u_id][0].append(sec)
         dic[c_id][u_id][1].append("x")
     except KeyError:
         dic[c_id].update({u_id : [[sec], ["x"]]})
+    
     x = int(dic[c_id][u_id][0][0])
     y = int(dic[c_id][u_id][0][-1])
+    
     if len(dic[c_id][u_id][1]) == limit:
         if y-x <= within:
             if action == "ban":

Powers/plugins/muting.py

@@ -632,6 +632,13 @@ async def unmutebutton(c: Gojo, q: CallbackQuery):
     user_id = int(splitter[1])
     user = await q.message.chat.get_member(q.from_user.id)
 
+    if not user:
+        await q.answer(
+            "You don't have enough permission to do this!\nStay in your limits!",
+            show_alert=True,
+        )
+        return
+
     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!",

Powers/plugins/utils.py

@@ -287,11 +287,11 @@ async def github(_, m: Message):
 
 
 pattern = re.compile(r"^text/|json$|yaml$|xml$|toml$|x-sh$|x-shellscript$")
-BASE = "https://nekobin.com/"
+BASE = "https://batbin.me/"
 
 
 def paste(content: str):
-    resp = resp_post(f"{BASE}api/documents", data=content)
+    resp = resp_post(f"{BASE}api/v2/paste", data=content)
     if resp.status_code != 200:
         return
     resp = resp.json()

Powers/plugins/watchers.py

@@ -1,3 +1,4 @@
+from datetime import datetime, timedelta
 from re import escape as re_escape
 from time import time
 from traceback import format_exc
@@ -53,117 +54,120 @@ async def bl_watcher(_, m: Message):
         return
 
     bl_db = Blacklist(m.chat.id)
+    try:
+        async def perform_action_blacklist(m: Message, action: str, trigger: str):
+            if action == "kick":
+                tim = datetime.now() + timedelta(minutes=45)
+                await m.chat.ban_member(m.from_user.id, tim)
+                await m.reply_text(
+                    text="Kicked {user} for sending a blacklisted word!".format(
+                        user=m.from_user.username or f"<b>{m.from_user.first_name}</b>",
+                    ),
+                )
 
-    async def perform_action_blacklist(m: Message, action: str, trigger: str):
-        if action == "kick":
-            await m.chat.kick_member(m.from_user.id, int(time() + 45))
-            await m.reply_text(
-                text="Kicked {user} for sending a blacklisted word!".format(
-                    user=m.from_user.username or f"<b>{m.from_user.first_name}</b>",
-                ),
-            )
+            elif action == "ban":
+                (
+                    await m.chat.ban_member(
+                        m.from_user.id,
+                    )
+                )
+                await m.reply_text(
+                    text="Banned {user} for sending a blacklisted word!".format(
+                        user=m.from_user.username or f"<b>{m.from_user.first_name}</b>",
+                    ),
+                )
 
-        elif action == "ban":
-            (
-                await m.chat.kick_member(
+            elif action == "mute":
+                await m.chat.restrict_member(
                     m.from_user.id,
+                    ChatPermissions(),
                 )
-            )
-            await m.reply_text(
-                text="Banned {user} for sending a blacklisted word!".format(
-                    user=m.from_user.username or f"<b>{m.from_user.first_name}</b>",
-                ),
-            )
 
-        elif action == "mute":
-            await m.chat.restrict_member(
-                m.from_user.id,
-                ChatPermissions(),
-            )
-
-            await m.reply_text(
-                text="Muted {user} for sending a blacklisted word!".format(
-                    user=m.from_user.username or f"<b>{m.from_user.first_name}</b>",
-                ),
-            )
+                await m.reply_text(
+                    text="Muted {user} for sending a blacklisted word!".format(
+                        user=m.from_user.username or f"<b>{m.from_user.first_name}</b>",
+                    ),
+                )
 
-        elif action == "warn":
-            warns_settings_db = WarnSettings(m.chat.id)
-            warns_db = Warns(m.chat.id)
-            warn_settings = warns_settings_db.get_warnings_settings()
-            warn_reason = bl_db.get_reason()
-            _, num = warns_db.warn_user(m.from_user.id, warn_reason)
-            if num >= warn_settings["warn_limit"]:
-                if warn_settings["warn_mode"] == "kick":
-                    await m.chat.ban_member(
-                        m.from_user.id,
-                        until_date=int(time() + 45),
+            elif action == "warn":
+                warns_settings_db = WarnSettings(m.chat.id)
+                warns_db = Warns(m.chat.id)
+                warn_settings = warns_settings_db.get_warnings_settings()
+                warn_reason = bl_db.get_reason()
+                _, num = warns_db.warn_user(m.from_user.id, warn_reason)
+                if num >= warn_settings["warn_limit"]:
+                    if warn_settings["warn_mode"] == "kick":
+                        await m.chat.ban_member(
+                            m.from_user.id,
+                            until_date=int(time() + 45),
+                        )
+                        action = "kicked"
+                    elif warn_settings["warn_mode"] == "ban":
+                        await m.chat.ban_member(m.from_user.id)
+                        action = "banned"
+                    elif warn_settings["warn_mode"] == "mute":
+                        await m.chat.restrict_member(m.from_user.id, ChatPermissions())
+                        action = "muted"
+                    await m.reply_text(
+                        (
+                            f"Warnings {num}/{warn_settings['warn_limit']}\n"
+                            f"{(await mention_html(m.from_user.first_name, m.from_user.id))} has been <b>{action}!</b>"
+                        ),
                     )
-                    action = "kicked"
-                elif warn_settings["warn_mode"] == "ban":
-                    await m.chat.ban_member(m.from_user.id)
-                    action = "banned"
-                elif warn_settings["warn_mode"] == "mute":
-                    await m.chat.restrict_member(m.from_user.id, ChatPermissions())
-                    action = "muted"
+                    return
                 await m.reply_text(
                     (
-                        f"Warnings {num}/{warn_settings['warn_limit']}\n"
-                        f"{(await mention_html(m.from_user.first_name, m.from_user.id))} has been <b>{action}!</b>"
+                        f"{(await mention_html(m.from_user.first_name, m.from_user.id))} warned {num}/{warn_settings['warn_limit']}\n"
+                        # f"Last warn was for:\n<i>{warn_reason}</i>"
+                        f"Last warn was for:\n<i>{warn_reason.format(trigger)}</i>"
                     ),
                 )
-                return
-            await m.reply_text(
-                (
-                    f"{(await mention_html(m.from_user.first_name, m.from_user.id))} warned {num}/{warn_settings['warn_limit']}\n"
-                    # f"Last warn was for:\n<i>{warn_reason}</i>"
-                    f"Last warn was for:\n<i>{warn_reason.format(trigger)}</i>"
-                ),
-            )
-        return
+            return
 
-    if m.from_user.id in SUPPORT_STAFF:
-        # Don't work on Support Staff!
-        return
+        if m.from_user.id in SUPPORT_STAFF:
+            # Don't work on Support Staff!
+            return
 
-    # If no blacklists, then return
-    chat_blacklists = bl_db.get_blacklists()
-    if not chat_blacklists:
-        return
+        # If no blacklists, then return
+        chat_blacklists = bl_db.get_blacklists()
+        if not chat_blacklists:
+            return
 
-    # Get admins from admin_cache, reduces api calls
-    try:
-        admin_ids = {i[0] for i in ADMIN_CACHE[m.chat.id]}
-    except KeyError:
-        admin_ids = await admin_cache_reload(m, "blacklist_watcher")
+        # Get admins from admin_cache, reduces api calls
+        try:
+            admin_ids = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+        except KeyError:
+            admin_ids = await admin_cache_reload(m, "blacklist_watcher")
 
-    if m.from_user.id in admin_ids:
-        return
+        if m.from_user.id in admin_ids:
+            return
 
-    # Get approved user from cache/database
-    app_users = Approve(m.chat.id).list_approved()
-    if m.from_user.id in {i[0] for i in app_users}:
-        return
+        # Get approved user from cache/database
+        app_users = Approve(m.chat.id).list_approved()
+        if m.from_user.id in {i[0] for i in app_users}:
+            return
 
-    # Get action for blacklist
-    action = bl_db.get_action()
-    for trigger in chat_blacklists:
-        pattern = r"( |^|[^\w])" + re_escape(trigger) + r"( |$|[^\w])"
-        match = await regex_searcher(pattern, m.text.lower())
-        if not match:
-            continue
-        if match:
-            try:
-                await perform_action_blacklist(m, action, trigger)
-                LOGGER.info(
-                    f"{m.from_user.id} {action}ed for using blacklisted word {trigger} in {m.chat.id}",
-                )
-                await m.delete()
-            except RPCError as ef:
-                LOGGER.error(ef)
-                LOGGER.error(format_exc())
-            break
-    return
+        # Get action for blacklist
+        action = bl_db.get_action()
+        for trigger in chat_blacklists:
+            pattern = r"( |^|[^\w])" + re_escape(trigger) + r"( |$|[^\w])"
+            match = await regex_searcher(pattern, m.text.lower())
+            if not match:
+                continue
+            if match:
+                try:
+                    await perform_action_blacklist(m, action, trigger)
+                    LOGGER.info(
+                        f"{m.from_user.id} {action}ed for using blacklisted word {trigger} in {m.chat.id}",
+                    )
+                    await m.delete()
+                except RPCError as ef:
+                    LOGGER.error(ef)
+                    LOGGER.error(format_exc())
+                break
+        return
+    except Exception:
+        return
 
 
 

Powers/utils/custom_filters.py

@@ -219,7 +219,7 @@ async def restrict_check_func(_, __, m: Message or CallbackQuery):
 
     user = await m.chat.get_member(m.from_user.id)
 
-    if user.status in [CMS.ADMINISTRATOR, CMS.OWNER] and user.privileges.can_restrict_members:
+    if user and user.status in [CMS.ADMINISTRATOR, CMS.OWNER] and user.privileges.can_restrict_members:
         status = True
     else:
         status = False