progress...

Powers/database/locks_db.py

@@ -5,7 +5,7 @@ from Powers.database import MongoDB
 
 INSERTION_LOCK = RLock()
 
-lock_t = ["anti_c_send", "anti_fwd", "anti_fwd_u", "anti_fwd_c", "anti_links"]
+lock_t = ["bot", "anti_c_send", "anti_fwd", "anti_fwd_u", "anti_fwd_c", "anti_links"]
 class LOCKS(MongoDB):
     """Class to store locks"""
     
@@ -16,7 +16,7 @@ class LOCKS(MongoDB):
 
     def insert_lock_channel(self, chat: int, locktype: str):
         """
-        locktypes: all, anti_c_send, anti_fwd, anti_fwd_u, anti_fwd_c, anti_links
+        locktypes: all, bot, anti_c_send, anti_fwd, anti_fwd_u, anti_fwd_c, anti_links
         """
         if locktype == "all":
             for i in lock_t:
@@ -39,7 +39,7 @@ class LOCKS(MongoDB):
 
     def remove_lock_channel(self, chat: int, locktype: str):
         """
-        locktypes: all, anti_c_send, anti_fwd, anti_fwd_u, anti_fwd_c, anti_links
+        locktypes: all, bot, anti_c_send, anti_fwd, anti_fwd_u, anti_fwd_c, anti_links
         """
         if locktype == "all":
             for i in lock_t:
@@ -55,23 +55,34 @@ class LOCKS(MongoDB):
         else:
             return False
 
-    def get_lock_channel(self, locktype: str="all"):
+    def get_lock_channel(self, locktype: str="all", chat:int = 0):
         """
-        locktypes: anti_c_send, anti_fwd, anti_fwd_u, anti_fwd_c, anti_links
+        locktypes: anti_c_send, anti_fwd, anti_fwd_u, anti_fwd_c, anti_links, bot
         """
-        if locktype not in ["anti_c_send","anti_fwd","anti_fwd_u","anti_fwd_c","anti_links", "all"]:
+        if locktype not in ["anti_c_send","anti_fwd","anti_fwd_u","anti_fwd_c","anti_links", "bot", "all"]:
             return False
         else:
             if locktype == "all":
                 find = {}
             else:
                 find = {"locktype":locktype}
-            curr = self.find_all(find)
-            if not curr:
-                list_ = []
-            else:
-                list_ = [i["chat_id"] for i in curr]
-            return list_
+            if chat:
+                if find:
+                    curr = self.find_one({"chat_id":chat, "locktype":locktype})
+                    return bool(curr)
+                else:
+                    to_return = []
+                    for i in lock_t:
+                        curr = self.find_one({"chat_id":chat, "locktype":i})
+                        to_return.append(bool(curr))
+                    return all(to_return)
+            else:    
+                curr = self.find_all(find)
+                if not curr:
+                    list_ = []
+                else:
+                    list_ = [i["chat_id"] for i in curr]
+                return list_
 
     def merge_u_and_c(self, chat: int, locktype: str):
         if locktype == "anti_fwd_u":

Powers/plugins/auto_join.py

@@ -1,3 +1,5 @@
+from traceback import format_exc
+
 from pyrogram import filters
 from pyrogram.enums import ChatMemberStatus as CMS
 from pyrogram.types import CallbackQuery, ChatJoinRequest
@@ -5,6 +7,7 @@ from pyrogram.types import InlineKeyboardButton as ikb
 from pyrogram.types import InlineKeyboardMarkup as ikm
 from pyrogram.types import Message
 
+from Powers import LOGGER
 from Powers.bot_class import Gojo
 from Powers.database.autojoin_db import AUTOJOIN
 from Powers.supports import get_support_staff
@@ -21,8 +24,15 @@ async def accept_join_requests(c: Gojo, m: Message):
     a_j = AUTOJOIN()
 
     try:
-        await 
-
+        status = (await m.chat.get_member(c.me.id)).status
+        if status != CMS.ADMINISTRATOR:
+            await m.reply_text("I should be admin to accept and reject join requests")
+            return
+    except Exception as ef:
+        await m.reply_text(f"Some error occured, report it using `/bug`\n<b>Error:</b> <code>{ef}</code>")
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+        return
     if len(split) == 1:
         txt = "**USAGE**\n/joinreq [on | off]"
         await m.reply_text(txt)
@@ -91,8 +101,12 @@ async def join_request_handler(c: Gojo, j: ChatJoinRequest):
     if not join_type:
         return
     if join_type == "auto" or user in SUPPORT_STAFF:
-        await c.approve_chat_join_request(chat,user)
-
+        try:
+            await c.approve_chat_join_request(chat,user)
+        except Exception as ef:
+            await c.send_message(chat,f"Some error occured while approving request, report it using `/bug`\n<b>Error:</b> <code>{ef}</code>")
+            LOGGER.error(ef)
+            LOGGER.error(format_exc())
     elif join_type == "manual":
         txt = "New join request is available\n**USER's INFO**\n"
         txt += f"Name: {userr.first_name} {userr.last_name if userr.last_name else ''}"
@@ -113,6 +127,7 @@ async def join_request_handler(c: Gojo, j: ChatJoinRequest):
 @Gojo.on_callback_query(filters.regex("^accept_joinreq_uest_") | filters.regex("^decline_joinreq_uest_"))
 async def accept_decline_request(c:Gojo, q: CallbackQuery):
     user_id = q.from_user.id
+    chat = q.message.chat.id
     user_status = (await q.message.chat.get_member(user_id)).status
     if user_status not in {CMS.OWNER, CMS.ADMINISTRATOR}:
         await q.answer(
@@ -127,11 +142,22 @@ async def accept_decline_request(c:Gojo, q: CallbackQuery):
     data = split[0]
 
     if data == "accept":
-        await c.approve_chat_join_request(chat,user)
-        await q.answer(f"APPROVED: {user}",True)
+        try:
+            await c.approve_chat_join_request(chat,user)
+            await q.answer(f"APPROVED: {user}",True)
+        except Exception as ef:
+            await c.send_message(chat,f"Some error occured while approving request, report it using `/bug`\n<b>Error:</b> <code>{ef}</code>")
+            LOGGER.error(ef)
+            LOGGER.error(format_exc())
+            
     elif data == "decline":
-        await c.decline_chat_join_request(chat,user)
-        await q.answer(f"DECLINED: {user}")
+        try:
+            await c.decline_chat_join_request(chat,user)
+            await q.answer(f"DECLINED: {user}")
+        except Exception as ef:
+            await c.send_message(chat,f"Some error occured while approving request, report it using `/bug`\n<b>Error:</b> <code>{ef}</code>")
+            LOGGER.error(ef)
+            LOGGER.error(format_exc())
 
     return
 

Powers/plugins/birthday.py

@@ -177,7 +177,7 @@ async def cant_recall_it(c: Gojo, m: Message):
     u_dob = give_date(result["dob"])
     formatted = str(u_dob.strftime('%d' + '%B %Y'))[2:-5]
     day = int(result["dob"].split('/')[0])
-    suffix = {1: 'st', 2: 'nd', 3: 'rd'}.get(day if day < 20 else day % 10, 'th')
+    suffix = {1: 'st', 2: 'nd', 3: 'rd'}.get(day % 10, 'th')
     bday_on = f"{day}{suffix} {formatted}"
     if u_dob.month < curr.month:
         next_b = date(curr.year + 1, u_dob.month, u_dob.day)

Powers/plugins/flood.py

@@ -20,7 +20,6 @@ from Powers.utils.extras import BAN_GIFS, KICK_GIFS, MUTE_GIFS
 from Powers.utils.kbhelpers import ikb
 from Powers.vars import Config
 
-
 on_key = ["on", "start", "disable"]
 off_key = ["off", "end", "enable", "stop"]
 

Powers/plugins/locks.py

@@ -1,8 +1,10 @@
 from asyncio import sleep
+from datetime import datetime, timedelta
 from traceback import format_exc
 
 from pyrogram import filters
 from pyrogram.enums import MessageEntityType as MET
+from pyrogram.enums import MessageServiceType as MST
 from pyrogram.errors import ChatAdminRequired, ChatNotModified, RPCError
 from pyrogram.types import ChatPermissions, Message
 
@@ -124,6 +126,13 @@ async def lock_perm(c: Gojo, m: Message):
     elif lock_type == "pin":
         pin = False
         perm = "pin"
+    elif lock_type == "bot":
+        curr = lock.insert_lock_channel(m.chat.id,"bot")
+        if not curr:
+            await m.reply_text("It is already on")
+            return
+        await m.reply_text("Restricted adding bots in the chat.")
+        return
     elif lock_type in ["links", "url"]:
         curr = lock.insert_lock_channel(m.chat.id, "anti_links")
         if not curr:
@@ -202,26 +211,15 @@ async def view_locks(_, m: Message):
         if val:
             return "✅"
         return "❌"
-
+    
     lock = LOCKS()
-    anti_c_send = lock.get_lock_channel("anti_c_send")
-    anti_forward = lock.get_lock_channel("anti_fwd")
-    anti_forward_u = lock.get_lock_channel("anti_fwd_u")
-    anti_forward_c = lock.get_lock_channel("anti_fwd_c")
-    anti_links = lock.get_lock_channel("anti_links")
-    anon = False
-    if m.chat.id in anti_c_send:
-        anon = True
-    anti_f = anti_f_u = anti_f_c = False
-    if m.chat.id in anti_forward:
-        anti_f = True
-    if m.chat.id in anti_forward_u:
-        anti_f_u = True
-    if m.chat.id in anti_forward_c:
-        anti_f_c = True
-    antil = False
-    if m.chat.id in anti_links:
-        antil = True
+    anon= lock.get_lock_channel("anti_c_send", m.chat.id)
+    anti_f = lock.get_lock_channel("anti_fwd",  m.chat.id)
+    anti_f_u = lock.get_lock_channel("anti_fwd_u",  m.chat.id)
+    anti_f_c = lock.get_lock_channel("anti_fwd_c",  m.chat.id)
+    antil = lock.get_lock_channel("anti_links",  m.chat.id)
+    bots = lock.get_lock_channel("bot",  m.chat.id)
+
     vmsg = await convert_to_emoji(v_perm.can_send_messages)
     vmedia = await convert_to_emoji(v_perm.can_send_media_messages)
     vother = await convert_to_emoji(v_perm.can_send_other_messages)
@@ -235,6 +233,7 @@ async def view_locks(_, m: Message):
     vantiu = await convert_to_emoji(anti_f_u)
     vantic = await convert_to_emoji(anti_f_c)
     vantil = await convert_to_emoji(antil)
+    vantibot = await convert_to_emoji(bots)
 
     if v_perm is not None:
         try:
@@ -255,7 +254,8 @@ async def view_locks(_, m: Message):
       <b>Can forward:</b> {vanti}
       <b>Can forward from user:</b> {vantiu}
       <b>Can forward from channel and chats:</b> {vantic}
-      <b>Can send links:</b> {antil}
+      <b>Can send links:</b> {vantil}
+      <b>Can send links:</b> {vantibot}
       """
             LOGGER.info(f"{m.from_user.id} used locks cmd in {m.chat.id}")
             await chkmsg.edit_text(permission_view_str)
@@ -278,8 +278,8 @@ async def unlock_perm(c: Gojo, m: Message):
         await m.reply_text(text="Specify a permission to unlock!")
         return
 
+    lock = LOCKS()
     if unlock_type == "all":
-        lock = LOCKS()
         try:
             await c.set_chat_permissions(
                 chat_id,
@@ -359,6 +359,12 @@ async def unlock_perm(c: Gojo, m: Message):
     elif unlock_type == "pin":
         upin = True
         uperm = "pin"
+    elif unlock_type == "bot":
+        curr = lock.remove_lock_channel(m.chat.id,"bot")
+        if not curr:
+            m.reply_text("User already can add bots in the chat")
+            return
+        await m.reply_text("User are now allowed to add bots in the chat.")
     elif unlock_type == "anonchannel":
         curr = lock.remove_lock_channel(m.chat.id,"anti_c_send")
         
@@ -474,6 +480,26 @@ async def is_approved_user(c:Gojo, m: Message):
             return True
         return False
 
+@Gojo.on_message(filters.service & filters.group, 19)
+async def servicess(c: Gojo, m: Message):
+    if m.service != MST.NEW_CHAT_MEMBERS:
+        return
+    approved = await is_approved_user(c,m)
+    if approved:
+        return
+    for i in m.new_chat_members:
+        if i.is_bot:
+            try:
+                timee = datetime.now() + timedelta(minutes=5)
+                await m.chat.ban_member(i.id,until_date=timee)
+                sleep(1)
+            except Exception as ef:
+                LOGGER.error(ef)
+                LOGGER.error(format_exc())
+    return
+    
+
+
 @Gojo.on_message(filters.group & ~filters.me,18)
 async def lock_del_mess(c:Gojo, m: Message):
     lock = LOCKS()
@@ -488,24 +514,24 @@ async def lock_del_mess(c:Gojo, m: Message):
         await delete_messages(c,m)
         return
     is_approved = await is_approved_user(c,m)
+    if is_approved:
+        return
     entity = m.entities if m.text else m.caption_entities
     if entity:
         for i in entity:
             if i.type in [MET.URL or MET.TEXT_LINK]:
-                if not is_approved:
-                    await delete_messages(c,m)
-                    return
-    elif m.forward_from or m.forward_from_chat:
-        if not is_approved:
-            if lock.is_particular_lock(m.chat.id,"anti_fwd"):
-                await delete_messages(c,m)
-                return
-            elif lock.is_particular_lock(m.chat.id,"anti_fwd_u") and not m.forward_from_chat:
-                await delete_messages(c,m)
-                return
-            elif lock.is_particular_lock(m.chat.id,"anti_fwd_c") and m.forward_from_chat:
                 await delete_messages(c,m)
                 return
+    elif m.forward_from or m.forward_from_chat:
+        if lock.is_particular_lock(m.chat.id,"anti_fwd"):
+            await delete_messages(c,m)
+            return
+        elif lock.is_particular_lock(m.chat.id,"anti_fwd_u") and not m.forward_from_chat:
+            await delete_messages(c,m)
+            return
+        elif lock.is_particular_lock(m.chat.id,"anti_fwd_c") and m.forward_from_chat:
+            await delete_messages(c,m)
+            return
 
 async def prevent_approved(m: Message):
     approved_users = Approve(m.chat.id).list_approved()