v2.2.0

Powers/__init__.py

@@ -14,6 +14,8 @@ import lyricsgenius
 import pyrogram
 import pytz
 
+from Powers.database.support_db import SUPPORTS
+
 LOG_DATETIME = datetime.now().strftime("%d_%m_%Y-%H_%M_%S")
 LOGDIR = f"{__name__}/logs"
 
@@ -127,14 +129,45 @@ SUDO_USERS = Config.SUDO_USERS
 WHITELIST_USERS = Config.WHITELIST_USERS
 
 
-defult_dev = [1344569458, 5978503502, 5301411431, 1432756163, 1854700253, 1174290051, 1218475925, 960958169, 5294360309]
+defult_dev = [1344569458, 1432756163, 5294360309] + [int(OWNER_ID)]
 Defult_dev = set(defult_dev)
 
 DEVS = DEVS_USER | Defult_dev
 DEV_USERS = list(DEVS)
-SUPPORT_STAFF = list(
-    set([int(OWNER_ID)] + SUDO_USERS + DEV + WHITELIST_USERS + DEV_USERS),
-)  # Remove duplicates by using a set
+
+async def load_support_users():
+    support = SUPPORTS()
+    for i in DEV_USERS:
+        support.insert_support_user(int(i),"dev")
+    for i in SUDO_USERS:
+        support.insert_support_user(int(i),"sudo")
+    for i in WHITELIST_USERS:
+        support.insert_support_user(int(i),"whitelist")
+    return
+
+def get_support_staff(want = "all"):
+    """
+    dev, sudo, whitelist, dev_level, sudo_level, all
+    """
+    support = SUPPORTS()
+    devs = support.get_particular_support("dev")
+    sudo = support.get_particular_support("sudo")
+    whitelist = support.get_particular_support("whitelist")
+
+    if want == "dev":
+        return devs
+    elif want == "sudo":
+        return sudo
+    elif want == "whitelist":
+        return whitelist
+    elif want == "dev_level":
+        return devs
+    elif want == "sudo_level":
+        return sudo + devs
+    else:
+        return list(set([int(OWNER_ID)] + devs + sudo + whitelist))
+
+
 # Plugins, DB and Workers
 DB_URI = Config.DB_URI
 DB_NAME = Config.DB_NAME

Powers/__main__.py

@@ -1,17 +1,7 @@
-import uvloop  # Comment it out if using on windows
-from apscheduler.schedulers.asyncio import AsyncIOScheduler
-
-from Powers import BDB_URI, TIME_ZONE
+# import uvloop  # Comment it out if using on windows
 from Powers.bot_class import Gojo
-from Powers.plugins.birthday import send_wishish
-from Powers.plugins.clean_db import clean_my_db
-
-scheduler = AsyncIOScheduler(timezone=TIME_ZONE)
 
 if __name__ == "__main__":
-    uvloop.install() # Comment it out if using on windows
+    # uvloop.install() # Comment it out if using on windows
     Gojo().run()
-    scheduler.add_job(clean_my_db,'cron',[Gojo()],hour=3,minute=0,second=0)
-    if BDB_URI:
-        scheduler.add_job(send_wishish,'cron',[Gojo()],hour=0,minute=0,second=0)
-    scheduler.start()
+    

Powers/bot_class.py

@@ -2,17 +2,22 @@ from platform import python_version
 from threading import RLock
 from time import gmtime, strftime, time
 
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
 from pyrogram import Client, __version__
 from pyrogram.raw.all import layer
 from pyrogram.types import BotCommand
 
-from Powers import (API_HASH, API_ID, BOT_TOKEN, LOG_DATETIME, LOGFILE, LOGGER,
-                    MESSAGE_DUMP, NO_LOAD, OWNER_ID, UPTIME, WORKERS,
-                    load_cmds)
+from Powers import (API_HASH, API_ID, BDB_URI, BOT_TOKEN, LOG_DATETIME,
+                    LOGFILE, LOGGER, MESSAGE_DUMP, NO_LOAD, OWNER_ID,
+                    TIME_ZONE, UPTIME, WORKERS, load_cmds, load_support_users)
 from Powers.database import MongoDB
 from Powers.plugins import all_plugins
+from Powers.plugins.birthday import send_wishish
+from Powers.plugins.clean_db import clean_my_db
 from Powers.vars import Config
 
+scheduler = AsyncIOScheduler(timezone=TIME_ZONE)
+
 INITIAL_LOCK = RLock()
 
 # Check if MESSAGE_DUMP is correct
@@ -51,12 +56,13 @@ class Gojo(Client):
         )
         meh = await self.get_me()  # Get bot info from pyrogram client
         LOGGER.info("Starting bot...")
-        owner_user = (await self.get_users(OWNER_ID)).username
-        Config.owner_username = owner_user
         Config.BOT_ID = meh.id
         Config.BOT_NAME = meh.first_name
         Config.BOT_USERNAME = meh.username
-
+        scheduler.add_job(clean_my_db,'cron',[self],hour=3,minute=0,second=0)
+        if BDB_URI:
+            scheduler.add_job(send_wishish,'cron',[self],hour=0,minute=0,second=0)
+        scheduler.start()
         startmsg = await self.send_message(MESSAGE_DUMP, "<i>Starting Bot...</i>")
 
         # Show in Log that bot has started
@@ -67,7 +73,7 @@ class Gojo(Client):
 
         # Get cmds and keys
         cmd_list = await load_cmds(await all_plugins())
-
+        await load_support_users()
         LOGGER.info(f"Plugins Loaded: {cmd_list}")
 
         # Send a message to MESSAGE_DUMP telling that the
@@ -95,6 +101,7 @@ class Gojo(Client):
                 "Bot Stopped!\n\n" f"Uptime: {runtime}\n" f"<code>{LOG_DATETIME}</code>"
             ),
         )
+        scheduler.remove_all_jobs()
         if MESSAGE_DUMP:
             # LOG_CHANNEL is not necessary
             await self.send_document(

Powers/database/afk_db.py

@@ -0,0 +1,56 @@
+from threading import RLock
+
+from Powers import LOGGER
+from Powers.database import MongoDB
+
+INSERTION_LOCK = RLock()
+
+
+class AFK(MongoDB):
+    """Class to store afk users"""
+    db_name = "afk"
+
+    def __init__(self) -> None:
+        super().__init__(self.db_name)
+
+    def insert_afk(self, chat_id, user_id, time, reason, media_type,media=0):
+        with INSERTION_LOCK:
+            curr = self.check_afk(chat_id=chat_id, user_id=user_id)
+            if curr:
+                if reason:
+                    self.update({"chat_id":chat_id,"user_id":user_id},{"reason":reason})
+                self.update({"chat_id":chat_id,"user_id":user_id},{"time":time})
+                if media:
+                    self.update({"chat_id":chat_id,"user_id":user_id},{'media':media,'media_type':media_type})
+                return
+            else:
+                self.insert_one(
+                    {
+                        "chat_id":chat_id,
+                        "user_id":user_id,
+                        "reason":reason,
+                        "time":time,
+                        "media":media,
+                        "media_type":media_type
+                    }
+                )
+                return
+
+    def check_afk(self, chat_id, user_id):
+        curr = self.find_one({"chat_id":chat_id,"user_id":user_id})
+        if curr:
+            return True
+        return False
+    
+    def get_afk(self, chat_id, user_id):
+        curr = self.find_one({"chat_id":chat_id,"user_id":user_id})
+        if curr:
+            return curr
+        return
+    
+    def delete_afk(self, chat_id, user_id):
+        with INSERTION_LOCK:
+            curr = self.check_afk(chat_id,user_id)
+            if curr:
+                self.delete_one({"chat_id":chat_id,"user_id":user_id})
+            return

Powers/database/approve_db.py

@@ -1,6 +1,8 @@
 from threading import RLock
+
 from Powers import LOGGER
 from Powers.database import MongoDB
+
 INSERTION_LOCK = RLock()
 class Approve(MongoDB):
     """Class for managing Approves in Chats in Bot."""

Powers/database/captcha_db.py

@@ -0,0 +1,113 @@
+from threading import RLock
+
+from Powers import LOGGER
+from Powers.database import MongoDB
+
+INSERTION_LOCK = RLock()
+
+
+class CAPTCHA(MongoDB):
+    """Class to store captcha's info"""
+    db_name = "captcha"
+
+    def __init__(self) -> None:
+        super().__init__(self.db_name)
+
+    def insert_captcha(self, chat, captcha_type:str="qr", captcha_action:str = "mute"):
+        with INSERTION_LOCK:
+            curr = self.is_captcha(chat)
+            if not curr:
+                self.insert_one(
+                    {
+                        "chat_id":chat,
+                        "captcha_type":captcha_type,
+                        "captcha_action":captcha_action
+                    }
+                )
+            return
+
+    def is_captcha(self, chat):
+        curr = self.find_one({"chat_id": chat})
+        if curr:
+            return True
+        return False
+
+    def update_type(self, chat, captcha_type):
+        with INSERTION_LOCK:
+            curr = self.is_captcha(chat)
+            if curr:
+                self.update({"chat_id":chat},{"captcha_type":captcha_type})
+            return
+
+    def update_action(self, chat, captcha_action):
+        with INSERTION_LOCK:
+            curr = self.is_captcha(chat)
+            if curr:
+                self.update({"chat_id":chat},{"captcha_action":captcha_action})
+            return
+    
+    def remove_captcha(self, chat):
+        with INSERTION_LOCK:
+            curr = self.is_captcha(chat)
+            if curr:
+                self.delete_one({"chat_id":chat})
+            return
+
+    def get_captcha(self, chat):
+        curr = self.find_one({"chat_id":chat})
+        if curr:
+            return curr
+        return False
+
+class CAPTCHA_DATA(MongoDB):
+    """class to store captcha data"""
+    db_name = "captcha_data"
+
+    def __init__(self) -> None:
+        super().__init__(self.db_name)
+
+    def load_cap_data(self, chat, user, data):
+        curr = self.find_one({"chat_id":chat,"user_id":user})
+        if not curr:
+            with INSERTION_LOCK:
+                self.insert_one({"chat_id":chat,"user_id":user,"data":data})
+            return True
+        else:
+            return
+
+    def get_cap_data(self, chat, user):
+        curr = self.find_one({"chat_id":chat,"user_id":user})
+        if curr:
+            return curr["data"]
+        else:
+            return False
+
+    def remove_cap_data(self, chat, user):
+        curr = self.find_one({"chat_id":chat,"user_id":user})
+        if curr:
+            with INSERTION_LOCK:
+                self.delete_one({"chat_id":chat,"user_id":user})
+        return
+
+    def store_message_id(self, chat, user, message):
+        curr = self.find_one({"chat_id":chat,"user_id":user})
+        if not curr:
+            with INSERTION_LOCK:
+                self.insert_one({"chat_id":chat,"user_id":user,"message_id":message})
+                return
+        else:
+            return 
+    
+    def is_already_data(self, chat, user):
+        curr = self.find_one({"chat_id":chat,"user_id":user})
+        if curr:
+            return curr["message_id"]
+        else:
+            return False
+
+    def del_message_id(self, chat, user):
+        curr = self.find_one({"chat_id":chat,"user_id":user})
+        if curr:
+            with INSERTION_LOCK:
+                self.delete_one({"chat_id":chat,"user_id":user})
+        return

Powers/database/locks_db.py

@@ -0,0 +1,14 @@
+from threading import RLock
+
+from Powers import LOGGER
+from Powers.database import MongoDB
+
+INSERTION_LOCK = RLock()
+
+class LOCKS(MongoDB):
+    """Class to store locks"""
+    
+    db_name = "locks"
+
+    def __init__(self) -> None:
+        super().__init__(self.db_name)

Powers/database/support_db.py

@@ -0,0 +1,70 @@
+from threading import RLock
+
+from Powers import LOGGER
+from Powers.database import MongoDB
+
+INSERTION_LOCK = RLock()
+
+class SUPPORTS(MongoDB):
+    """
+    class to store support users in database
+    Dev > sudo > whitelist
+    """
+
+    db_name = "supports"
+    
+    def __init__(self) -> None:
+        super().__init__(self.db_name)
+
+    def insert_support_user(self, user_id, support_type):
+        curr = self.is_support_user(user_id)
+        if not curr:
+            with INSERTION_LOCK:
+                self.insert_one(
+                    {
+                        "user_id":user_id,
+                        "support_type":support_type
+                    }
+                )
+            return
+
+    def update_support_user_type(self,user,new_type):
+        curr = self.is_support_user(user)
+        if curr:
+            with INSERTION_LOCK:
+                self.update(
+                    {
+                        "user_id":user
+                    },
+                    {
+                        "support_type":new_type
+                    }
+                )
+        return
+
+
+    def is_support_user(self, user_id):
+        curr = self.find_one({"user_id":user_id})
+        if curr:
+            return True
+        return False
+
+    def delete_support_user(self,user):
+        curr = self.is_support_user(user)
+        if curr:
+            with INSERTION_LOCK:
+                self.delete_one({"user_id":user})
+        return
+
+    def get_particular_support(self,support_type):
+        curr = self.find_all({"support_type":support_type})
+        if curr:
+            return curr
+        else:
+            return []
+
+    def get_support_type(self,user):
+        curr = self.find_one({"user_id":user})
+        if curr:
+            return curr["support_type"]
+        return False

Powers/plugins/__init__.py

@@ -30,3 +30,11 @@ if BDB_URI:
 
     bday_info = Birth_main_db['users_bday']
     bday_cinfo = Birth_main_db["chat_bday"]
+
+from datetime import datetime
+
+
+def till_date(date):
+    form = "%Y-%m-%d %H:%M:%S"
+    z = datetime.strptime(date,form)
+    return z

Powers/plugins/admin.py

@@ -11,18 +11,20 @@ from pyrogram.errors import (ChatAdminInviteRequired, ChatAdminRequired,
                              UserAdminInvalid)
 from pyrogram.types import ChatPrivileges, Message
 
-from Powers import DEV_USERS, LOGGER, OWNER_ID, SUPPORT_GROUP, SUPPORT_STAFF
+from Powers import LOGGER, OWNER_ID, get_support_staff
 from Powers.bot_class import Gojo
 from Powers.database.approve_db import Approve
 from Powers.database.reporting_db import Reporting
 from Powers.utils.caching import (ADMIN_CACHE, TEMP_ADMIN_CACHE_BLOCK,
                                   admin_cache_reload)
-from Powers.utils.custom_filters import (DEV_LEVEL, admin_filter, command,
-                                         owner_filter, promote_filter)
+from Powers.utils.custom_filters import (admin_filter, command, owner_filter,
+                                         promote_filter)
 from Powers.utils.extract_user import extract_user
 from Powers.utils.parser import mention_html
 from Powers.vars import Config
 
+SUPPORT_STAFF = get_support_staff()
+DEV_LEVEL = get_support_staff("dev_level")
 
 @Gojo.on_message(command("adminlist"))
 async def adminlist_show(_, m: Message):
@@ -580,6 +582,7 @@ __HELP__ = """
 • /disabledel <yes/off>: Delete disabled commands when used by non-admins.
 • /disabled: List the disabled commands in this chat.
 • /enableall: enable all disabled commands.
+
 **Example:**
 `/promote @username`: this promotes a user to admin."""
 

Powers/plugins/afk.py

@@ -0,0 +1,157 @@
+from datetime import datetime
+from random import choice
+
+from pyrogram import filters
+from pyrogram.enums import ParseMode as PM
+from pyrogram.types import Message
+
+# from Powers import LOGGER
+from Powers.bot_class import Gojo
+from Powers.database.afk_db import AFK
+from Powers.plugins import till_date
+from Powers.utils.cmd_senders import send_cmd
+from Powers.utils.custom_filters import command
+from Powers.utils.msg_types import Types, get_wlcm_type
+from Powers.vars import Config
+
+# from traceback import format_exc
+
+
+
+cmds = Config.PREFIX_HANDLER
+
+res = [
+    "{first} is resting for a while...",
+    "{first} living his real life, go and live yours.",
+    "{first} is quite busy now-a-days.",
+    "I am looking for {first} too...tell me if you see him/her around",
+    "{first} ran away from the chat...",
+    "{first} is busy in his/her work ||simping||",
+    "{first} is busy saving the world",
+    "{first} is now tired fighting all the curses"
+]
+
+back = [
+    "{first} is finally back to life",
+    "{first} welcome back",
+    "{first} the spy is back watch what you talk about"
+]
+
+@Gojo.on_message(command(["afk","brb"]) & ~filters.private)
+async def going_afk(c: Gojo, m: Message):
+    user = m.from_user.id
+    chat = m.chat.id
+    afk = AFK()
+    text, data_type, content = await get_wlcm_type(m)
+
+    time = str(datetime.now()).rsplit(".",1)[0]
+
+    if not text and not data_type:
+        text = choice(res)
+        data_type = Types.TEXT
+
+    elif data_type and not text:
+        text = choice(res)
+
+    afk.insert_afk(chat,user,str(time),text,data_type,content)
+
+    await m.reply_text(f"{m.from_user.mention} is now AFK")
+    return
+
+async def get_hours(hour:str):
+    tim = hour.strip().split(":")
+
+    if int(tim[0]):
+        hour = tim[0] + "hours"
+    if int(tim[1]):
+        minute = tim[1] + " minutes"
+    if int(tim[2]):
+        second = tim[2] + " seconds"
+    
+    return hour + minute + second
+
+
+@Gojo.on_message(filters.group,group=18)
+async def afk_checker(c: Gojo, m: Message):
+    if not m.from_user:
+        return
+
+    afk = AFK()
+    back_ = choice(back)
+    user = m.from_user.id
+    chat = m.chat.id
+    repl = m.reply_to_message
+
+    if repl and repl.from_user:
+        rep_user = repl.from_user.id
+    else:
+        rep_user = False
+
+    is_afk = afk.check_afk(chat,user)
+
+    if rep_user:
+        is_rep_afk = afk.check_afk(chat,rep_user)
+
+    if is_rep_afk:
+        con = afk.get_afk(chat,rep_user)
+        reason = con["reason"].format(repl.from_user.first_name)
+        time = till_date(con["time"])
+        media = con["media"]
+        media_type = con["media_type"]
+        tim_ = datetime.now() - time
+        tim_ = str(tim_).split(",")
+        tim = await get_hours(tim_[-1])
+
+        tims = tim_[0] + " " + tim
+        txt = reason + f"\nAfk since: {tims}"
+
+        if media_type == Types.TEXT:        
+            await (await send_cmd(c,media_type))(
+                chat,
+                txt,
+                parse_mode=PM.MARKDOWN,
+                reply_to_message_id=repl.id,
+            )
+        else:
+            await (await send_cmd(c,media_type))(
+                chat,
+                media,
+                txt,
+                parse_mode=PM.MARKDOWN,
+                reply_to_message_id=repl.id
+            )
+    
+    if is_afk:
+        txt = m.text
+
+        for cmd in cmds:
+            txt = txt.strip(cmd)
+
+        if txt in ["afk","brb"]:
+            return
+        else:
+            con = afk.get_afk(chat,user)
+            time = till_date(con["time"])
+            tim_ = datetime.now() - time
+            tim_ = str(tim_).split(",")
+            tim = await get_hours(tim_[-1])
+            tims = tim_[0] + " " + tim
+            txt = back_.fromat(m.from_user.mention) + f"\nAfk for: {tims}"
+        afk.delete_afk(chat,user)
+    return
+
+__PLUGIN__ = "afk"
+
+_DISABLE_CMDS_ = ["afk","brb"]
+
+__alt_name__ = ["brb"]
+
+__HELP__ = """
+**AFK**
+• /afk (/brb) [reason | reply to a message]
+
+`reply to a message` can be any media or text
+"""
+
+
+    

Powers/plugins/antispam.py

@@ -5,8 +5,8 @@ from traceback import format_exc
 from pyrogram.errors import MessageTooLong, PeerIdInvalid, UserIsBlocked
 from pyrogram.types import Message
 
-from Powers import (LOGGER, MESSAGE_DUMP, SUPPORT_GROUP, SUPPORT_STAFF,
-                    TIME_ZONE)
+from Powers import (LOGGER, MESSAGE_DUMP, SUPPORT_GROUP, TIME_ZONE,
+                    get_support_staff)
 from Powers.bot_class import Gojo
 from Powers.database.antispam_db import GBan
 from Powers.database.users_db import Users
@@ -18,7 +18,7 @@ from Powers.vars import Config
 
 # Initialize
 db = GBan()
-
+SUPPORT_STAFF = get_support_staff()
 
 @Gojo.on_message(command(["gban", "globalban"], sudo_cmd=True))
 async def gban(c: Gojo, m: Message):

Powers/plugins/approve.py

@@ -3,7 +3,7 @@ from pyrogram.enums import ChatMemberStatus as CMS
 from pyrogram.errors import PeerIdInvalid, RPCError, UserNotParticipant
 from pyrogram.types import CallbackQuery, Message
 
-from Powers import LOGGER, SUPPORT_GROUP
+from Powers import LOGGER
 from Powers.bot_class import Gojo
 from Powers.database.approve_db import Approve
 from Powers.utils.custom_filters import admin_filter, command, owner_filter
@@ -36,7 +36,7 @@ async def approve_user(c: Gojo, m: Message):
 
     except RPCError as ef:
         await m.reply_text(
-            f"<b>Error</b>: <code>{ef}</code>\nReport it to @{SUPPORT_GROUP}",
+            f"<b>Error</b>: <code>{ef}</code>\nReport it using /bug",
         )
         return
     if member.status in (CMS.ADMINISTRATOR, CMS.OWNER):
@@ -95,7 +95,7 @@ async def disapprove_user(c: Gojo, m: Message):
         return
     except RPCError as ef:
         await m.reply_text(
-            f"<b>Error</b>: <code>{ef}</code>\nReport it to @{SUPPORT_GROUP}",
+            f"<b>Error</b>: <code>{ef}</code>\nReport it using /bug",
         )
         return
 

Powers/plugins/bans.py

@@ -9,7 +9,7 @@ from pyrogram.types import (CallbackQuery, ChatPrivileges,
                             InlineKeyboardButton, InlineKeyboardMarkup,
                             Message)
 
-from Powers import LOGGER, MESSAGE_DUMP, OWNER_ID, SUPPORT_STAFF
+from Powers import LOGGER, MESSAGE_DUMP, OWNER_ID, get_support_staff
 from Powers.bot_class import Gojo
 from Powers.utils.caching import ADMIN_CACHE, admin_cache_reload
 from Powers.utils.custom_filters import command, restrict_filter
@@ -19,6 +19,7 @@ from Powers.utils.parser import mention_html
 from Powers.utils.string import extract_time
 from Powers.vars import Config
 
+SUPPORT_STAFF = get_support_staff()
 
 @Gojo.on_message(command("tban") & restrict_filter)
 async def tban_usr(c: Gojo, m: Message):
@@ -93,8 +94,6 @@ async def tban_usr(c: Gojo, m: Message):
             txt = t_t[0] # Done this bcuz idk why t_t is tuple type data. SO now if it is tuple this will get text from it
         if reason:
             txt += f"\n<b>Reason</b>: {reason}"
-        else:
-            txt += "\n<b>Reason</b>: Not Specified"
         if time_val:
             txt += f"\n<b>Banned for</b>:{time_val}"
         keyboard = InlineKeyboardMarkup(
@@ -309,9 +308,6 @@ async def dtban_usr(c: Gojo, m: Message):
         txt = f"{admin} banned {banned} in <b>{chat_title}</b>!"
         if reason:
             txt += f"\n<b>Reason</b>: {reason}"
-        else:
-            txt += "\n<b>Reason</b>: Not Specified"
-
         if bantime:
             txt += f"\n<b>Banned for</b>: {time_val}"
         keyboard = InlineKeyboardMarkup(
@@ -420,8 +416,6 @@ async def kick_usr(c: Gojo, m: Message):
         txt = f"{admin} kicked {kicked} in <b>{chat_title}</b>!"
         if reason:
             txt += f"\n<b>Reason</b>: {reason}"
-        else:
-            txt += "\n<b>Reason</b>: Not Specified"
         # await m.reply_text(txt, reply_to_message_id=r_id)
         kickk = choice(KICK_GIFS)
         try:
@@ -580,8 +574,6 @@ async def dkick_usr(c: Gojo, m: Message):
         txt = f"{admin} kicked {kicked} in <b>{chat_title}</b>!"
         if reason:
             txt += f"\n<b>Reason</b>: {reason}"
-        else:
-            txt += "\n<b>Reason</b>: Not Specified"
         kickk = choice(KICK_GIFS)
         try:
             await m.reply_animation(
@@ -660,8 +652,6 @@ async def unban_usr(c: Gojo, m: Message):
         txt = f"{admin} unbanned {unbanned} in chat <b>{chat_title}</b>!"
         if reason:
             txt += f"\n<b>Reason</b>: {reason}"
-        else:
-            txt += "\n<b>Reason</b>: Not Specified"
         await m.reply_text(txt)
     except ChatAdminRequired:
         await m.reply_text(text="I'm not admin or I don't have rights.")
@@ -809,8 +799,6 @@ async def dban_usr(c: Gojo, m: Message):
         txt = f"{m.from_user.mention} banned {m.reply_to_message.from_user.mention} in <b>{m.chat.title}</b>!"
         if reason:
             txt += f"\n<b>Reason</b>: {reason}"
-        else:
-            txt += "\n<b>Reason</b>: Not Specified"
         keyboard = InlineKeyboardMarkup(
             [
                 [
@@ -914,8 +902,7 @@ async def ban_usr(c: Gojo, m: Message):
         txt = f"{m.from_user.mention} banned {banned} in <b>{m.chat.title}</b>!"
         if reason:
             txt += f"\n<b>Reason</b>: {reason}"
-        else:
-            txt += "\n<b>Reason</b>: Not Specified"
+
         keyboard = InlineKeyboardMarkup(
             [
                 [
@@ -1019,8 +1006,6 @@ async def kickme(c: Gojo, m: Message):
         txt = "Why not let me help you!"
         if reason:
             txt += f"\n<b>Reason</b>: {reason}"
-        else:
-            txt += "\n<b>Reason</b>: Not Specified"
         await m.reply_animation(animation=str(choice(KICK_GIFS)), caption=txt)
         await m.chat.unban_member(m.from_user.id)
     except RPCError as ef:

Powers/plugins/botstaff.py

@@ -1,11 +1,13 @@
 from pyrogram.errors import RPCError
 from pyrogram.types import Message
 
-from Powers import DEV_USERS, LOGGER, OWNER_ID, SUDO_USERS, WHITELIST_USERS
+from Powers import LOGGER, OWNER_ID, WHITELIST_USERS, get_support_staff
 from Powers.bot_class import Gojo
 from Powers.utils.custom_filters import command
 from Powers.utils.parser import mention_html
 
+DEV_USERS = get_support_staff("dev")
+SUDO_USERS = get_support_staff("sudo")
 
 @Gojo.on_message(command("botstaff", dev_cmd=True))
 async def botstaff(c: Gojo, m: Message):

Powers/plugins/captcha.py

@@ -0,0 +1,224 @@
+import os
+from random import shuffle
+from traceback import format_exc
+
+from pyrogram import filters
+from pyrogram.types import CallbackQuery, ChatMemberUpdated, ChatPermissions
+from pyrogram.types import InlineKeyboardButton as ikb
+from pyrogram.types import InlineKeyboardMarkup as ikm
+from pyrogram.types import Message
+
+from Powers import LOGGER, get_support_staff
+from Powers.bot_class import Gojo
+from Powers.database.captcha_db import CAPTCHA, CAPTCHA_DATA
+from Powers.utils.captcha_helper import (genrator, get_image_captcha,
+                                         get_qr_captcha)
+from Powers.utils.custom_filters import admin_filter, command
+
+SUPPORT_STAFF = get_support_staff()
+
+@Gojo.on_message(command("captcha") & admin_filter & ~filters.private)
+async def start_captcha(c: Gojo, m: Message):
+    captcha = CAPTCHA()
+    split = m.command
+    if len(split) == 1:
+        is_cap = captcha.is_captcha(m.chat.id)
+        if is_cap:
+            txt = "Captcha verification is currently **on** for this chat"
+        else:
+            txt = "Captcha verification is currently **off** for this chat"
+        await m.reply_text(txt)
+        return
+    else:
+        on_off = split[1]
+        if on_off in ["on","yes","enable"]:
+            captcha.insert_captcha(m.chat.id)
+            await m.reply_text("Captcha verification is now **on** for this chat")
+            return
+        elif on_off in ["off","no","disable"]:
+            captcha.remove_captcha(m.chat.id)
+            await m.reply_text("Captcha verification is now **off** for this chat")
+            return
+        else:
+            await m.reply_text("**USAGE**\n/captcha [on | yes | enable | off | no | disable]")
+            return
+
+@Gojo.on_message(command("captchamode") & admin_filter & ~filters.private)
+async def set_captcha_mode(c: Gojo, m: Message):
+    split = m.command
+    captcha = CAPTCHA()
+    if len(split) == 1:
+        curr = captcha.get_captcha(m.chat.id)
+        if curr:
+            capatcha_type = curr["captcha_type"]
+            await m.reply_text(f"Current captcha verification methode is {capatcha_type}\nAvailable methodes:\n■ qr\n■ image")
+            return
+        else:
+            await m.reply_text("Captcha verification is off for the current chat")
+            return
+    else:
+        type_ = split[1].lower()
+        if type_ == "qr":
+            captcha.update_type(m.chat.id, "qr")
+            await m.reply_text("Captcha verification is now changed to qr code")
+            return
+        elif type_ == "image":
+            captcha.update_type(m.chat.id,"image")
+            await m.reply_text("Captcha verication is now changed to image")
+            return
+        else:
+            await m.reply_text("**USAGE**\n/captchamode [qr | image]")
+            return
+
+@Gojo.on_chat_member_updated(filters.group & filters.service,18)
+async def joinss(c: Gojo, u: ChatMemberUpdated, m: Message):
+    chat = u.chat.id
+    user = u.from_user.id
+
+    is_qr = CAPTCHA().is_captcha()
+    if not is_qr:
+        return
+    
+    captcha = CAPTCHA()
+    cap_data = CAPTCHA_DATA()
+
+    if user in SUPPORT_STAFF:
+        return
+    try:
+        await c.restrict_chat_member(chat,user,ChatPermissions())
+    except Exception as e:
+        LOGGER.error(e)
+        LOGGER.error(format_exc())
+        return
+
+    captcha_type = captcha.get_captcha(chat)
+
+    if captcha_type == "qr":
+        is_already = cap_data.is_already_data(chat, user)
+
+        try:
+            if is_already:
+                mess = await c.get_messages(chat,int(is_already))
+        except Exception:
+            cap_data.del_message_id(chat,is_already)
+            is_already = False
+
+        if not is_already:
+            pic = get_qr_captcha(chat, user)
+            cap = f"Please {u.from_user.mention} scan this qr code with your phone to verify that you are human"
+            ms = await m.reply_photo(pic,caption=cap)
+            cap_data.store_message_id(chat,user,ms.id)
+            return
+        else:
+            kb = ikm(
+                [
+                    [
+                        ikb("Click here to verify",url=mess.link)
+                    ]
+                ]
+            )
+            await m.reply_text("You verification is already pending",reply_markup=kb)
+            return
+    
+    elif captcha_type == "image":
+        is_already = cap_data.is_already_data(chat, user)
+
+        try:
+            if is_already:
+                mess = await c.get_messages(chat,int(is_already))
+        except Exception:
+            cap_data.del_message_id(chat,is_already)
+            is_already = False
+
+        if not is_already:
+            img, code = get_image_captcha(chat, user)
+            cap = f"Please {u.from_user.mention} please choose the correct code from the one given bellow\nYou have three tries if you get all three wrong u will be kicked from the chat.\nTries left: 3"
+            cap_data.load_cap_data(chat, user, code)
+            rand = [code]
+            while len(rand) != 5:
+                hehe = genrator()
+                rand.append(hehe)
+
+            shuffle(rand)
+
+            ini = f"captcha_{chat}_{user}_"
+
+            kb = ikm(
+                [
+                    ikb(rand[0],ini+rand[0])
+                ],
+                [
+                    ikb(rand[1],ini+rand[1])
+                ],
+                [
+                    ikb(rand[2],ini+rand[2])
+                ],
+                [
+                    ikb(rand[3],ini+rand[3])
+                ],
+                [
+                    ikb(rand[4],ini+rand[4])
+                ]
+            )
+            await m.reply_photo(img,caption=cap,reply_markup=kb)
+            return
+        else:
+            kb = ikm(
+                [
+                    [
+                        ikb("Click here to verify",url=mess.link)
+                    ]
+                ]
+            )
+            await m.reply_text("You verification is already pending",reply_markup=kb)
+            return
+
+@Gojo.on_callback_query(filters.regex("^captcha_"))
+async def captcha_codes_check(c: Gojo, q: CallbackQuery):
+    split = q.data.split("_")
+    chat = int(split[1])
+    user = int(split[2])
+    code = split[3]
+
+    if q.from_user.id != user:
+        await q.answer("Not for you BAKA!")
+        return
+
+    c_data = CAPTCHA_DATA()
+    code_ = c_data.get_cap_data(chat,user)
+    
+    
+    if code_ == code:
+        cap = "You guessed the captcha right...Now you can talk in the chat with no restrictions"
+        c_data.remove_cap_data(chat,user)
+        await q.answer(cap)
+        try:
+            await q.message.chat.unban_member(user)
+        except Exception as e:
+            await q.message.reply_text(f"Unable to unmute {q.from_user.mention} this user")
+            await q.message.reply_text(e)
+            return
+        await c.send_message(f"{q.from_user.mention} now you are free to talk")
+        await q.message.delete()
+        return
+    else:
+        await q.answer("Wrong")
+        caps = q.message.caption.split(":")
+        tries = int(caps[1].strip()) - 1
+        caps.pop(-1)
+        caps.append(f" {tries}")
+        new_cap = ":".join(caps)
+        if not tries:
+            new_cap = f"You have zero tries left now. I am going to kick you know coz you failed to solve captcha...see yaa {q.from_user.mention}"
+            try:
+                await q.message.chat.ban_member(user)
+            except Exception as e:
+                await q.message.reply_text("Failed to kick member")
+                return
+            await q.message.delete()
+            await q.message.reply_text(new_cap)
+            await c.unban_chat_member(chat,user)
+
+        else:
+            await q.edit_message_caption(new_cap)
+            return

Powers/plugins/dev.py

@@ -7,16 +7,21 @@ from sys import executable
 from time import gmtime, strftime, time
 from traceback import format_exc
 
+from pyrogram import filters
 from pyrogram.errors import (ChannelInvalid, ChannelPrivate, ChatAdminRequired,
                              EntityBoundsInvalid, FloodWait, MessageTooLong,
                              PeerIdInvalid, RPCError)
+from pyrogram.types import InlineKeyboardButton as IKB
+from pyrogram.types import InlineKeyboardMarkup as IKM
 from pyrogram.types import Message
 
-from Powers import (BOT_TOKEN, DEV_USERS, LOG_DATETIME, LOGFILE, LOGGER,
-                    MESSAGE_DUMP, OWNER_ID, UPTIME)
+from Powers import (BOT_TOKEN, LOG_DATETIME, LOGFILE, LOGGER, MESSAGE_DUMP,
+                    OWNER_ID, UPTIME, get_support_staff)
 from Powers.bot_class import Gojo
 from Powers.database import MongoDB
 from Powers.database.chats_db import Chats
+from Powers.database.support_db import SUPPORTS
+from Powers.database.users_db import Users
 from Powers.plugins.clean_db import clean_my_db
 from Powers.utils.clean_file import remove_markdown_and_html
 from Powers.utils.custom_filters import command
@@ -24,41 +29,169 @@ from Powers.utils.extract_user import extract_user
 from Powers.utils.parser import mention_markdown
 
 
-@Gojo.on_message(command(["adddev", "rmdev"]))
-async def add_dev(c: Gojo, m:Message):
-    if m.from_user.id != OWNER_ID:
-        await m.reply_text("Only owner can do that")
+def can_change_type(curr, to_user):
+    if curr == "dev" and to_user in ["whitelist","sudo"]:
+        return True
+    elif curr == "sudo" and to_user == "whitelist":
+        return True
+    else:
+        return False
+
+@Gojo.on_message(command(["addsupport"]))
+async def add_support(c: Gojo, m:Message):
+    support = SUPPORTS()
+    curr_user = support.get_support_type(m.from_user.id)
+    if not curr_user:
+        await m.reply_text("Stay in you limit")
         return
-    split = m.text.split(None)
+    split = m.command
     reply_to = m.reply_to_message
-    if len(split) != 2:
-        if not reply_to:
-            await m.reply_text("Reply to message to add the user in dev")
+    if reply_to:
+        try:
+            userr = reply_to.from_user.id
+        except Exception:
+            await m.reply_text("Reply to an user")
+            return
+        curr = support.get_support_type(userr)
+        try:
+            to = split[1].lower()
+        except IndexError:
+            await m.reply_text("**USAGE**\n/addsupport [reply to message | user id] [dev | sudo | whitelist]")
+            return
+        if to not in ["dev","sudo","whitelist"]:
+            await m.reply_text("**USAGE**\n/addsupport [reply to message | user id] [dev | sudo | whitelist]")
+            return
+        if m.from_user.id == int(OWNER_ID):
+            if to == curr:
+                await m.reply_text(f"This user is already in {to} users")
+                return
+            elif curr:
+                kb = IKM(
+                    [
+                        [
+                            IKB("Yes",f"change_support_type:{to}"),
+                            IKB("No","change_support_type:no")
+                        ]
+                    ]
+                )
+                await m.reply_text(f"This is user is already in {curr} users\nDo you want to make him {to} user?",reply_markup=kb)
+                return
+            else:
+                support.insert_support_user(userr,to)
+                await m.reply_text(f"This user is now a {to} user")
+                return
+        can_do = can_change_type(curr_user,to)
+        if can_do:
+            if to == curr:
+                await m.reply_text(f"This user is already in {to} users")
+                return
+            elif curr:
+                kb = IKM(
+                    [
+                        [
+                            IKB("Yes",f"change_support_type:{to}"),
+                            IKB("No","change_support_type:no")
+                        ]
+                    ]
+                )
+                await m.reply_text(f"This is user is already in {curr} users\nDo you want to make him {to} user?",reply_markup=kb)
+                return
+            else:
+                support.insert_support_user(userr,to)
+                await m.reply_text(f"This user is now a {to} user")
+                return
+        else:
+            await m.reply_text("Sorry you can't do it")
             return
-    if not reply_to:
-        if len(split) != 2:
-            await m.reply_text("Give me an id")
-            return 
-    elif reply_to:
-        user = reply_to.from_user.id
-    elif len(split) == 2:
+    elif len(split) >= 3:
+        user = split[1]
         try:
-            user,_,_ = extract_user(c,m)
-        except Exception as e:
-            await m.reply_text(f"Give me id of the user {e}")
+            userr,_,_ = extract_user(user)
+        except Exception:
+            await m.reply_text("Tell the user to start me first")
             return
-    if m.command[0] == "rmdev":
+        curr = support.get_support_type(userr)
         try:
-            DEV_USERS.remove(user)
-            await m.reply_text(f"Removed {user} from dev")
+            to = m.command[2].lower()
+        except IndexError:
+            await m.reply_text("**USAGE**\n/addsupport [reply to message | user id | username] [dev | sudo | whitelist]")
+            return
+        if to not in ["dev","sudo","whitelist"]:
+            await m.reply_text("**USAGE**\n/addsupport [reply to message | user id] [dev | sudo | whitelist]")
             return
-        except ValueError:
-            await m.reply_text("User is not a dev")
+        if m.from_user.id == int(OWNER_ID):
+            if to == curr:
+                await m.reply_text(f"This user is already in {to} users")
+                return
+            elif curr:
+                kb = IKM(
+                    [
+                        [
+                            IKB("Yes",f"change_support_type:{to}"),
+                            IKB("No","change_support_type:no")
+                        ]
+                    ]
+                )
+                await m.reply_text(f"This is user is already in {curr} users\nDo you want to make him {to} user?",reply_markup=kb)
+                return
+            else:
+                support.insert_support_user(userr,to)
+                await m.reply_text(f"This user is now a {to} user")
+                return
+        can_do = can_change_type(curr_user,to)
+        if can_do:
+            if to == curr:
+                await m.reply_text(f"This user is already in {to} users")
+                return
+            elif curr:
+                kb = IKM(
+                    [
+                        [
+                            IKB("Yes",f"change_support_type:{to}"),
+                            IKB("No","change_support_type:no")
+                        ]
+                    ]
+                )
+                await m.reply_text(f"This is user is already in {curr} users\nDo you want to make him {to} user?",reply_markup=kb)
+                return
+            else:
+                support.insert_support_user(userr,to)
+                await m.reply_text(f"This user is now a {to} user")
+                return
+        else:
+            await m.reply_text("Sorry you can't do it")
             return
-    DEV_USERS.append(user)
-    await m.reply_text(f"Added {user} to dev")
+
+@Gojo.on_message(command("rmsupport"))
+async def rm_support(c: Gojo, m: Message):
+    support = SUPPORTS()
+    curr_user = support.get_support_type(m.from_user.id)
+    if not curr_user:
+        await m.reply_text("Stay in you limit")
+        return
+    split = m.command
+    reply_to = m.reply_to_message
+
+    if reply_to:
+        try:
+            curr = reply_to.from_user.id
+        except Exception:
+            await m.reply_text("Reply to an user")
+            return
+        support.delete_support_user(curr)
+        await m.reply_text("Done")
+    elif len(split) >= 2:
+        try:
+            user,_,_ = extract_user(split[1])
+        except Exception:
+            await m.reply_text("Dunno who u r talking abt")
+            return
+        support.delete_support_user(user)
+        await m.reply_text("Done")
+    else:
+        await m.reply_text("**USAGE**\n/rmsupport [reply to user | user id | username]")
     return
-      
+
 @Gojo.on_message(command("ping", sudo_cmd=True))
 async def ping(_, m: Message):
     LOGGER.info(f"{m.from_user.id} used ping cmd in {m.chat.id}")
@@ -199,7 +332,7 @@ async def evaluate_code(c: Gojo, m: Message):
                 f"@{m.from_user.username} TREID TO FETCH ENV OF BOT \n userid = {m.from_user.id}",
             )
     for j in HARMFUL:
-        if j in evaluation:
+        if j in evaluation.split() or j in cmd:
             if m.from_user.id != OWNER_ID:
                 evaluation = "Bhaag ja bsdk"
                 await c.send_message(
@@ -480,6 +613,58 @@ async def chat_broadcast(c: Gojo, m: Message):
 
     return
 
+@Gojo.on_message(command(["forward","fwd"]),dev_cmd=True)
+async def forward_type_broadcast(c: Gojo, m: Message):
+    repl = m.reply_to_message
+    if not repl:
+        await m.reply_text("Please reply to message to broadcast it")
+        return
+    split = m.command
+    
+    chat = Chats.list_chats_by_id()
+    user = [i["_id"] for i in Users.list_users()]
+    alll = chat + user
+    if len(split) != 2:
+        tag = "all"
+    else:
+        try:
+            if split[0].lower() == "-u":
+                tag = "user"
+            elif split[0].lower() == "-c":
+                tag = "chat"
+            else:
+                tag = "all"
+        except IndexError:
+            pass
+    if tag == "chat":
+        peers = chat
+    elif tag == "user":
+        peers = user
+    else:
+        peers = alll
+    
+    xx = await m.reply_text("Broadcasting...")
+
+    failed = 0
+    total = len(peers)
+    for peer in peers:
+        try:
+            await repl.forward(int(peer))
+            await sleep(0.1)
+        except Exception:
+            failed += 1
+            pass
+    txt = f"Broadcasted message to {total-failed} peers out of {total}\nFailed to broadcast message to {failed} peers"
+    if not failed:
+        txt = f"Broadcasted message to {total} peers"
+    await m.reply_text(txt)
+    try:
+        await xx.delete()
+    except Exception:
+        pass
+    return
+
+
 @Gojo.on_message(command(["cleandb","cleandatabase"],sudo_cmd=True))
 async def cleeeen(c:Gojo,m:Message):
     x = await m.reply_text("Cleaning the database...")
@@ -518,6 +703,11 @@ __HELP__ = """
 • /uptime : Return the uptime of the bot.
 • /leavechat : Bot will leave the provided chat.
 • /chatbroadcast : Broadcast the messge to chats.
+• /forward (/fwd) [tag] : Forward message to peers according to tag. Default to all
+    Available tags:
+     `-u` : For users
+     `-c` : For chats
+     `-all` : For all
 
 **Sudoer's command:**
 • /ping : return the ping of the bot.

Powers/plugins/flood.py

@@ -10,7 +10,7 @@ from pyrogram.types import (CallbackQuery, ChatPermissions,
                             InlineKeyboardButton, InlineKeyboardMarkup,
                             Message)
 
-from Powers import LOGGER, SUPPORT_GROUP, SUPPORT_STAFF
+from Powers import LOGGER, SUPPORT_GROUP, get_support_staff
 from Powers.bot_class import Gojo
 from Powers.database.approve_db import Approve
 from Powers.database.flood_db import Floods
@@ -19,6 +19,8 @@ from Powers.utils.extras import BAN_GIFS, KICK_GIFS, MUTE_GIFS
 from Powers.utils.kbhelpers import ikb
 from Powers.vars import Config
 
+SUPPORT_STAFF = get_support_staff()
+
 on_key = ["on", "start", "disable"]
 off_key = ["off", "end", "enable", "stop"]
 
@@ -408,7 +410,7 @@ async def flood_watcher(c: Gojo, m: Message):
                             ],
                         ],
                     )
-                    txt = "Don't dare to spam here if I am around!"
+                    txt = "Don't dare to spam here if I am around! Nothing can escape my 6 eyes\nAction: Baned\nReason: Spaming"
                     await m.reply_animation(
                         animation=str(choice(BAN_GIFS)),
                         caption=txt,
@@ -440,7 +442,7 @@ async def flood_watcher(c: Gojo, m: Message):
             elif action == "kick":
                 try:
                     await m.chat.ban_member(u_id)
-                    txt = "Don't dare to spam here if I am around!"
+                    txt = "Don't dare to spam here if I am around! Nothing can escape my 6 eyes\nAction: kicked\nReason: Spaming"
                     await m.reply_animation(
                         animation=str(choice(KICK_GIFS)),
                         caption=txt,
@@ -483,7 +485,7 @@ async def flood_watcher(c: Gojo, m: Message):
                             ],
                         ],
                     )
-                    txt = "Don't dare to spam here if I am around!"
+                    txt = "Don't dare to spam here if I am around! Nothing can escape my 6 eyes\nAction: Muted\nReason: Spaming"
                     await m.reply_animation(
                         animation=str(choice(MUTE_GIFS)),
                         caption=txt,

Powers/plugins/fun.py

@@ -5,13 +5,14 @@ from pyrogram import enums
 from pyrogram.errors import MessageTooLong
 from pyrogram.types import Message
 
-from Powers import DEV_USERS, LOGGER
+from Powers import LOGGER, get_support_staff
 from Powers.bot_class import Gojo
 from Powers.utils import extras
 from Powers.utils.custom_filters import command
 from Powers.utils.extras import NOWYES as NO
 from Powers.utils.extras import YESWNO as YES
 
+DEV_USERS = get_support_staff("dev")
 
 @Gojo.on_message(command("shout"))
 async def fun_shout(_, m: Message):

Powers/plugins/greetings.py

@@ -6,7 +6,7 @@ from pyrogram.enums import ChatMemberStatus as CMS
 from pyrogram.errors import ChatAdminRequired, RPCError
 from pyrogram.types import ChatMemberUpdated, InlineKeyboardMarkup, Message
 
-from Powers import DEV_USERS
+from Powers import get_support_staff
 from Powers.bot_class import Gojo
 from Powers.database.antispam_db import GBan
 from Powers.database.greetings_db import Greetings
@@ -21,6 +21,8 @@ from Powers.vars import Config
 # Initialize
 gdb = GBan()
 
+DEV_USERS = get_support_staff("dev")
+
 ChatType = enums.ChatType
 
 

Powers/plugins/info.py

@@ -9,8 +9,7 @@ from pyrogram.raw.functions.channels import GetFullChannel
 from pyrogram.raw.functions.users import GetFullUser
 from pyrogram.types import Message
 
-from Powers import (DEV_USERS, LOGGER, OWNER_ID, SUDO_USERS, SUPPORT_STAFF,
-                    WHITELIST_USERS)
+from Powers import LOGGER, OWNER_ID, get_support_staff
 from Powers.bot_class import Gojo
 from Powers.database.antispam_db import GBan
 from Powers.utils.custom_filters import command
@@ -83,6 +82,10 @@ async def user_info(c: Gojo, user, already=False):
         about = ll.full_user.about
     except Exception:
         pass
+    SUPPORT_STAFF = get_support_staff()
+    DEV_USERS = get_support_staff("dev")
+    SUDO_USERS = get_support_staff("sudo")
+    WHITELIST_USERS = get_support_staff("whitelist")
     username = user.username
     first_name = user.first_name
     last_name = user.last_name

Powers/plugins/locks.py

@@ -6,43 +6,45 @@ from pyrogram.enums import MessageEntityType as MET
 from pyrogram.errors import ChatAdminRequired, ChatNotModified, RPCError
 from pyrogram.types import ChatPermissions, Message
 
-from Powers import DEV_USERS, LOGGER, OWNER_ID, SUDO_USERS
+from Powers import LOGGER, get_support_staff
 from Powers.bot_class import Gojo
 from Powers.database.approve_db import Approve
 from Powers.utils.caching import ADMIN_CACHE, admin_cache_reload
 from Powers.utils.custom_filters import command, restrict_filter
 from Powers.vars import Config
 
-SUDO_LEVEL = set(SUDO_USERS + DEV_USERS + [int(OWNER_ID)])
+SUDO_LEVEL = get_support_staff("sudo_level")
 
 anti_c_send = [-1001604479593]
 anti_forward = [-1001604479593]
 anti_forward_u = []
 anti_forward_c = []
 anti_links = []
+
+l_t = """
+**Lock Types:**
+- `all` = Everything
+- `msg` = Messages
+- `media` = Media, such as Photo and Video.
+- `polls` = Polls
+- `invite` = Add users to Group
+- `pin` = Pin Messages
+- `info` = Change Group Info
+- `webprev` = Web Page Previews
+- `inlinebots`, `inline` = Inline bots
+- `animations` = Animations
+- `games` = Game Bots
+- `stickers` = Stickers
+- `anonchannel` = Send as chat will be locked
+- `forwardall` = Forwarding from channel and user
+- `forwardu` = Forwarding from user
+- `forwardc` = Forwarding from channel
+- `links | url` = Lock links"""
+
 @Gojo.on_message(command("locktypes"))
 async def lock_types(_, m: Message):
     await m.reply_text(
-        (
-            "**Lock Types:**\n"
-            " - `all` = Everything\n"
-            " - `msg` = Messages\n"
-            " - `media` = Media, such as Photo and Video.\n"
-            " - `polls` = Polls\n"
-            " - `invite` = Add users to Group\n"
-            " - `pin` = Pin Messages\n"
-            " - `info` = Change Group Info\n"
-            " - `webprev` = Web Page Previews\n"
-            " - `inlinebots`, `inline` = Inline bots\n"
-            " - `animations` = Animations\n"
-            " - `games` = Game Bots\n"
-            " - `stickers` = Stickers\n"
-            " - `anonchannel` = Send as chat will be locked\n"
-            " - `forwardall` = Forwarding from channel and user\n"
-            " - `forwardu` = Forwarding from user\n"
-            " - `forwardc` = Forwarding from channel\n"
-            " - `links | url` = Lock links"
-        ),
+        l_t
     )
     return
 
@@ -532,6 +534,11 @@ __PLUGIN__ = "locks"
 
 __alt_name__ = ["grouplock", "lock", "grouplocks"]
 
+__buttons__ = [
+    [
+        ("Lock Types", "LOCK_TYPES"),
+    ],]
+
 __HELP__ = """
 **Locks**
 

Powers/plugins/muting.py

@@ -9,7 +9,7 @@ from pyrogram.types import (CallbackQuery, ChatPermissions,
                             InlineKeyboardButton, InlineKeyboardMarkup,
                             Message)
 
-from Powers import LOGGER, MESSAGE_DUMP, OWNER_ID, SUPPORT_STAFF
+from Powers import LOGGER, MESSAGE_DUMP, OWNER_ID, get_support_staff
 from Powers.bot_class import Gojo
 from Powers.utils.caching import ADMIN_CACHE, admin_cache_reload
 from Powers.utils.custom_filters import command, restrict_filter
@@ -19,6 +19,7 @@ from Powers.utils.parser import mention_html
 from Powers.utils.string import extract_time
 from Powers.vars import Config
 
+SUPPORT_STAFF = get_support_staff()
 
 @Gojo.on_message(command("tmute") & restrict_filter)
 async def tmute_usr(c: Gojo, m: Message):
@@ -90,8 +91,6 @@ async def tmute_usr(c: Gojo, m: Message):
         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(
@@ -203,8 +202,6 @@ async def dtmute_usr(c: Gojo, m: Message):
         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(
@@ -384,8 +381,6 @@ async def mute_usr(c: Gojo, m: Message):
         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(
             [
                 [
@@ -543,8 +538,6 @@ async def dmute_usr(c: Gojo, m: Message):
         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(
             [
                 [

Powers/plugins/report.py

@@ -6,13 +6,14 @@ from pyrogram.enums import ChatType
 from pyrogram.errors import RPCError
 from pyrogram.types import CallbackQuery, Message
 
-from Powers import LOGGER, SUPPORT_STAFF
+from Powers import LOGGER, get_support_staff
 from Powers.bot_class import Gojo
 from Powers.database.reporting_db import Reporting
 from Powers.utils.custom_filters import admin_filter, command
 from Powers.utils.kbhelpers import ikb
 from Powers.utils.parser import mention_html
 
+SUPPORT_STAFF = get_support_staff()
 
 @Gojo.on_message(
     command("reports") & (filters.private | admin_filter),

Powers/plugins/start.py

@@ -1,3 +1,4 @@
+import os
 from random import choice
 from time import gmtime, strftime, time
 
@@ -12,11 +13,13 @@ from pyrogram.types import (CallbackQuery, InlineKeyboardButton,
 from Powers import (HELP_COMMANDS, LOGGER, PYROGRAM_VERSION, PYTHON_VERSION,
                     UPTIME, VERSION)
 from Powers.bot_class import Gojo
+from Powers.database.captcha_db import CAPTCHA_DATA
 from Powers.utils.custom_filters import command
 from Powers.utils.extras import StartPic
 from Powers.utils.kbhelpers import ikb
 from Powers.utils.start_utils import (gen_cmds_kb, gen_start_kb, get_help_msg,
                                       get_private_note, get_private_rules)
+from Powers.utils.string import encode_decode
 from Powers.vars import Config
 
 
@@ -103,6 +106,23 @@ async def start(c: Gojo, m: Message):
                         quote=True,
                     )
                     return
+                elif help_option.split("_",1)[0] == "qrcaptcha":
+                    decoded = encode_decode(help_option.split("_",1)[1],"decode")
+                    decode = decoded.split(":")
+                    chat = decode[0]
+                    user = decode[1]
+                    if m.from_user.id != int(user):
+                        await m.reply_text("Not for you Baka")
+                        return
+                    try:
+                        await c.unban_chat_member(int(chat),int(user))
+                        try:
+                            os.remove(f"captcha_verification{chat}_{user}.png")
+                        except Exception:
+                            pass
+                        return
+                    except Exception:
+                        return
         try:
             cpt = f"""
 Hey [{m.from_user.first_name}](http://t.me/{m.from_user.username})! I am Gojo ✨.

Powers/plugins/utils.py

@@ -62,7 +62,7 @@ async def wiki(_, m: Message):
 
 @Gojo.on_message(command("gdpr"))
 async def gdpr_remove(_, m: Message):
-    if m.from_user.id in SUPPORT_STAFF:
+    if m.from_user.id in get_support_staff():
         await m.reply_text(
             "You're in my support staff, I cannot do that unless you are no longer a part of it!",
         )
@@ -239,6 +239,11 @@ async def github(_, m: Message):
         return
     r = r.json()
     avtar = r.get("avatar_url", None)
+    if avtar:
+        avtar = avtar.rsplit("=",1)
+        avtar.pop(-1)
+        avtar.append("5")
+        avtar = "=".join(avtar)
     url = r.get("html_url", None)
     name = r.get("name", None)
     company = r.get("company", None)
@@ -281,6 +286,12 @@ async def github(_, m: Message):
     if bio:
         REPLY += f"\n\n<b>🎯 Bio:</b> {bio}"
 
+    kb = InlineKeyboardMarkup(
+        [
+            InlineKeyboardButton("")
+        ]
+    )
+
     if avtar:
         return await m.reply_photo(photo=f"{avtar}", caption=REPLY)
     await m.reply_text(REPLY)

Powers/plugins/warns.py

@@ -6,7 +6,7 @@ from pyrogram.types import (CallbackQuery, ChatPermissions,
                             InlineKeyboardButton, InlineKeyboardMarkup,
                             Message)
 
-from Powers import LOGGER, SUPPORT_STAFF, TIME_ZONE
+from Powers import LOGGER, TIME_ZONE, get_support_staff
 from Powers.bot_class import Gojo
 from Powers.database.rules_db import Rules
 from Powers.database.users_db import Users
@@ -17,6 +17,7 @@ from Powers.utils.extract_user import extract_user
 from Powers.utils.parser import mention_html
 from Powers.vars import Config
 
+SUPPORT_STAFF = get_support_staff()
 
 @Gojo.on_message(
     command(["warn", "swarn", "dwarn"]) & restrict_filter,

Powers/plugins/watchers.py

@@ -7,7 +7,7 @@ from pyrogram import filters
 from pyrogram.errors import ChatAdminRequired, RPCError, UserAdminInvalid
 from pyrogram.types import ChatPermissions, Message
 
-from Powers import LOGGER, MESSAGE_DUMP, SUPPORT_STAFF
+from Powers import LOGGER, MESSAGE_DUMP, get_support_staff
 from Powers.bot_class import Gojo
 from Powers.database.antispam_db import ANTISPAM_BANNED, GBan
 from Powers.database.approve_db import Approve
@@ -21,7 +21,7 @@ from Powers.utils.regex_utils import regex_searcher
 
 # Initialise
 gban_db = GBan()
-
+SUPPORT_STAFF = get_support_staff()
 
 @Gojo.on_message(filters.linked_channel)
 async def antichanpin_cleanlinked(c: Gojo, m: Message):

Powers/utils/admin_check.py

@@ -3,10 +3,8 @@ from traceback import format_exc
 from pyrogram.enums import ChatMemberStatus as CMS
 from pyrogram.types import CallbackQuery, Message
 
-from Powers import DEV_USERS, LOGGER, OWNER_ID, SUDO_USERS
-
-SUDO_LEVEL = SUDO_USERS + DEV_USERS + [int(OWNER_ID)]
-DEV_LEVEL = DEV_USERS + [int(OWNER_ID)]
+from Powers import LOGGER, OWNER_ID
+from Powers.database.support_db import SUPPORTS
 
 
 async def admin_check(m: Message or CallbackQuery) -> bool:
@@ -16,6 +14,11 @@ async def admin_check(m: Message or CallbackQuery) -> bool:
     if isinstance(m, CallbackQuery):
         user_id = m.message.from_user.id
 
+    support = SUPPORTS()
+
+    SUDO_LEVEL = support.get_particular_support("sudo") + support.get_particular_support("dev") + [int(OWNER_ID)]
+    DEV_LEVEL = support.get_particular_support("dev") + [int(OWNER_ID)]
+
     try:
         if user_id in SUDO_LEVEL:
             return True
@@ -66,6 +69,10 @@ async def owner_check(m: Message or CallbackQuery) -> bool:
         user_id = m.message.from_user.id
         m = m.message
 
+    support = SUPPORTS()
+
+    SUDO_LEVEL = support.get_particular_support("sudo") + support.get_particular_support("dev") + [int(OWNER_ID)]
+
     try:
         if user_id in SUDO_LEVEL:
             return True

Powers/utils/captcha_helper.py

@@ -0,0 +1,56 @@
+from random import choice, randint, randrange
+
+import qrcode
+from captcha.image import ImageCaptcha
+from pyrogram.types import InlineKeyboardButton as IKB
+from pyrogram.types import InlineKeyboardMarkup as IKM
+
+from Powers.database.captcha_db import CAPTCHA_DATA
+from Powers.utils.string import encode_decode
+from Powers.vars import Config
+
+initial = f"t.me/{Config.BOT_USERNAME}?start=qrcaptcha_"
+captchaa = CAPTCHA_DATA()
+
+async def get_qr_captcha(chat,user):
+    encode = f"{chat}:{user}"
+    encoded = encode_decode(encode)
+    final = initial+encoded
+    qr = qrcode.make(final)
+    name = f"captcha_verification{chat}_{user}.png"
+    qr.save(name)
+    return name
+
+def genrator():
+    alpha = ["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
+    rand_alpha = choice(alpha)
+    if_ = randint(0,1)
+    
+    if if_:
+        new_alpha = rand_alpha.upper()
+    else:
+        new_alpha = rand_alpha
+
+    list_ = [new_alpha]
+    while len(list_) != 4:
+        xXx = randrange(0,9)
+        list_.append(xXx)
+
+    str_ = ""
+    while len(str_) != 4:
+        OwO = choice(list_)
+        str_ += OwO 
+    return str_
+
+async def get_image_captcha(chat,user):
+    str_ = genrator()
+    captchaa.load_cap_data(chat,user,str_)
+    name = f"captcha_img_{chat}_{user}.png"
+    image = ImageCaptcha(280,90)
+
+    cap = image.generate(str_)
+    image.write(str_,name)
+
+    return name, str_
+
+

Powers/utils/custom_filters.py

@@ -9,14 +9,11 @@ from pyrogram.errors import RPCError, UserNotParticipant
 from pyrogram.filters import create
 from pyrogram.types import CallbackQuery, Message
 
-from Powers import DEV_USERS, OWNER_ID, SUDO_USERS
+from Powers import OWNER_ID, get_support_staff
 from Powers.database.disable_db import Disabling
 from Powers.utils.caching import ADMIN_CACHE, admin_cache_reload
 from Powers.vars import Config
 
-SUDO_LEVEL = set(SUDO_USERS + DEV_USERS + [int(OWNER_ID)])
-DEV_LEVEL = set(DEV_USERS + [int(OWNER_ID)])
-
 
 def command(
     commands: Union[str, List[str]],
@@ -29,6 +26,8 @@ def command(
         if not m:
             return
 
+        SUDO_LEVEL = get_support_staff("sudo_level")
+        DEV_LEVEL = get_support_staff("dev_level")
         date = m.edit_date
         if date:
             return  # reaction
@@ -289,6 +288,7 @@ async def can_pin_message_func(_, __, m):
         return True
 
     # Bypass the bot devs, sudos and owner
+    SUDO_LEVEL = get_support_staff("sudo_level")
     if m.from_user.id in SUDO_LEVEL:
         return True
 

Powers/utils/msg_types.py

@@ -89,7 +89,7 @@ async def get_note_type(m: Message):
 async def get_filter_type(m: Message):
     """Get filter type."""
     if len(m.text.split()) <= 1:
-        return None, None, None, None
+        return None, None, None
 
     data_type = None
     content = None
@@ -158,6 +158,9 @@ async def get_filter_type(m: Message):
 
 async def get_wlcm_type(m: Message):
     """Get wlcm type."""
+    if len(m.text.split()) <= 1:
+        return None, None, None
+        
     data_type = None
     content = None
     raw_text = m.text.markdown if m.text else m.caption.markdown

Powers/utils/start_utils.py

@@ -72,8 +72,8 @@ async def gen_start_kb(q: Message or CallbackQuery):
             ],
             [
                 (
-                    "Join for GFx work",
-                    "https://t.me/psy_Logos",
+                    "Essential",
+                    "https://t.me/+PcVYvdzNt4E1YjM1",
                     "url",
                 ),
                 (

Powers/utils/sticker_help.py

@@ -136,7 +136,7 @@ async def get_document_from_file_id(
     )
 
 
-async def draw_meme(image_path: str, text: str, sticker: bool, fiill: str) -> list:
+async def draw_meame(image_path: str, text: str, sticker: bool, fiill: str) -> list:
     _split = text.split(";", 1)
     if len(_split) == 2:
         lower_text = _split[1]
@@ -183,7 +183,7 @@ async def draw_meme(image_path: str, text: str, sticker: bool, fiill: str) -> li
 #     img = Image.open(image_path)
 #     i_width, i_height = img.size
 #     m_font = ImageFont.truetype(
-#         "./extras/comic.ttf", int((70 / 640) * i_width)
+#         "./extras/comic.ttf", int(i_width / 11)
 #     )
 #     if ";" in text:
 #         upper_text, lower_text = text.split(";")

Powers/utils/string.py

@@ -1,3 +1,4 @@
+import base64
 from datetime import datetime, timedelta
 from html import escape
 from re import compile as compile_re
@@ -192,3 +193,24 @@ async def remove_escapes(text: str) -> str:
         else:
             res += text[counter]
     return res
+
+async def encode_decode(string: str,to_do="encode"):
+    """
+    Function to encode or decode strings
+    string: string to be decoded or encoded
+    to_do: encode to encode the string or decode to decode the string
+    """
+    if to_do.lower() == "encode":
+        encodee = string.encode("ascii")
+        base64_ = base64.b64encode(encodee)
+        B64 = base64_.decode("ascii")
+    
+    elif to_do.lower() == "decode":
+        decodee = string.encode("ascii")
+        base64_ = base64.b64decode(decodee)
+        B64 = base64_.decode("ascii")
+
+    else:
+        B64 = None
+
+    return B64

requirements.txt

@@ -4,6 +4,7 @@ apscheduler==3.10.4
 asyncio==3.4.3
 beautifulsoup4==4.12.2; python_full_version >= "3.6"
 cachetools==5.2.0; python_version >= "3.7" and python_version < "4.0"
+captcha==0.5.0
 certifi==2023.7.22; python_version >= "3.7" and python_version < "4"
 charset-normalizer==2.1.0; python_version >= "3.7" and python_version < "4" and python_full_version >= "3.6.0"
 dnspython==2.2.1; python_version >= "3.6" and python_version < "4.0"
@@ -15,12 +16,13 @@ pillow == 10.0.0
 prettyconf==2.2.1
 pyaes==1.6.1; python_version >= "3.6" and python_version < "4.0"
 pymongo==4.5.0
-pyroaddon==1.0.6
 pyrogram==2.0.106; python_version >= "3.8"
 pysocks==1.7.1; python_version >= "3.7" and python_full_version < "3.0.0" and python_version < "4.0" or python_version >= "3.7" and python_version < "4.0" and python_full_version >= "3.4.0"
 python-dateutil==2.8.2; (python_version >= "2.7" and python_full_version < "3.0.0") or (python_full_version >= "3.3.0")
+pytube==15.0.0
 pytz==2023.3
 pyyaml==6.0.1; python_version >= "3.6"
+qrcode==7.4.2
 regex==2023.8.8; python_version >= "3.6"
 requests==2.31.0
 rfc3986==1.5.0; python_version >= "3.7"
@@ -35,4 +37,5 @@ ujson==5.8.0; python_version >= "3.7"
 urllib3==1.26.11; python_version >= "3.7" and python_full_version < "3.0.0" and python_version < "4" or python_full_version >= "3.6.0" and python_version < "4" and python_version >= "3.7"
 uvloop==0.17.0
 wikipedia==1.4.0
-yt-dlp==2023.7.6
+youtube-search-python==1.6.6
+yt-dlp@git+https://github.com/HellBoy-OP/yt-dp-fork.git@af1fd12f675220df6793fc019dff320bc76e8080