Merge branch 'main' of https://github.com/Gojo-Bots/Gojo_Satoru

Powers/__main__.py

@@ -1,8 +1,11 @@
-# import uvloop  # Comment it out if using on windows
+import uvloop  # Comment it out if using on windows
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+
+from Powers import BDB_URI, TIME_ZONE
 from Powers.bot_class import Gojo
 
 if __name__ == "__main__":
-    # uvloop.install() # Comment it out if using on windows
+    uvloop.install() # Comment it out if using on windows
     Gojo().run()
     
     

Powers/database/afk_db.py

@@ -0,0 +1,55 @@
+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=None):
+        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,"time":time})
+                if media:
+                    self.update({"chat_id":chat_id,"user_id":user_id},{'media':media,'media_type':media_type,"time":time})
+                return True
+            else:
+                self.insert_one(
+                    {
+                        "chat_id":chat_id,
+                        "user_id":user_id,
+                        "reason":reason,
+                        "time":time,
+                        "media":media,
+                        "media_type":media_type
+                    }
+                )
+                return True
+
+    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/autojoin_db.py

@@ -0,0 +1,50 @@
+from threading import RLock
+from time import time
+
+from Powers import LOGGER
+from Powers.database import MongoDB
+
+INSERTION_LOCK = RLock()
+
+
+class AUTOJOIN(MongoDB):
+    """class to store auto join requests"""
+
+    db_name = "autojoin"
+
+    def __init__(self) -> None:
+        super().__init__(self.db_name)
+
+    def load_autojoin(self, chat,mode="auto"):
+        """
+        type = auto or notify
+        auto to auto accept join requests
+        notify to notify the admins about the join requests
+        """
+        curr = self.find_one({"chat_id":chat,})
+        if not curr:
+            with INSERTION_LOCK:
+                self.insert_one({"chat_id":chat,"type":mode})
+            return True
+        return False
+
+    def get_autojoin(self,chat):
+        curr = self.find_one({"chat_id":chat})
+        if not curr:
+            return False
+        else:
+            return curr["type"]
+
+    def update_join_type(self,chat,mode):
+        curr = self.find_one({"chat_id":chat})
+        if curr:
+            self.update({"chat_id":chat},{"type":mode})
+            return 
+        else:
+            return
+
+    def remove_autojoin(self,chat):
+        curr = self.find_one({"chat_id":chat})
+        if curr:
+            self.delete_one({"chat_id":chat})
+        return

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/plugins/afk.py

@@ -0,0 +1,167 @@
+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, PREFIX_HANDLER
+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_afk_type
+from Powers.vars import Config
+
+# from traceback import format_exc
+
+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_afk_type(m)
+    
+    time = str(datetime.now()).rsplit(".",1)[0]
+
+    if len(m.command) == 1:
+        text = choice(res)
+
+    elif len(m.command) > 1:
+        text = m.text.markdown.split(None,1)[1]
+
+    if not data_type:
+        data_type = Types.TEXT
+
+    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(":")
+    txt = ""
+    if int(tim[0]):
+        txt += tim[0] + " hours "
+    if int(tim[1]):
+        txt += tim[1] + " minutes "
+    if int(round(float(tim[2]))):
+        txt += str(round(float(tim[2]))) + " seconds"
+    
+    return txt
+
+
+@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)
+    is_rep_afk = False
+    if rep_user:
+        is_rep_afk = afk.check_afk(chat,rep_user)
+
+    if is_rep_afk and rep_user != user:
+        con = afk.get_afk(chat,rep_user)
+        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])
+        if len(tim_) == 1:
+            tims = tim
+        elif len(tim_) == 2:
+            tims = tim_[0] + " " + tim
+        reason = f"{repl.from_user.first_name} is afk since {tims}\n"
+        if con['reason'] not in res:
+            reason += f"\nDue to: {con['reason'].format(first=repl.from_user.first_name)}"
+        else:
+            reason += f"\n{con['reason'].format(first=repl.from_user.first_name)}"
+        txt = reason
+
+        if media_type == Types.TEXT:        
+            await (await send_cmd(c,media_type))(
+                chat,
+                txt,
+                parse_mode=PM.MARKDOWN,
+                reply_to_message_id=m.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 = False
+        try:
+            txt = m.command[0]
+        except Exception:
+            pass
+
+        if txt and 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])
+            if len(tim_) == 1:
+                tims = tim
+            elif len(tim_) == 2:
+                tims = tim_[0] + " " + tim
+            txt = back_.format(first=m.from_user.mention) + f"\n\nAfk for: {tims}"
+            await m.reply_text(txt)
+        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/auto_join.py

@@ -0,0 +1,147 @@
+from pyrogram import filters
+from pyrogram.enums import ChatMemberStatus as CMS
+from pyrogram.types import CallbackQuery, ChatJoinRequest
+from pyrogram.types import InlineKeyboardButton as ikb
+from pyrogram.types import InlineKeyboardMarkup as ikm
+from pyrogram.types import Message
+
+from Powers.bot_class import Gojo
+from Powers.database.autojoin_db import AUTOJOIN
+from Powers.supports import get_support_staff
+from Powers.utils.custom_filters import admin_filter, command
+
+SUPPORT_STAFF = get_support_staff()
+
+@Gojo.on_message(command(["joinreq"]) & admin_filter)
+async def accept_join_requests(c: Gojo, m: Message):
+    if m.chat.id == m.from_user.id:
+        await m.reply_text("Use it in groups")
+        return
+
+    split = m.command
+    a_j = AUTOJOIN()
+
+    if len(split) == 1:
+        txt = "**USAGE**\n/joinreq [on | off]"
+        await m.reply_text(txt)
+        return
+    else:
+        yes_no = split[1].lower()
+        if yes_no not in ["on","off"]:
+            txt = "**USAGE**\n/joinreq [on | off]"
+            await m.reply_text(txt)
+            return
+        
+        else:
+            if yes_no == "on":
+                is_al = a_j.load_autojoin(m.chat.id)
+                
+                if is_al:
+                    txt = "Now I will approve all the join request of the chat\nIf you want that I will just notify admins about the join request use command\n//joinreqmode [manual | auto]"
+                    await m.reply_text(txt)
+                    return
+                else:
+                    txt = "Auto approve join request is already on for this chat\nIf you want that I will just notify admins about the join request use command\n/joinreqmode [manual | auto]"
+                    await m.reply_text(txt)
+                    return
+
+            elif yes_no == "off":
+                a_j.remove_autojoin(m.chat.id)
+                txt = "Now I will neither auto approve join request nor notify any admins about it"
+                await m.reply_text(txt)
+                return
+
+@Gojo.on_message(command("joinreqmode") & admin_filter)
+async def join_request_mode(c: Gojo, m: Message):
+    if m.chat.id == m.from_user.id:
+        await m.reply_text("Use it in groups")
+        return
+    u_text = "**USAGE**\n/joinreqmode [auto | manual]\nauto: auto approve joins\nmanual: will notify admin about the join request"
+        
+    split = m.command
+    a_j = AUTOJOIN()
+        
+    if len(split) == 1:
+        await m.reply_text(u_text)
+        return
+
+    else:
+        auto_manual = split[1]
+        if auto_manual not in ["auto","manual"]:
+            await m.reply_text(u_text)
+            return
+        else:
+            a_j.update_join_type(m.chat.id,auto_manual)
+            txt = "Changed join request type"
+            await m.reply_text(txt)
+            return
+
+
+@Gojo.on_chat_join_request(filters.group)
+async def join_request_handler(c: Gojo, j: ChatJoinRequest):
+    chat = j.chat.id
+    aj = AUTOJOIN()
+    join_type = aj.get_autojoin(chat)
+    
+    if not join_type:
+        return
+    
+    user = j.from_user.id
+    userr = j.from_user
+    if join_type == "auto" or user in SUPPORT_STAFF:
+        await c.approve_chat_join_request(chat,user)
+
+    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 ''}"
+        txt += f"Mention: {userr.mention}"
+        txt += f"Id: {user}"
+        txt += f"Scam: {'True' if  userr.is_scam else 'False'}"
+        if userr.username:
+            txt+= f"Username: @{userr.username}"
+        kb = [
+            [
+                ikb("Accept",f"accept_joinreq_uest_{user}"),
+                ikb("Decline",f"decline_joinreq_uest_{user}")
+            ]
+        ]
+        await c.send_message(chat,txt,reply_markup=ikm(kb))
+        return
+
+@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
+    user_status = (await q.message.chat.get_member(user_id)).status
+    if user_status not in {CMS.OWNER, CMS.ADMINISTRATOR}:
+        await q.answer(
+            "You're not even an admin, don't try this explosive shit!",
+            show_alert=True,
+        )
+        return
+
+    split = q.data.split("_")
+    chat = q.message.chat.id
+    user = int(split[-1])
+    data = split[0]
+
+    if data == "accept":
+        await c.approve_chat_join_request(chat,user)
+        await q.answer(f"APPROVED: {user}",True)
+    elif data == "decline":
+        await c.decline_chat_join_request(chat,user)
+        await q.answer(f"DECLINED: {user}")
+
+    return
+
+__PLUGIN__ = "auto join"
+
+__alt_name__ = ["join_request"]
+
+
+__HELP__ = """
+**Auto join request**
+
+**Admin commands:**
+• /joinreq [on | off]: To switch on auto accept join request 
+• /joinreqmode [auto | manual]: `auto` to accept join request automatically and `manual` to get notified when new join request is available
+"""

Powers/plugins/captcha.py

@@ -0,0 +1,234 @@
+from random import shuffle
+from traceback import format_exc
+
+import pyrogram  # don't remove
+from pyrogram import filters
+from pyrogram.enums import ChatMemberStatus as CMS
+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
+from Powers.bot_class import Gojo
+from Powers.database.captcha_db import CAPTCHA, CAPTCHA_DATA
+from Powers.supports import get_support_staff
+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].lower()
+        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,18)
+async def joinss(c: Gojo, u: ChatMemberUpdated):
+    chat = u.chat.id
+
+    if (
+        u.new_chat_member
+    ):
+        pass
+    else:
+        return
+
+    user = u.new_chat_member.user.id
+    userr = u.new_chat_member.user
+
+    is_qr = CAPTCHA().is_captcha(chat)
+    if not is_qr:
+        return
+
+    captcha = CAPTCHA()
+    cap_data = CAPTCHA_DATA()
+
+    if user in SUPPORT_STAFF:
+        return
+
+    captcha_type = captcha.get_captcha(chat)
+
+    is_already = cap_data.is_already_data(chat, user)
+    
+    mess = False
+    try:
+        if is_already:
+            mess = await c.get_messages(chat,int(is_already))
+    except Exception:
+        cap_data.del_message_id(chat,is_already)
+        mess = False
+        is_already = False
+
+    if is_already and not mess:
+        cap_data.del_message_id(chat,is_already)
+        return
+
+    try:
+        await c.restrict_chat_member(chat,user,ChatPermissions())
+    except Exception as e:
+        LOGGER.error(e)
+        LOGGER.error(format_exc())
+        return
+
+    if not is_already:
+        if captcha_type == "qr":
+            pic = await get_qr_captcha(chat, user)
+            cap = f"Please {userr.mention} scan this qr code with your phone to verify that you are human"
+            ms = await c.send_photo(chat,pic,caption=cap)
+            cap_data.store_message_id(chat,user,ms.id)
+            return
+        elif captcha_type == "image":
+            img, code = await get_image_captcha(chat, user)
+            cap = f"Please {userr.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 c.send_photo(chat,img,caption=cap,reply_markup=kb)
+            return
+    elif is_already and mess:
+        kb = ikm(
+            [
+                [
+                    ikb("Click here to verify",url=mess.link)
+                ]
+            ]
+        )
+        await c.send_message(f"{userr.mention} your verification is already pending",reply_markup=kb)
+        return
+    else:
+        await c.unban_chat_member(chat,user)
+        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,True)
+        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(chat,f"{q.from_user.mention} now you are free to talk")
+        await q.message.delete()
+        return
+    else:
+        caps = q.message.caption.split(":")
+        tries = int(caps[1].strip()) - 1
+        caps.pop(-1)
+        caps.append(f" {tries}")
+        new_cap = ":".join(caps)
+        await q.answer(f"Wrong\nTries left: {tries}", True)
+        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,reply_markup=q.message.reply_markup)
+            return
+
+
+__PLUGIN__ = "captcha"
+
+__HELP__ = """
+• /captcha [on|yes|enable|off|no|disable] : To enable or disable captcha verification
+• /captchamode [qr|image] : To change captcha mode
+"""

Powers/plugins/start.py

@@ -13,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
 
 
@@ -104,7 +106,6 @@ async def start(c: Gojo, m: Message):
                         quote=True,
                     )
                     return
-                
         try:
             cpt = f"""
 Hey [{m.from_user.first_name}](http://t.me/{m.from_user.username})! I am Gojo ✨.

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,12 @@ 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, PREFIX_HANDLER
 from Powers.database.disable_db import Disabling
+from Powers.supports import get_support_staff
 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 +27,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
@@ -61,7 +61,7 @@ def command(
         if not text:
             return False
         regex = r"^[{prefix}](\w+)(@{bot_name})?(?: |$)(.*)".format(
-            prefix="|".join(escape(x) for x in Config.PREFIX_HANDLER),
+            prefix="|".join(escape(x) for x in PREFIX_HANDLER),
             bot_name=Config.BOT_USERNAME,
         )
         matches = compile_re(regex).search(text)
@@ -289,6 +289,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/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

Version/version 2.2.0.md

@@ -0,0 +1,21 @@
+# V 2.1.1
+### Changes made:
+- Added `AFK` support.
+- Added `Captcha verification` for new joined members.
+- Added support for `join request` in the chat.
+- Now `lock types` will be stored in database.
+- Improved **youtube support** to provide best quality.
+- Now you can kang `video sticker` by replying to **videos** and **animations**.
+- Added few commands for **devs**.
+- Improved stability and few minor improvements.
+- Few bug fixes.
+- Bug known: 0
+- Deployed and tested locally
+
+## Report issues [here](https://github.com/Gojo-Bots/Gojo_Satoru/issues/new/choose) if find any.
+
+## Give ideas [here](https://github.com/Gojo-Bots/Gojo_Satoru/discussions/new?category=ideas) for next update.
+
+## Trying our best to give the best
+
+## Regards 🧑‍💻: [Captain D. Ezio](https://github.com/iamgojoof6eyes)