Second commit....Looks good

Powers/__main__.py

@@ -0,0 +1,4 @@
+from Powers.bot_class import Gojo
+
+if __name__ == "__main__":
+    Gojo().run()

Powers/bot_class.py

@@ -0,0 +1,116 @@
+from platform import python_version
+from threading import RLock
+from time import gmtime, strftime, time
+
+from pyrogram import Client, __version__
+from pyrogram.raw.all import layer
+
+from Powers import (
+    API_HASH,
+    APP_ID,
+    BOT_TOKEN,
+    LOG_DATETIME,
+    LOGFILE,
+    LOGGER,
+    MESSAGE_DUMP,
+    NO_LOAD,
+    UPTIME,
+    WORKERS,
+    load_cmds,
+)
+from Powers.database import MongoDB
+from Powers.plugins import all_plugins
+from Powers.tr_engine import lang_dict
+from Powers.vars import Config
+
+INITIAL_LOCK = RLock()
+
+# Check if MESSAGE_DUMP is correct
+if MESSAGE_DUMP == -100 or not str(MESSAGE_DUMP).startswith("-100"):
+    raise Exception(
+        "Please enter a vaild Supergroup ID, A Supergroup ID starts with -100",
+    )
+
+
+class Gojo(Client):
+    """Starts the Pyrogram Client on the Bot Token when we do 'python3 -m Powers'"""
+
+    def __init__(self):
+        name = self.__class__.__name__.lower()
+
+        super().__init__(
+            "Gojo_Satarou",
+            bot_token=BOT_TOKEN,
+            plugins=dict(root=f"{name}.plugins", exclude=NO_LOAD),
+            api_id=APP_ID,
+            api_hash=API_HASH,
+            workers=WORKERS,
+        )
+
+    async def start(self):
+        """Start the bot."""
+        await super().start()
+
+        meh = await self.get_me()  # Get bot info from pyrogram client
+        LOGGER.info("Starting bot...")
+        Config.BOT_ID = meh.id
+        Config.BOT_NAME = meh.first_name
+        Config.BOT_USERNAME = meh.username
+
+        startmsg = await self.send_message(MESSAGE_DUMP, "<i>Starting Bot...</i>")
+
+        # Load Languages
+        lang_status = len(lang_dict) >= 1
+        LOGGER.info(f"Loading Languages: {lang_status}\n")
+
+        # Show in Log that bot has started
+        LOGGER.info(
+            f"Pyrogram v{__version__} (Layer - {layer}) started on {meh.username}",
+        )
+        LOGGER.info(f"Python Version: {python_version()}\n")
+
+        # Get cmds and keys
+        cmd_list = await load_cmds(await all_plugins())
+
+        LOGGER.info(f"Plugins Loaded: {cmd_list}")
+
+        # Send a message to MESSAGE_DUMP telling that the
+        # bot has started and has loaded all plugins!
+        await startmsg.edit_text(
+            (
+                f"<b><i>@{meh.username} started on Pyrogram v{__version__} (Layer - {layer})</i></b>\n"
+                f"\n<b>Python:</b> <u>{python_version()}</u>\n"
+                "\n<b>Loaded Plugins:</b>\n"
+                f"<i>{cmd_list}</i>\n"
+            ),
+        )
+
+        LOGGER.info("Bot Started Successfully!\n")
+
+    async def stop(self):
+        """Stop the bot and send a message to MESSAGE_DUMP telling that the bot has stopped."""
+        runtime = strftime("%Hh %Mm %Ss", gmtime(time() - UPTIME))
+        LOGGER.info("Uploading logs before stopping...!\n")
+        # Send Logs to MESSAGE_DUMP and LOG_CHANNEL
+        await self.send_document(
+            MESSAGE_DUMP,
+            document=LOGFILE,
+            caption=(
+                "Bot Stopped!\n\n" f"Uptime: {runtime}\n" f"<code>{LOG_DATETIME}</code>"
+            ),
+        )
+        if MESSAGE_DUMP:
+            # LOG_CHANNEL is not necessary
+            await self.send_document(
+                MESSAGE_DUMP,
+                document=LOGFILE,
+                caption=f"Uptime: {runtime}",
+            )
+        await super().stop()
+        MongoDB.close()
+        LOGGER.info(
+            f"""Bot Stopped.
+            Logs have been uploaded to the MESSAGE_DUMP Group!
+            Runtime: {runtime}s\n
+        """,
+        )

Powers/database/__init__.py

@@ -0,0 +1,75 @@
+from sys import exit as exiter
+
+from pymongo import MongoClient
+from pymongo.errors import PyMongoError
+
+from Powers import DB_NAME, DB_URI, LOGGER
+
+try:
+    Powers_db_client = MongoClient(DB_URI)
+except PyMongoError as f:
+    LOGGER.error(f"Error in Mongodb: {f}")
+    exiter(1)
+Powers_main_db = Powers_db_client[DB_NAME]
+
+
+class MongoDB:
+    """Class for interacting with Bot database."""
+
+    def __init__(self, collection) -> None:
+        self.collection = Powers_main_db[collection]
+
+    # Insert one entry into collection
+    def insert_one(self, document):
+        result = self.collection.insert_one(document)
+        return repr(result.inserted_id)
+
+    # Find one entry from collection
+    def find_one(self, query):
+        result = self.collection.find_one(query)
+        if result:
+            return result
+        return False
+
+    # Find entries from collection
+    def find_all(self, query=None):
+        if query is None:
+            query = {}
+        return list(self.collection.find(query))
+
+    # Count entries from collection
+    def count(self, query=None):
+        if query is None:
+            query = {}
+        return self.collection.count_documents(query)
+
+    # Delete entry/entries from collection
+    def delete_one(self, query):
+        self.collection.delete_many(query)
+        return self.collection.count_documents({})
+
+    # Replace one entry in collection
+    def replace(self, query, new_data):
+        old = self.collection.find_one(query)
+        _id = old["_id"]
+        self.collection.replace_one({"_id": _id}, new_data)
+        new = self.collection.find_one({"_id": _id})
+        return old, new
+
+    # Update one entry from collection
+    def update(self, query, update):
+        result = self.collection.update_one(query, {"$set": update})
+        new_document = self.collection.find_one(query)
+        return result.modified_count, new_document
+
+    @staticmethod
+    def close():
+        return Powers_db_client.close()
+
+
+def __connect_first():
+    _ = MongoDB("test")
+    LOGGER.info("Initialized Database!\n")
+
+
+__connect_first()

Powers/database/antispam_db.py

@@ -0,0 +1,73 @@
+from datetime import datetime
+from threading import RLock
+
+from Powers.database import MongoDB
+
+INSERTION_LOCK = RLock()
+ANTISPAM_BANNED = set()
+
+
+class GBan(MongoDB):
+    """Class for managing Gbans in bot."""
+
+    db_name = "gbans"
+
+    def __init__(self) -> None:
+        super().__init__(self.db_name)
+
+    def check_gban(self, user_id: int):
+        with INSERTION_LOCK:
+            return bool(self.find_one({"_id": user_id}))
+
+    def add_gban(self, user_id: int, reason: str, by_user: int):
+        global ANTISPAM_BANNED
+        with INSERTION_LOCK:
+            # Check if  user is already gbanned or not
+            if self.find_one({"_id": user_id}):
+                return self.update_gban_reason(user_id, reason)
+
+            # If not already gbanned, then add to gban
+            time_rn = datetime.now()
+            return self.insert_one(
+                {
+                    "_id": user_id,
+                    "reason": reason,
+                    "by": by_user,
+                    "time": time_rn,
+                },
+            )
+
+    def remove_gban(self, user_id: int):
+        global ANTISPAM_BANNED
+        with INSERTION_LOCK:
+            # Check if  user is already gbanned or not
+            if self.find_one({"_id": user_id}):
+                return self.delete_one({"_id": user_id})
+
+            return "User not gbanned!"
+
+    def get_gban(self, user_id: int):
+        if self.check_gban(user_id):
+            curr = self.find_one({"_id": user_id})
+            if curr:
+                return True, curr["reason"]
+        return False, ""
+
+    def update_gban_reason(self, user_id: int, reason: str):
+        with INSERTION_LOCK:
+            return self.update(
+                {"_id": user_id},
+                {"reason": reason},
+            )
+
+    def count_gbans(self):
+        with INSERTION_LOCK:
+            return self.count()
+
+    def load_from_db(self):
+        with INSERTION_LOCK:
+            return self.find_all()
+
+    def list_gbans(self):
+        with INSERTION_LOCK:
+            return self.find_all()

Powers/database/approve_db.py

@@ -0,0 +1,106 @@
+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."""
+
+    # Database name to connect to to preform operations
+    db_name = "approve"
+
+    def __init__(self, chat_id: int) -> None:
+        super().__init__(self.db_name)
+        self.chat_id = chat_id
+        self.chat_info = self.__ensure_in_db()
+
+    def check_approve(self, user_id: int):
+        with INSERTION_LOCK:
+            return bool(user_id in self.chat_info["users"])
+
+    def add_approve(self, user_id: int, user_name: str):
+        with INSERTION_LOCK:
+            self.chat_info["users"].append((user_id, user_name))
+            if not self.check_approve(user_id):
+                return self.update(
+                    {"_id": self.chat_id},
+                    {"users": self.chat_info["users"]},
+                )
+            return True
+
+    def remove_approve(self, user_id: int):
+        with INSERTION_LOCK:
+            if self.check_approve(user_id):
+                user_full = next(
+                    user for user in self.chat_info["users"] if user[0] == user_id
+                )
+                self.chat_info["users"].pop(user_full)
+                return self.update(
+                    {"_id": self.chat_id},
+                    {"users": self.chat_info["users"]},
+                )
+            return True
+
+    def unapprove_all(self):
+        with INSERTION_LOCK:
+            return self.delete_one(
+                {"_id": self.chat_id},
+            )
+
+    def list_approved(self):
+        with INSERTION_LOCK:
+            return self.chat_info["users"]
+
+    def count_approved(self):
+        with INSERTION_LOCK:
+            return len(self.chat_info["users"])
+
+    def load_from_db(self):
+        return self.find_all()
+
+    def __ensure_in_db(self):
+        chat_data = self.find_one({"_id": self.chat_id})
+        if not chat_data:
+            new_data = {"_id": self.chat_id, "users": []}
+            self.insert_one(new_data)
+            LOGGER.info(f"Initialized Approve Document for chat {self.chat_id}")
+            return new_data
+        return chat_data
+
+    # Migrate if chat id changes!
+    def migrate_chat(self, new_chat_id: int):
+        old_chat_db = self.find_one({"_id": self.chat_id})
+        new_data = old_chat_db.update({"_id": new_chat_id})
+        self.insert_one(new_data)
+        self.delete_one({"_id": self.chat_id})
+
+    @staticmethod
+    def count_all_approved():
+        with INSERTION_LOCK:
+            collection = MongoDB(Approve.db_name)
+            all_data = collection.find_all()
+            return sum(len(i["users"]) for i in all_data if len(i["users"]) >= 1)
+
+    @staticmethod
+    def count_approved_chats():
+        with INSERTION_LOCK:
+            collection = MongoDB(Approve.db_name)
+            all_data = collection.find_all()
+            return sum(len(i["users"]) >= 1 for i in all_data)
+
+    @staticmethod
+    def repair_db(collection):
+        all_data = collection.find_all()
+        keys = {"users": []}
+        for data in all_data:
+            for key, val in keys.items():
+                try:
+                    _ = data[key]
+                except KeyError:
+                    LOGGER.warning(
+                        f"Repairing Approve Database - setting '{key}:{val}' for {data['_id']}",
+                    )
+                    collection.update({"_id": data["_id"]}, {key: val})

Powers/database/blacklist_db.py

@@ -0,0 +1,148 @@
+from threading import RLock
+from time import time
+
+from Powers import LOGGER
+from Powers.database import MongoDB
+
+INSERTION_LOCK = RLock()
+
+
+class Blacklist(MongoDB):
+    """Class to manage database for blacklists for chats."""
+
+    # Database name to connect to to preform operations
+    db_name = "blacklists"
+
+    def __init__(self, chat_id: int) -> None:
+        super().__init__(self.db_name)
+        self.chat_id = chat_id
+        self.chat_info = self.__ensure_in_db()
+
+    def check_word_blacklist_status(self, word: str):
+        with INSERTION_LOCK:
+            bl_words = self.chat_info["triggers"]
+            return bool(word in bl_words)
+
+    def add_blacklist(self, trigger: str):
+        with INSERTION_LOCK:
+            if not self.check_word_blacklist_status(trigger):
+                return self.update(
+                    {"_id": self.chat_id},
+                    {
+                        "_id": self.chat_id,
+                        "triggers": self.chat_info["triggers"] + [trigger],
+                    },
+                )
+
+    def remove_blacklist(self, trigger: str):
+        with INSERTION_LOCK:
+            if self.check_word_blacklist_status(trigger):
+                self.chat_info["triggers"].remove(trigger)
+                return self.update(
+                    {"_id": self.chat_id},
+                    {
+                        "_id": self.chat_id,
+                        "triggers": self.chat_info["triggers"],
+                    },
+                )
+
+    def get_blacklists(self):
+        with INSERTION_LOCK:
+            return self.chat_info["triggers"]
+
+    @staticmethod
+    def count_blacklists_all():
+        with INSERTION_LOCK:
+            collection = MongoDB(Blacklist.db_name)
+            curr = collection.find_all()
+            return sum(len(chat["triggers"]) for chat in curr)
+
+    @staticmethod
+    def count_blackists_chats():
+        with INSERTION_LOCK:
+            collection = MongoDB(Blacklist.db_name)
+            curr = collection.find_all()
+            return sum(1 for chat in curr if chat["triggers"])
+
+    def set_action(self, action: str):
+        with INSERTION_LOCK:
+            return self.update(
+                {"_id": self.chat_id},
+                {"_id": self.chat_id, "action": action},
+            )
+
+    def get_action(self):
+        with INSERTION_LOCK:
+            return self.chat_info["action"]
+
+    def set_reason(self, reason: str):
+        with INSERTION_LOCK:
+            return self.update(
+                {"_id": self.chat_id},
+                {"_id": self.chat_id, "reason": reason},
+            )
+
+    def get_reason(self):
+        with INSERTION_LOCK:
+            return self.chat_info["reason"]
+
+    @staticmethod
+    def count_action_bl_all(action: str):
+        with INSERTION_LOCK:
+            collection = MongoDB(Blacklist.db_name)
+            all_data = collection.find_all({"action": action})
+            return sum(len(i["triggers"]) >= 1 for i in all_data)
+
+    def rm_all_blacklist(self):
+        with INSERTION_LOCK:
+            return self.update(
+                {"_id": self.chat_id},
+                {"triggers": []},
+            )
+
+    def __ensure_in_db(self):
+        chat_data = self.find_one({"_id": self.chat_id})
+        if not chat_data:
+            new_data = new_data = {
+                "_id": self.chat_id,
+                "triggers": [],
+                "action": "none",
+                "reason": "Automated blacklisted word: {{}}",
+            }
+            self.insert_one(new_data)
+            LOGGER.info(f"Initialized Blacklist Document for chat {self.chat_id}")
+            return new_data
+        return chat_data
+
+    # Migrate if chat id changes!
+    def migrate_chat(self, new_chat_id: int):
+        old_chat_db = self.find_one({"_id": self.chat_id})
+        new_data = old_chat_db.update({"_id": new_chat_id})
+        self.insert_one(new_data)
+        self.delete_one({"_id": self.chat_id})
+
+    @staticmethod
+    def repair_db(collection):
+        all_data = collection.find_all()
+        keys = {
+            "triggers": [],
+            "action": "none",
+            "reason": "Automated blacklisted word: {{}}",
+        }
+        for data in all_data:
+            for key, val in keys.items():
+                try:
+                    _ = data[key]
+                except KeyError:
+                    LOGGER.warning(
+                        f"Repairing Blacklist Database - setting '{key}:{val}' for {data['_id']}",
+                    )
+                    collection.update({"_id": data["_id"]}, {key: val})
+
+
+def __pre_req_blacklists():
+    start = time()
+    LOGGER.info("Starting Blacklists Database Repair...")
+    collection = MongoDB(Blacklist.db_name)
+    Blacklist.repair_db(collection)
+    LOGGER.info(f"Done in {round((time() - start), 3)}s!")

Powers/database/chats_db.py

@@ -0,0 +1,141 @@
+from threading import RLock
+from time import time
+
+from Powers import LOGGER
+from Powers.database import MongoDB
+
+INSERTION_LOCK = RLock()
+
+
+class Chats(MongoDB):
+    """Class to manage users for bot."""
+
+    # Database name to connect to to preform operations
+    db_name = "chats"
+
+    def __init__(self, chat_id: int) -> None:
+        super().__init__(self.db_name)
+        self.chat_id = chat_id
+        self.chat_info = self.__ensure_in_db()
+
+    def user_is_in_chat(self, user_id: int):
+        return bool(user_id in set(self.chat_info["users"]))
+
+    def update_chat(self, chat_name: str, user_id: int):
+        with INSERTION_LOCK:
+
+            if chat_name == self.chat_info["chat_name"] and self.user_is_in_chat(
+                user_id,
+            ):
+                return True
+
+            if chat_name != self.chat_info["chat_name"] and self.user_is_in_chat(
+                user_id,
+            ):
+                return self.update(
+                    {"_id": self.chat_id},
+                    {"chat_name": chat_name},
+                )
+
+            if chat_name == self.chat_info["chat_name"] and not self.user_is_in_chat(
+                user_id,
+            ):
+                self.chat_info["users"].append(user_id)
+                return self.update(
+                    {"_id": self.chat_id},
+                    {"users": self.chat_info["users"]},
+                )
+
+            users_old = self.chat_info["users"]
+            users_old.append(user_id)
+            users = list(set(users_old))
+            return self.update(
+                {"_id": self.chat_id},
+                {
+                    "_id": self.chat_id,
+                    "chat_name": chat_name,
+                    "users": users,
+                },
+            )
+
+    def count_chat_users(self):
+        with INSERTION_LOCK:
+            return len(self.chat_info["users"]) or 0
+
+    def chat_members(self):
+        with INSERTION_LOCK:
+            return self.chat_info["users"]
+
+    @staticmethod
+    def remove_chat(chat_id: int):
+        with INSERTION_LOCK:
+            collection = MongoDB(Chats.db_name)
+            collection.delete_one({"_id": chat_id})
+
+    @staticmethod
+    def count_chats():
+        with INSERTION_LOCK:
+            collection = MongoDB(Chats.db_name)
+            return collection.count() or 0
+
+    @staticmethod
+    def list_chats_by_id():
+        with INSERTION_LOCK:
+            collection = MongoDB(Chats.db_name)
+            chats = collection.find_all()
+            chat_list = {i["_id"] for i in chats}
+            return list(chat_list)
+
+    @staticmethod
+    def list_chats_full():
+        with INSERTION_LOCK:
+            collection = MongoDB(Chats.db_name)
+            return collection.find_all()
+
+    @staticmethod
+    def get_chat_info(chat_id: int):
+        with INSERTION_LOCK:
+            collection = MongoDB(Chats.db_name)
+            return collection.find_one({"_id": chat_id})
+
+    def load_from_db(self):
+        with INSERTION_LOCK:
+            return self.find_all()
+
+    def __ensure_in_db(self):
+        chat_data = self.find_one({"_id": self.chat_id})
+        if not chat_data:
+            new_data = {"_id": self.chat_id, "chat_name": "", "users": []}
+            self.insert_one(new_data)
+            LOGGER.info(f"Initialized Chats Document for chat {self.chat_id}")
+            return new_data
+        return chat_data
+
+    # Migrate if chat id changes!
+    def migrate_chat(self, new_chat_id: int):
+        old_chat_db = self.find_one({"_id": self.chat_id})
+        new_data = old_chat_db.update({"_id": new_chat_id})
+        self.insert_one(new_data)
+        self.delete_one({"_id": self.chat_id})
+
+    @staticmethod
+    def repair_db(collection):
+        all_data = collection.find_all()
+        keys = {"chat_name": "", "users": []}
+        for data in all_data:
+            for key, val in keys.items():
+                try:
+                    _ = data[key]
+                except KeyError:
+                    LOGGER.warning(
+                        f"Repairing Chats Database - setting '{key}:{val}' for {data['_id']}",
+                    )
+                    collection.update({"_id": data["_id"]}, {key: val})
+
+
+def __pre_req_chats():
+    start = time()
+    LOGGER.info("Starting Chats Database Repair...")
+    collection = MongoDB(Chats.db_name)
+    Chats.repair_db(collection)
+    LOGGER.info(f"Done in {round((time() - start), 3)}s!")

Powers/database/disable_db.py

@@ -0,0 +1,147 @@
+from threading import RLock
+
+from Powers import LOGGER
+from Powers.database import MongoDB
+
+INSERTION_LOCK = RLock()
+DISABLED_CMDS = {}
+
+
+class Disabling(MongoDB):
+    """Class to manage database for Disabling for chats."""
+
+    # Database name to connect to to preform operations
+    db_name = "disabled"
+
+    def __init__(self, chat_id: int) -> None:
+        super().__init__(self.db_name)
+        self.chat_id = chat_id
+        self.chat_info = self.__ensure_in_db()
+
+    def check_cmd_status(self, cmd: str):
+        with INSERTION_LOCK:
+            # cmds = self.chat_info["commands"]
+            cmds = DISABLED_CMDS[self.chat_id]["commands"]
+            # return bool(cmd in cmds)
+            return bool(cmd in cmds)
+
+    def add_disable(self, cmd: str):
+        with INSERTION_LOCK:
+            if not self.check_cmd_status(cmd):
+                # DISABLED_CMDS[self.chat_id]["commands"].append(cmd)
+                return self.update(
+                    {"_id": self.chat_id},
+                    {
+                        "_id": self.chat_id,
+                        "commands": self.chat_info["commands"] + [cmd],
+                    },
+                )
+
+    def remove_disabled(self, comm: str):
+        with INSERTION_LOCK:
+            if self.check_cmd_status(comm):
+                self.chat_info["commands"].remove(comm)
+                DISABLED_CMDS[self.chat_id]["commands"].remove(comm)
+                return self.update(
+                    {"_id": self.chat_id},
+                    {
+                        "_id": self.chat_id,
+                        "commands": self.chat_info["commands"],
+                    },
+                )
+
+    def get_disabled(self):
+        with INSERTION_LOCK:
+            global DISABLED_CMDS
+            try:
+                cmds = DISABLED_CMDS[self.chat_id]["commands"]
+            except KeyError:
+                cmds = self.chat_info["commands"]
+                DISABLED_CMDS[self.chat_id]["commands"] = cmds
+            return cmds
+
+    @staticmethod
+    def count_disabled_all():
+        with INSERTION_LOCK:
+            collection = MongoDB(Disabling.db_name)
+            curr = collection.find_all()
+            return sum(len(chat["commands"]) for chat in curr)
+
+    @staticmethod
+    def count_disabling_chats():
+        with INSERTION_LOCK:
+            collection = MongoDB(Disabling.db_name)
+            curr = collection.find_all()
+            return sum(1 for chat in curr if chat["commands"])
+
+    def set_action(self, action: str):
+        with INSERTION_LOCK:
+            global DISABLED_CMDS
+            DISABLED_CMDS[self.chat_id]["action"] = action
+            return self.update(
+                {"_id": self.chat_id},
+                {"_id": self.chat_id, "action": action},
+            )
+
+    def get_action(self):
+        with INSERTION_LOCK:
+            global DISABLED_CMDS
+            try:
+                action = DISABLED_CMDS[self.chat_id]["action"]
+            except KeyError:
+                action = self.chat_info["action"]
+                DISABLED_CMDS[self.chat_id]["action"] = action
+            return action
+
+    @staticmethod
+    def count_action_dis_all(action: str):
+        with INSERTION_LOCK:
+            collection = MongoDB(Disabling.db_name)
+            all_data = collection.find_all({"action": action})
+            return sum(len(i["commands"]) >= 1 for i in all_data)
+
+    def rm_all_disabled(self):
+        with INSERTION_LOCK:
+            DISABLED_CMDS[self.chat_id]["commands"] = []
+            return self.update(
+                {"_id": self.chat_id},
+                {"commands": []},
+            )
+
+    def __ensure_in_db(self):
+        try:
+            chat_data = DISABLED_CMDS[self.chat_id]
+        except KeyError:
+            chat_data = self.find_one({"_id": self.chat_id})
+            if not chat_data:
+                new_data = new_data = {
+                    "_id": self.chat_id,
+                    "commands": [],
+                    "action": "none",
+                }
+                self.insert_one(new_data)
+                LOGGER.info(f"Initialized Disabling Document for chat {self.chat_id}")
+                return new_data
+        return chat_data
+
+    # Migrate if chat id changes!
+    def migrate_chat(self, new_chat_id: int):
+        global DISABLED_CMDS  # global only when we are modifying the value
+        old_chat_db = self.find_one({"_id": self.chat_id})
+        new_data = old_chat_db.update({"_id": new_chat_id})
+        DISABLED_CMDS[new_chat_id] = DISABLED_CMDS[self.chat_id]
+        del DISABLED_CMDS[self.chat_id]
+        self.insert_one(new_data)
+        self.delete_one({"_id": self.chat_id})
+
+
+def __load_disable_cache():
+    global DISABLED_CMDS
+    collection = MongoDB(Disabling.db_name)
+    all_data = collection.find_all()
+    DISABLED_CMDS = {
+        i["_id"]: {"action": i["action"], "commands": i["commands"]} for i in all_data
+    }
+
+
+__load_disable_cache()

Powers/database/filters_db.py

@@ -0,0 +1,103 @@
+from threading import RLock
+
+from Powers.database import MongoDB
+from Powers.utils.msg_types import Types
+
+INSERTION_LOCK = RLock()
+
+
+class Filters(MongoDB):
+    db_name = "chat_filters"
+
+    def __init__(self) -> None:
+        super().__init__(self.db_name)
+
+    def save_filter(
+        self,
+        chat_id: int,
+        keyword: str,
+        filter_reply: str,
+        msgtype: int = Types.TEXT,
+        fileid="",
+    ):
+        with INSERTION_LOCK:
+            # Database update
+            curr = self.find_one({"chat_id": chat_id, "keyword": keyword})
+            if curr:
+                return False
+            return self.insert_one(
+                {
+                    "chat_id": chat_id,
+                    "keyword": keyword,
+                    "filter_reply": filter_reply,
+                    "msgtype": msgtype,
+                    "fileid": fileid,
+                },
+            )
+
+    def get_filter(self, chat_id: int, keyword: str):
+        with INSERTION_LOCK:
+            curr = self.find_one({"chat_id": chat_id, "keyword": keyword})
+            if curr:
+                return curr
+            return "Filter does not exist!"
+
+    def get_all_filters(self, chat_id: int):
+        with INSERTION_LOCK:
+            curr = self.find_all({"chat_id": chat_id})
+            if curr:
+                filter_list = {i["keyword"] for i in curr}
+                return list(filter_list)
+            return []
+
+    def rm_filter(self, chat_id: int, keyword: str):
+        with INSERTION_LOCK:
+            curr = self.find_one({"chat_id": chat_id, "keyword": keyword})
+            if curr:
+                self.delete_one(curr)
+                return True
+            return False
+
+    def rm_all_filters(self, chat_id: int):
+        with INSERTION_LOCK:
+            return self.delete_one({"chat_id": chat_id})
+
+    def count_filters_all(self):
+        with INSERTION_LOCK:
+            return self.count()
+
+    def count_filter_aliases(self):
+        with INSERTION_LOCK:
+            curr = self.find_all()
+            if curr:
+                return len(
+                    [z for z in (i["keyword"].split("|") for i in curr) if len(z) >= 2],
+                )
+            return 0
+
+    def count_filters_chats(self):
+        with INSERTION_LOCK:
+            filters = self.find_all()
+            chats_ids = {i["chat_id"] for i in filters}
+            return len(chats_ids)
+
+    def count_all_filters(self):
+        with INSERTION_LOCK:
+            return self.count()
+
+    def count_filter_type(self, ntype):
+        with INSERTION_LOCK:
+            return self.count({"msgtype": ntype})
+
+    def load_from_db(self):
+        with INSERTION_LOCK:
+            return self.find_all()
+
+    # Migrate if chat id changes!
+    def migrate_chat(self, old_chat_id: int, new_chat_id: int):
+        with INSERTION_LOCK:
+            old_chat_db = self.find_one({"_id": old_chat_id})
+            if old_chat_db:
+                new_data = old_chat_db.update({"_id": new_chat_id})
+                self.delete_one({"_id": old_chat_id})
+                self.insert_one(new_data)

Powers/database/greetings_db.py

@@ -0,0 +1,146 @@
+from threading import RLock
+
+from Powers import LOGGER
+from Powers.database import MongoDB
+
+INSERTION_LOCK = RLock()
+
+
+class Greetings(MongoDB):
+    """Class for managing antichannelpins in chats."""
+
+    # Database name to connect to to preform operations
+    db_name = "welcome_chats"
+
+    def __init__(self, chat_id: int) -> None:
+        super().__init__(self.db_name)
+        self.chat_id = chat_id
+        self.chat_info = self.__ensure_in_db()
+
+    # Get settings from database
+    def get_welcome_status(self):
+        with INSERTION_LOCK:
+            return self.chat_info["welcome"]
+
+    def get_goodbye_status(self):
+        with INSERTION_LOCK:
+            return self.chat_info["goodbye"]
+
+    def get_current_cleanservice_settings(self):
+        with INSERTION_LOCK:
+            return self.chat_info["cleanservice"]
+
+    def get_current_cleanwelcome_settings(self):
+        with INSERTION_LOCK:
+            return self.chat_info["cleanwelcome"]
+
+    def get_current_cleangoodbye_settings(self):
+        with INSERTION_LOCK:
+            return self.chat_info["cleangoodbye"]
+
+    def get_welcome_text(self):
+        with INSERTION_LOCK:
+            return self.chat_info["welcome_text"]
+
+    def get_goodbye_text(self):
+        with INSERTION_LOCK:
+            return self.chat_info["goodbye_text"]
+
+    def get_current_cleanwelcome_id(self):
+        with INSERTION_LOCK:
+            return self.chat_info["cleanwelcome_id"]
+
+    def get_current_cleangoodbye_id(self):
+        with INSERTION_LOCK:
+            return self.chat_info["cleangoodbye_id"]
+
+    # Set settings in database
+    def set_current_welcome_settings(self, status: bool):
+        with INSERTION_LOCK:
+            return self.update({"_id": self.chat_id}, {"welcome": status})
+
+    def set_current_goodbye_settings(self, status: bool):
+        with INSERTION_LOCK:
+            return self.update({"_id": self.chat_id}, {"goodbye": status})
+
+    def set_welcome_text(self, welcome_text: str):
+        with INSERTION_LOCK:
+            return self.update(
+                {"_id": self.chat_id},
+                {"welcome_text": welcome_text},
+            )
+
+    def set_goodbye_text(self, goodbye_text: str):
+        with INSERTION_LOCK:
+            return self.update(
+                {"_id": self.chat_id},
+                {"goodbye_text": goodbye_text},
+            )
+
+    def set_current_cleanservice_settings(self, status: bool):
+        with INSERTION_LOCK:
+            return self.update(
+                {"_id": self.chat_id},
+                {"cleanservice": status},
+            )
+
+    def set_current_cleanwelcome_settings(self, status: bool):
+        with INSERTION_LOCK:
+            return self.update(
+                {"_id": self.chat_id},
+                {"cleanwelcome": status},
+            )
+
+    def set_current_cleangoodbye_settings(self, status: bool):
+        with INSERTION_LOCK:
+            return self.update(
+                {"_id": self.chat_id},
+                {"cleangoodbye": status},
+            )
+
+    def set_cleanwlcm_id(self, status: int):
+        with INSERTION_LOCK:
+            return self.update(
+                {"_id": self.chat_id},
+                {"cleanwelcome_id": status},
+            )
+
+    def set_cleangoodbye_id(self, status: int):
+        with INSERTION_LOCK:
+            return self.update(
+                {"_id": self.chat_id},
+                {"cleangoodbye_id": status},
+            )
+
+    def __ensure_in_db(self):
+        chat_data = self.find_one({"_id": self.chat_id})
+        if not chat_data:
+            new_data = {
+                "_id": self.chat_id,
+                "cleanwelcome": False,
+                "cleanwelcome_id": None,
+                "cleangoodbye_id": None,
+                "cleangoodbye": False,
+                "cleanservice": False,
+                "goodbye_text": "Sad to see you leaving {first}.\nTake Care!",
+                "welcome_text": "Hey {first}, welcome to {chatname}!",
+                "welcome": True,
+                "goodbye": True,
+            }
+            self.insert_one(new_data)
+            LOGGER.info(f"Initialized Greetings Document for chat {self.chat_id}")
+            return new_data
+        return chat_data
+
+    # Migrate if chat id changes!
+    def migrate_chat(self, new_chat_id: int):
+        old_chat_db = self.find_one({"_id": self.chat_id})
+        new_data = old_chat_db.update({"_id": new_chat_id})
+        self.insert_one(new_data)
+        self.delete_one({"_id": self.chat_id})
+
+    @staticmethod
+    def count_chats(query: str):
+        with INSERTION_LOCK:
+            collection = MongoDB(Greetings.db_name)
+            return collection.count({query: True})

Powers/database/group_blacklist.py

@@ -0,0 +1,46 @@
+from threading import RLock
+
+from Powers.database import MongoDB
+from Powers.database.chats_db import Chats
+
+INSERTION_LOCK = RLock()
+BLACKLIST_CHATS = []
+
+
+class GroupBlacklist(MongoDB):
+    """Class to blacklist chats where bot will exit."""
+
+    db_name = "group_blacklists"
+
+    def __init__(self) -> None:
+        super().__init__(self.db_name)
+
+    def add_chat(self, chat_id: int):
+        with INSERTION_LOCK:
+            global BLACKLIST_CHATS
+            try:
+                Chats.remove_chat(chat_id)  # Delete chat from database
+            except KeyError:
+                pass
+            BLACKLIST_CHATS.append(chat_id)
+            BLACKLIST_CHATS.sort()
+            return self.insert_one({"_id": chat_id, "blacklist": True})
+
+    def remove_chat(self, chat_id: int):
+        with INSERTION_LOCK:
+            global BLACKLIST_CHATS
+            BLACKLIST_CHATS.remove(chat_id)
+            BLACKLIST_CHATS.sort()
+            return self.delete_one({"_id": chat_id})
+
+    def list_all_chats(self):
+        with INSERTION_LOCK:
+            try:
+                BLACKLIST_CHATS.sort()
+                return BLACKLIST_CHATS
+            except Exception:
+                all_chats = self.find_all()
+                return [chat["_id"] for chat in all_chats]
+
+    def get_from_db(self):
+        return self.find_all()

Powers/database/lang_db.py

@@ -0,0 +1,93 @@
+from threading import RLock
+from time import time
+
+from Powers import LOGGER
+from Powers.database import MongoDB
+
+INSERTION_LOCK = RLock()
+
+# Locall cache languages for users!!
+LANG_CACHE = {}
+
+
+class Langs(MongoDB):
+    """Class for language options in bot."""
+
+    db_name = "langs"
+
+    def __init__(self, chat_id: int) -> None:
+        super().__init__(self.db_name)
+        self.chat_id = chat_id
+        self.chat_info = self.__ensure_in_db()
+
+    def get_chat_type(self):
+        return "supergroup" if str(self.chat_id).startswith("-100") else "user"
+
+    def set_lang(self, lang: str):
+        with INSERTION_LOCK:
+            global LANG_CACHE
+            LANG_CACHE[self.chat_id] = lang
+            self.chat_info["lang"] = lang
+            return self.update(
+                {"_id": self.chat_id},
+                {"lang": self.chat_info["lang"]},
+            )
+
+    def get_lang(self):
+        with INSERTION_LOCK:
+            return self.chat_info["lang"]
+
+    @staticmethod
+    def load_from_db():
+        with INSERTION_LOCK:
+            collection = MongoDB(Langs.db_name)
+            return collection.find_all()
+
+    def __ensure_in_db(self):
+        try:
+            chat_data = {"_id": self.chat_id, "lang": LANG_CACHE[self.chat_id]}
+        except KeyError:
+            chat_data = self.find_one({"_id": self.chat_id})
+        if not chat_data:
+            chat_type = self.get_chat_type()
+            new_data = {"_id": self.chat_id, "lang": "en", "chat_type": chat_type}
+            self.insert_one(new_data)
+            LOGGER.info(f"Initialized Language Document for chat {self.chat_id}")
+            return new_data
+        return chat_data
+
+    # Migrate if chat id changes!
+    def migrate_chat(self, new_chat_id: int):
+        old_chat_db = self.find_one({"_id": self.chat_id})
+        new_data = old_chat_db.update({"_id": new_chat_id})
+        self.insert_one(new_data)
+        self.delete_one({"_id": self.chat_id})
+
+    @staticmethod
+    def repair_db(collection):
+        all_data = collection.find_all()
+        keys = {"lang": "en", "chat_type": ""}
+        for data in all_data:
+            for key, val in keys.items():
+                try:
+                    _ = data[key]
+                except KeyError:
+                    LOGGER.warning(
+                        f"Repairing Langs Database - setting '{key}:{val}' for {data['_id']}",
+                    )
+                    collection.update({"_id": data["_id"]}, {key: val})
+
+
+def __pre_req_all_langs():
+    start = time()
+    LOGGER.info("Starting Langs Database Repair...")
+    collection = MongoDB(Langs.db_name)
+    Langs.repair_db(collection)
+    LOGGER.info(f"Done in {round((time() - start), 3)}s!")
+
+
+def __load_lang_cache():
+    global LANG_CACHE
+    collection = MongoDB(Langs.db_name)
+    all_data = collection.find_all()
+    LANG_CACHE = {i["_id"]: i["lang"] for i in all_data}

Powers/database/notes_db.py

@@ -0,0 +1,141 @@
+from hashlib import md5
+from threading import RLock
+from time import time
+
+from Powers.database import MongoDB
+from Powers.utils.msg_types import Types
+
+INSERTION_LOCK = RLock()
+
+
+class Notes(MongoDB):
+    db_name = "notes"
+
+    def __init__(self) -> None:
+        super().__init__(self.db_name)
+
+    def save_note(
+        self,
+        chat_id: int,
+        note_name: str,
+        note_value: str,
+        msgtype: int = Types.TEXT,
+        fileid="",
+    ):
+        with INSERTION_LOCK:
+            curr = self.find_one(
+                {"chat_id": chat_id, "note_name": note_name},
+            )
+            if curr:
+                return False
+            hash_gen = md5(
+                (note_name + note_value + str(chat_id) + str(int(time()))).encode(),
+            ).hexdigest()
+            return self.insert_one(
+                {
+                    "chat_id": chat_id,
+                    "note_name": note_name,
+                    "note_value": note_value,
+                    "hash": hash_gen,
+                    "msgtype": msgtype,
+                    "fileid": fileid,
+                },
+            )
+
+    def get_note(self, chat_id: int, note_name: str):
+        with INSERTION_LOCK:
+            curr = self.find_one(
+                {"chat_id": chat_id, "note_name": note_name},
+            )
+            if curr:
+                return curr
+            return "Note does not exist!"
+
+    def get_note_by_hash(self, note_hash: str):
+        return self.find_one({"hash": note_hash})
+
+    def get_all_notes(self, chat_id: int):
+        with INSERTION_LOCK:
+            curr = self.find_all({"chat_id": chat_id})
+            note_list = [(note["note_name"], note["hash"]) for note in curr]
+            note_list.sort()
+            return note_list
+
+    def rm_note(self, chat_id: int, note_name: str):
+        with INSERTION_LOCK:
+            curr = self.find_one(
+                {"chat_id": chat_id, "note_name": note_name},
+            )
+            if curr:
+                self.delete_one(curr)
+                return True
+            return False
+
+    def rm_all_notes(self, chat_id: int):
+        with INSERTION_LOCK:
+            return self.delete_one({"chat_id": chat_id})
+
+    def count_notes(self, chat_id: int):
+        with INSERTION_LOCK:
+            curr = self.find_all({"chat_id": chat_id})
+            if curr:
+                return len(curr)
+            return 0
+
+    def count_notes_chats(self):
+        with INSERTION_LOCK:
+            notes = self.find_all()
+            chats_ids = [chat["chat_id"] for chat in notes]
+            return len(set(chats_ids))
+
+    def count_all_notes(self):
+        with INSERTION_LOCK:
+            return self.count()
+
+    def count_notes_type(self, ntype):
+        with INSERTION_LOCK:
+            return self.count({"msgtype": ntype})
+
+    # Migrate if chat id changes!
+    def migrate_chat(self, old_chat_id: int, new_chat_id: int):
+        with INSERTION_LOCK:
+            old_chat_db = self.find_one({"_id": old_chat_id})
+            if old_chat_db:
+                new_data = old_chat_db.update({"_id": new_chat_id})
+                self.delete_one({"_id": old_chat_id})
+                self.insert_one(new_data)
+
+
+class NotesSettings(MongoDB):
+    db_name = "notes_settings"
+
+    def __init__(self) -> None:
+        super().__init__(self.db_name)
+
+    def set_privatenotes(self, chat_id: int, status: bool = False):
+        curr = self.find_one({"_id": chat_id})
+        if curr:
+            return self.update({"_id": chat_id}, {"privatenotes": status})
+        return self.insert_one({"_id": chat_id, "privatenotes": status})
+
+    def get_privatenotes(self, chat_id: int):
+        curr = self.find_one({"_id": chat_id})
+        if curr:
+            return curr["privatenotes"]
+        self.update({"_id": chat_id}, {"privatenotes": False})
+        return False
+
+    def list_chats(self):
+        return self.find_all({"privatenotes": True})
+
+    def count_chats(self):
+        return len(self.find_all({"privatenotes": True}))
+
+    # Migrate if chat id changes!
+    def migrate_chat(self, old_chat_id: int, new_chat_id: int):
+        with INSERTION_LOCK:
+            old_chat_db = self.find_one({"_id": old_chat_id})
+            if old_chat_db:
+                new_data = old_chat_db.update({"_id": new_chat_id})
+                self.delete_one({"_id": old_chat_id})
+                self.insert_one(new_data)

Powers/database/pins_db.py

@@ -0,0 +1,113 @@
+from threading import RLock
+
+from Powers import LOGGER
+from Powers.database import MongoDB
+
+INSERTION_LOCK = RLock()
+
+
+class Pins(MongoDB):
+    """Class for managing antichannelpins in chats."""
+
+    # Database name to connect to to preform operations
+    db_name = "antichannelpin"
+
+    def __init__(self, chat_id: int) -> None:
+        super().__init__(self.db_name)
+        self.chat_id = chat_id
+        self.chat_info = self.__ensure_in_db()
+
+    def get_settings(self):
+        with INSERTION_LOCK:
+            return self.chat_info
+
+    def antichannelpin_on(self):
+        with INSERTION_LOCK:
+            return self.set_on("antichannelpin")
+
+    def cleanlinked_on(self):
+        with INSERTION_LOCK:
+            return self.set_on("cleanlinked")
+
+    def antichannelpin_off(self):
+        with INSERTION_LOCK:
+            return self.set_off("antichannelpin")
+
+    def cleanlinked_off(self):
+        with INSERTION_LOCK:
+            return self.set_off("cleanlinked")
+
+    def set_on(self, atype: str):
+        with INSERTION_LOCK:
+            otype = "cleanlinked" if atype == "antichannelpin" else "antichannelpin"
+            return self.update(
+                {"_id": self.chat_id},
+                {atype: True, otype: False},
+            )
+
+    def set_off(self, atype: str):
+        with INSERTION_LOCK:
+            otype = "cleanlinked" if atype == "antichannelpin" else "antichannelpin"
+            return self.update(
+                {"_id": self.chat_id},
+                {atype: False, otype: False},
+            )
+
+    def __ensure_in_db(self):
+        chat_data = self.find_one({"_id": self.chat_id})
+        if not chat_data:
+            new_data = {
+                "_id": self.chat_id,
+                "antichannelpin": False,
+                "cleanlinked": False,
+            }
+            self.insert_one(new_data)
+            LOGGER.info(f"Initialized Pins Document for chat {self.chat_id}")
+            return new_data
+        return chat_data
+
+    # Migrate if chat id changes!
+    def migrate_chat(self, new_chat_id: int):
+        old_chat_db = self.find_one({"_id": self.chat_id})
+        new_data = old_chat_db.update({"_id": new_chat_id})
+        self.insert_one(new_data)
+        self.delete_one({"_id": self.chat_id})
+
+    # ----- Static Methods -----
+    @staticmethod
+    def count_chats(atype: str):
+        with INSERTION_LOCK:
+            collection = MongoDB(Pins.db_name)
+            return collection.count({atype: True})
+
+    @staticmethod
+    def list_chats(query: str):
+        with INSERTION_LOCK:
+            collection = MongoDB(Pins.db_name)
+            return collection.find_all({query: True})
+
+    @staticmethod
+    def load_from_db():
+        with INSERTION_LOCK:
+            collection = MongoDB(Pins.db_name)
+            return collection.find_all()
+
+    @staticmethod
+    def repair_db(collection):
+        all_data = collection.find_all()
+        keys = {"antichannelpin": False, "cleanlinked": False}
+        for data in all_data:
+            for key, val in keys.items():
+                try:
+                    _ = data[key]
+                except KeyError:
+                    LOGGER.warning(
+                        f"Repairing Pins Database - setting '{key}:{val}' for {data['_id']}",
+                    )
+                    collection.update({"_id": data["_id"]}, {key: val})
+
+
+def __pre_req_pins_chats():
+    LOGGER.info("Starting Pins Database Repair...")
+    collection = MongoDB(Pins.db_name)
+    Pins.repair_db(collection)

Powers/database/reporting_db.py

@@ -0,0 +1,78 @@
+from threading import RLock
+from time import time
+
+from Powers import LOGGER
+from Powers.database import MongoDB
+
+INSERTION_LOCK = RLock()
+
+
+class Reporting(MongoDB):
+    """Class for managing report settings of users and groups."""
+
+    db_name = "reporting"
+
+    def __init__(self, chat_id: int) -> None:
+        super().__init__(self.db_name)
+        self.chat_id = chat_id
+        self.chat_info = self.__ensure_in_db()
+
+    def get_chat_type(self):
+        return "supergroup" if str(self.chat_id).startswith("-100") else "user"
+
+    def set_settings(self, status: bool = True):
+        with INSERTION_LOCK:
+            self.chat_info["status"] = status
+            return self.update(
+                {"_id": self.chat_id},
+                {"status": self.chat_info["status"]},
+            )
+
+    def get_settings(self):
+        with INSERTION_LOCK:
+            return self.chat_info["status"]
+
+    @staticmethod
+    def load_from_db():
+        with INSERTION_LOCK:
+            collection = MongoDB(Reporting.db_name)
+            return collection.find_all() or []
+
+    def __ensure_in_db(self):
+        chat_data = self.find_one({"_id": self.chat_id})
+        if not chat_data:
+            chat_type = self.get_chat_type()
+            new_data = {"_id": self.chat_id, "status": True, "chat_type": chat_type}
+            self.insert_one(new_data)
+            LOGGER.info(f"Initialized Language Document for chat {self.chat_id}")
+            return new_data
+        return chat_data
+
+    # Migrate if chat id changes!
+    def migrate_chat(self, new_chat_id: int):
+        old_chat_db = self.find_one({"_id": self.chat_id})
+        new_data = old_chat_db.update({"_id": new_chat_id})
+        self.insert_one(new_data)
+        self.delete_one({"_id": self.chat_id})
+
+    @staticmethod
+    def repair_db(collection):
+        all_data = collection.find_all()
+        keys = {"status": True, "chat_type": ""}
+        for data in all_data:
+            for key, val in keys.items():
+                try:
+                    _ = data[key]
+                except KeyError:
+                    LOGGER.warning(
+                        f"Repairing Reporting Database - setting '{key}:{val}' for {data['_id']}",
+                    )
+                    collection.update({"_id": data["_id"]}, {key: val})
+
+
+def __pre_req_all_reporting_settings():
+    start = time()
+    LOGGER.info("Starting Reports Database Repair...")
+    collection = MongoDB(Reporting.db_name)
+    Reporting.repair_db(collection)
+    LOGGER.info(f"Done in {round((time() - start), 3)}s!")

Powers/database/rules_db.py

@@ -0,0 +1,102 @@
+from threading import RLock
+from time import time
+
+from Powers import LOGGER
+from Powers.database import MongoDB
+
+INSERTION_LOCK = RLock()
+
+
+class Rules(MongoDB):
+    """Class for rules for chats in bot."""
+
+    db_name = "rules"
+
+    def __init__(self, chat_id: int) -> None:
+        super().__init__(self.db_name)
+        self.chat_id = chat_id
+        self.chat_info = self.__ensure_in_db()
+
+    def get_rules(self):
+        with INSERTION_LOCK:
+            return self.chat_info["rules"]
+
+    def set_rules(self, rules: str):
+        with INSERTION_LOCK:
+            self.chat_info["rules"] = rules
+            self.update({"_id": self.chat_id}, {"rules": rules})
+
+    def get_privrules(self):
+        with INSERTION_LOCK:
+            return self.chat_info["privrules"]
+
+    def set_privrules(self, privrules: bool):
+        with INSERTION_LOCK:
+            self.chat_info["privrules"] = privrules
+            self.update({"_id": self.chat_id}, {"privrules": privrules})
+
+    def clear_rules(self):
+        with INSERTION_LOCK:
+            return self.delete_one({"_id": self.chat_id})
+
+    @staticmethod
+    def count_chats_with_rules():
+        with INSERTION_LOCK:
+            collection = MongoDB(Rules.db_name)
+            return collection.count({"rules": {"$regex": ".*"}})
+
+    @staticmethod
+    def count_privrules_chats():
+        with INSERTION_LOCK:
+            collection = MongoDB(Rules.db_name)
+            return collection.count({"privrules": True})
+
+    @staticmethod
+    def count_grouprules_chats():
+        with INSERTION_LOCK:
+            collection = MongoDB(Rules.db_name)
+            return collection.count({"privrules": False})
+
+    @staticmethod
+    def load_from_db():
+        with INSERTION_LOCK:
+            collection = MongoDB(Rules.db_name)
+            return collection.find_all()
+
+    def __ensure_in_db(self):
+        chat_data = self.find_one({"_id": self.chat_id})
+        if not chat_data:
+            new_data = {"_id": self.chat_id, "privrules": False, "rules": ""}
+            self.insert_one(new_data)
+            LOGGER.info(f"Initialized Language Document for chat {self.chat_id}")
+            return new_data
+        return chat_data
+
+    # Migrate if chat id changes!
+    def migrate_chat(self, new_chat_id: int):
+        old_chat_db = self.find_one({"_id": self.chat_id})
+        new_data = old_chat_db.update({"_id": new_chat_id})
+        self.insert_one(new_data)
+        self.delete_one({"_id": self.chat_id})
+
+    @staticmethod
+    def repair_db(collection):
+        all_data = collection.find_all()
+        keys = {"privrules": False, "rules": ""}
+        for data in all_data:
+            for key, val in keys.items():
+                try:
+                    _ = data[key]
+                except KeyError:
+                    LOGGER.warning(
+                        f"Repairing Rules Database - setting '{key}:{val}' for {data['_id']}",
+                    )
+                    collection.update({"_id": data["_id"]}, {key: val})
+
+
+def __pre_req_all_rules():
+    start = time()
+    LOGGER.info("Starting Rules Database Repair...")
+    collection = MongoDB(Rules.db_name)
+    Rules.repair_db(collection)
+    LOGGER.info(f"Done in {round((time() - start), 3)}s!")

Powers/database/users_db.py

@@ -0,0 +1,101 @@
+from threading import RLock
+from time import time
+
+from Powers import LOGGER
+from Powers.database import MongoDB
+
+INSERTION_LOCK = RLock()
+
+
+class Users(MongoDB):
+    """Class to manage users for bot."""
+
+    db_name = "users"
+
+    def __init__(self, user_id: int) -> None:
+        super().__init__(self.db_name)
+        self.user_id = user_id
+        self.user_info = self.__ensure_in_db()
+
+    def update_user(self, name: str, username: str = None):
+        with INSERTION_LOCK:
+            if name != self.user_info["name"] or username != self.user_info["username"]:
+                return self.update(
+                    {"_id": self.user_id},
+                    {"username": username, "name": name},
+                )
+            return True
+
+    def delete_user(self):
+        with INSERTION_LOCK:
+            return self.delete_one({"_id": self.user_id})
+
+    @staticmethod
+    def count_users():
+        with INSERTION_LOCK:
+            collection = MongoDB(Users.db_name)
+            return collection.count()
+
+    def get_my_info(self):
+        with INSERTION_LOCK:
+            return self.user_info
+
+    @staticmethod
+    def list_users():
+        with INSERTION_LOCK:
+            collection = MongoDB(Users.db_name)
+            return collection.find_all()
+
+    @staticmethod
+    def get_user_info(user_id: int or str):
+        with INSERTION_LOCK:
+            collection = MongoDB(Users.db_name)
+            if isinstance(user_id, int):
+                curr = collection.find_one({"_id": user_id})
+            elif isinstance(user_id, str):
+                # user_id[1:] because we don't want the '@' in the username search!
+                curr = collection.find_one({"username": user_id[1:]})
+            else:
+                curr = None
+
+            if curr:
+                return curr
+
+            return {}
+
+    def __ensure_in_db(self):
+        chat_data = self.find_one({"_id": self.user_id})
+        if not chat_data:
+            new_data = {"_id": self.user_id, "username": "", "name": "unknown_till_now"}
+            self.insert_one(new_data)
+            LOGGER.info(f"Initialized User Document for {self.user_id}")
+            return new_data
+        return chat_data
+
+    @staticmethod
+    def load_from_db():
+        with INSERTION_LOCK:
+            collection = MongoDB(Users.db_name)
+            return collection.find_all()
+
+    @staticmethod
+    def repair_db(collection):
+        all_data = collection.find_all()
+        keys = {"username": "", "name": "unknown_till_now"}
+        for data in all_data:
+            for key, val in keys.items():
+                try:
+                    _ = data[key]
+                except KeyError:
+                    LOGGER.warning(
+                        f"Repairing Users Database - setting '{key}:{val}' for {data['_id']}",
+                    )
+                    collection.update({"_id": data["_id"]}, {key: val})
+
+
+def __pre_req_users():
+    start = time()
+    LOGGER.info("Starting Users Database Repair...")
+    collection = MongoDB(Users.db_name)
+    Users.repair_db(collection)
+    LOGGER.info(f"Done in {round((time() - start), 3)}s!")

Powers/database/warns_db.py

@@ -0,0 +1,177 @@
+from threading import RLock
+from time import time
+
+from Powers import LOGGER
+from Powers.database import MongoDB
+
+INSERTION_LOCK = RLock()
+
+
+class Warns(MongoDB):
+    db_name = "chat_warns"
+
+    def __init__(self, chat_id: int) -> None:
+        super().__init__(self.db_name)
+        self.chat_id = chat_id
+
+    def warn_user(self, user_id: int, warn_reason=None):
+        with INSERTION_LOCK:
+            self.user_info = self.__ensure_in_db(user_id)
+            self.user_info["warns"].append(warn_reason)
+            self.user_info["num_warns"] = len(self.user_info["warns"])
+            self.update(
+                {"chat_id": self.chat_id, "user_id": user_id},
+                {
+                    "warns": self.user_info["warns"],
+                    "num_warns": self.user_info["num_warns"],
+                },
+            )
+            return self.user_info["warns"], self.user_info["num_warns"]
+
+    def remove_warn(self, user_id: int):
+        with INSERTION_LOCK:
+            self.user_info = self.__ensure_in_db(user_id)
+            self.user_info["warns"].pop()
+            self.user_info["num_warns"] = len(self.user_info["warns"])
+            self.update(
+                {"chat_id": self.chat_id, "user_id": user_id},
+                {
+                    "warns": self.user_info["warns"],
+                    "num_warns": self.user_info["num_warns"],
+                },
+            )
+            return self.user_info["warns"], self.user_info["num_warns"]
+
+    def reset_warns(self, user_id: int):
+        with INSERTION_LOCK:
+            self.user_info = self.__ensure_in_db(user_id)
+            return self.delete_one({"chat_id": self.chat_id, "user_id": user_id})
+
+    def get_warns(self, user_id: int):
+        with INSERTION_LOCK:
+            self.user_info = self.__ensure_in_db(user_id)
+            return self.user_info["warns"], len(self.user_info["warns"])
+
+    @staticmethod
+    def count_all_chats_using_warns():
+        with INSERTION_LOCK:
+            collection = MongoDB(Warns.db_name)
+            curr = collection.find_all()
+            return len({i["chat_id"] for i in curr})
+
+    @staticmethod
+    def count_warned_users():
+        with INSERTION_LOCK:
+            collection = MongoDB(Warns.db_name)
+            curr = collection.find_all()
+            return len({i["user_id"] for i in curr if i["num_warns"] >= 1})
+
+    @staticmethod
+    def count_warns_total():
+        with INSERTION_LOCK:
+            collection = MongoDB(Warns.db_name)
+            curr = collection.find_all()
+            return sum(i["num_warns"] for i in curr if i["num_warns"] >= 1)
+
+    @staticmethod
+    def repair_db(collection):
+        all_data = collection.find_all()
+        keys = {
+            "warns": [],
+            "num_warns": 0,
+        }
+        for data in all_data:
+            for key, val in keys.items():
+                try:
+                    _ = data[key]
+                except KeyError:
+                    LOGGER.warning(
+                        f"Repairing Approve Database - setting '{key}:{val}' for {data['user_id']} in {data['chat_id']}",
+                    )
+                    collection.update(
+                        {"chat_id": data["chat_id"], "user_id": data["user_id"]},
+                        {key: val},
+                    )
+
+    def __ensure_in_db(self, user_id: int):
+        chat_data = self.find_one({"chat_id": self.chat_id, "user_id": user_id})
+        if not chat_data:
+            new_data = {
+                "chat_id": self.chat_id,
+                "user_id": user_id,
+                "warns": [],
+                "num_warns": 0,
+            }
+            self.insert_one(new_data)
+            LOGGER.info(f"Initialized Warn Document for {user_id} in {self.chat_id}")
+            return new_data
+        return chat_data
+
+
+class WarnSettings(MongoDB):
+    db_name = "chat_warn_settings"
+
+    def __init__(self, chat_id: int) -> None:
+        super().__init__(self.db_name)
+        self.chat_id = chat_id
+        self.chat_info = self.__ensure_in_db()
+
+    def __ensure_in_db(self):
+        chat_data = self.find_one({"_id": self.chat_id})
+        if not chat_data:
+            new_data = {"_id": self.chat_id, "warn_mode": "none", "warn_limit": 3}
+            self.insert_one(new_data)
+            LOGGER.info(f"Initialized Warn Settings Document for {self.chat_id}")
+            return new_data
+        return chat_data
+
+    def get_warnings_settings(self):
+        with INSERTION_LOCK:
+            return self.chat_info
+
+    def set_warnmode(self, warn_mode: str = "none"):
+        with INSERTION_LOCK:
+            self.update({"_id": self.chat_id}, {"warn_mode": warn_mode})
+            return warn_mode
+
+    def get_warnmode(self):
+        with INSERTION_LOCK:
+            return self.chat_info["warn_mode"]
+
+    def set_warnlimit(self, warn_limit: int = 3):
+        with INSERTION_LOCK:
+            self.update({"_id": self.chat_id}, {"warn_limit": warn_limit})
+            return warn_limit
+
+    def get_warnlimit(self):
+        with INSERTION_LOCK:
+            return self.chat_info["warn_limit"]
+
+    @staticmethod
+    def count_action_chats(mode: str):
+        collection = MongoDB(WarnSettings.db_name)
+        return collection.count({"warn_mode": mode})
+
+    @staticmethod
+    def repair_db(collection):
+        all_data = collection.find_all()
+        keys = {"warn_mode": "none", "warn_limit": 3}
+        for data in all_data:
+            for key, val in keys.items():
+                try:
+                    _ = data[key]
+                except KeyError:
+                    LOGGER.warning(
+                        f"Repairing Approve Database - setting '{key}:{val}' for {data['_id']}",
+                    )
+                    collection.update({"_id": data["_id"]}, {key: val})
+
+
+def __pre_req_warns():
+    start = time()
+    LOGGER.info("Starting Warns Database Repair...")
+    collection_warns = MongoDB(Warns.db_name)
+    collection_warn_settings = MongoDB(WarnSettings.db_name)
+    Warns.repair_db(collection_warns)
+    WarnSettings.repair_db(collection_warn_settings)
+    LOGGER.info(f"Done in {round((time() - start), 3)}s!")

Powers/plugins/__init__.py

@@ -0,0 +1,14 @@
+async def all_plugins():
+    # This generates a list of plugins in this folder for the * in __main__ to
+    # work.
+
+    from glob import glob
+    from os.path import basename, dirname, isfile
+
+    mod_paths = glob(dirname(__file__) + "/*.py")
+    all_plugs = [
+        basename(f)[:-3]
+        for f in mod_paths
+        if isfile(f) and f.endswith(".py") and not f.endswith("__init__.py")
+    ]
+    return sorted(all_plugs)

Powers/plugins/admin.py

@@ -0,0 +1,769 @@
+from asyncio import sleep
+from html import escape
+from os import remove
+from traceback import format_exc
+
+from pyrogram import filters
+from pyrogram.errors import (
+    ChatAdminInviteRequired,
+    ChatAdminRequired,
+    FloodWait,
+    RightForbidden,
+    RPCError,
+    UserAdminInvalid,
+)
+from pyrogram.types import Message
+
+from Powers import DEV_USERS, LOGGER, OWNER_ID, SUPPORT_GROUP, SUPPORT_STAFF
+from Powers.bot_class import Gojo
+from Powers.database.approve_db import Approve
+from Powers.database.reporting_db import Reporting
+from Powers.tr_engine import tlang
+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.extract_user import extract_user
+from Powers.utils.parser import mention_html
+from Powers.vars import Config
+
+
+@Gojo.on_message(command("adminlist"))
+async def adminlist_show(_, m: Message):
+    global ADMIN_CACHE
+    if m.chat.type != "supergroup":
+        return await m.reply_text(
+            "This command is made to be used in groups only!",
+        )
+    try:
+        try:
+            admin_list = ADMIN_CACHE[m.chat.id]
+            note = tlang(m, "admin.adminlist.note_cached")
+        except KeyError:
+            admin_list = await admin_cache_reload(m, "adminlist")
+            note = tlang(m, "admin.adminlist.note_updated")
+
+        adminstr = (tlang(m, "admin.adminlist.adminstr")).format(
+            chat_title=m.chat.title,
+        ) + "\n\n"
+
+        bot_admins = [i for i in admin_list if (i[1].lower()).endswith("bot")]
+        user_admins = [i for i in admin_list if not (i[1].lower()).endswith("bot")]
+
+        # format is like: (user_id, username/name,anonyamous or not)
+        mention_users = [
+            (
+                admin[1]
+                if admin[1].startswith("@")
+                else (await mention_html(admin[1], admin[0]))
+            )
+            for admin in user_admins
+            if not admin[2]  # if non-anonyamous admin
+        ]
+        mention_users.sort(key=lambda x: x[1])
+
+        mention_bots = [
+            (
+                admin[1]
+                if admin[1].startswith("@")
+                else (await mention_html(admin[1], admin[0]))
+            )
+            for admin in bot_admins
+        ]
+        mention_bots.sort(key=lambda x: x[1])
+
+        adminstr += "<b>User Admins:</b>\n"
+        adminstr += "\n".join(f"- {i}" for i in mention_users)
+        adminstr += "\n\n<b>Bots:</b>\n"
+        adminstr += "\n".join(f"- {i}" for i in mention_bots)
+
+        await m.reply_text(adminstr + "\n\n" + note)
+        LOGGER.info(f"Adminlist cmd use in {m.chat.id} by {m.from_user.id}")
+
+    except Exception as ef:
+        if str(ef) == str(m.chat.id):
+            await m.reply_text(tlang(m, "admin.adminlist.use_admin_cache"))
+        else:
+            ef = str(ef) + f"{admin_list}\n"
+            await m.reply_text(
+                (tlang(m, "general.some_error")).format(
+                    SUPPORT_GROUP=SUPPORT_GROUP,
+                    ef=ef,
+                ),
+            )
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+
+    return
+
+
+@Gojo.on_message(command("zombies") & owner_filter)
+async def zombie_clean(c: Gojo, m: Message):
+
+    zombie = 0
+
+    wait = await m.reply_text("Searching ... and banning ...")
+    async for member in c.iter_chat_members(m.chat.id):
+        if member.user.is_deleted:
+            zombie += 1
+            try:
+                await c.kick_chat_member(m.chat.id, member.user.id)
+            except UserAdminInvalid:
+                zombie -= 1
+            except FloodWait as e:
+                await sleep(e.x)
+    if zombie == 0:
+        return await wait.edit_text("Group is clean!")
+    return await wait.edit_text(
+        f"<b>{zombie}</b> Zombies found and has been banned!",
+    )
+
+
+@Gojo.on_message(command("admincache"))
+async def reload_admins(_, m: Message):
+    global TEMP_ADMIN_CACHE_BLOCK
+
+    if m.chat.type != "supergroup":
+        return await m.reply_text(
+            "This command is made to be used in groups only!",
+        )
+
+    if (
+        (m.chat.id in set(TEMP_ADMIN_CACHE_BLOCK.keys()))
+        and (m.from_user.id not in SUPPORT_STAFF)
+        and TEMP_ADMIN_CACHE_BLOCK[m.chat.id] == "manualblock"
+    ):
+        await m.reply_text("Can only reload admin cache once per 10 mins!")
+        return
+
+    try:
+        await admin_cache_reload(m, "admincache")
+        TEMP_ADMIN_CACHE_BLOCK[m.chat.id] = "manualblock"
+        await m.reply_text(tlang(m, "admin.adminlist.reloaded_admins"))
+        LOGGER.info(f"Admincache cmd use in {m.chat.id} by {m.from_user.id}")
+    except RPCError as ef:
+        await m.reply_text(
+            (tlang(m, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=ef,
+            ),
+        )
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+    return
+
+
+@Gojo.on_message(filters.regex(r"^(?i)@admin(s)?") & filters.group)
+async def tag_admins(_, m: Message):
+    db = Reporting(m.chat.id)
+    if not db.get_settings():
+        return
+
+    try:
+        admin_list = ADMIN_CACHE[m.chat.id]
+    except KeyError:
+        admin_list = await admin_cache_reload(m, "adminlist")
+
+    user_admins = [i for i in admin_list if not (i[1].lower()).endswith("bot")]
+    mention_users = [(await mention_html("\u2063", admin[0])) for admin in user_admins]
+    mention_users.sort(key=lambda x: x[1])
+    mention_str = "".join(mention_users)
+    await m.reply_text(
+        (
+            f"{(await mention_html(m.from_user.first_name, m.from_user.id))}"
+            f" reported the message to admins!{mention_str}"
+        ),
+    )
+
+
+@Gojo.on_message(command("fullpromote") & promote_filter)
+async def fullpromote_usr(c: Gojo, m: Message):
+    global ADMIN_CACHE
+
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text(tlang(m, "admin.promote.no_target"))
+        return
+
+    try:
+        user_id, user_first_name, user_name = await extract_user(c, m)
+    except Exception:
+        return
+
+    bot = await c.get_chat_member(m.chat.id, Config.BOT_ID)
+
+    if user_id == Config.BOT_ID:
+        await m.reply_text("Huh, how can I even promote myself?")
+        return
+
+    if not bot.can_promote_members:
+        return await m.reply_text(
+            "I don't have enough permissions!",
+        )  # This should be here
+
+    user = await c.get_chat_member(m.chat.id, m.from_user.id)
+    if m.from_user.id not in [DEV_USERS, OWNER_ID] and user.status != "creator":
+        return await m.reply_text("This command can only be used by chat owner.")
+    # If user is alreay admin
+    try:
+        admin_list = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admin_list = {
+            i[0] for i in (await admin_cache_reload(m, "promote_cache_update"))
+        }
+
+    if user_id in admin_list:
+        await m.reply_text(
+            "This user is already an admin, how am I supposed to re-promote them?",
+        )
+        return
+
+    try:
+        await m.chat.promote_member(
+            user_id=user_id,
+            can_change_info=bot.can_change_info,
+            can_invite_users=bot.can_invite_users,
+            can_delete_messages=bot.can_delete_messages,
+            can_restrict_members=bot.can_restrict_members,
+            can_pin_messages=bot.can_pin_messages,
+            can_promote_members=bot.can_promote_members,
+            can_manage_chat=bot.can_manage_chat,
+            can_manage_voice_chats=bot.can_manage_voice_chats,
+        )
+
+        title = ""
+        if len(m.text.split()) == 3 and not m.reply_to_message:
+            title = m.text.split()[2]
+        elif len(m.text.split()) == 2 and m.reply_to_message:
+            title = m.text.split()[1]
+        if title and len(title) > 16:
+            title = title[0:16]  # trim title to 16 characters
+
+        try:
+            await c.set_administrator_title(m.chat.id, user_id, title)
+        except RPCError as e:
+            LOGGER.error(e)
+
+        LOGGER.info(
+            f"{m.from_user.id} fullpromoted {user_id} in {m.chat.id} with title '{title}'",
+        )
+
+        await m.reply_text(
+            (tlang(m, "admin.promote.promoted_user")).format(
+                promoter=(await mention_html(m.from_user.first_name, m.from_user.id)),
+                promoted=(await mention_html(user_first_name, user_id)),
+                chat_title=f"{escape(m.chat.title)} title set to {title}"
+                if title
+                else f"{escape(m.chat.title)} title set to Admin",
+            ),
+        )
+
+        # If user is approved, disapprove them as they willbe promoted and get even more rights
+        if Approve(m.chat.id).check_approve(user_id):
+            Approve(m.chat.id).remove_approve(user_id)
+
+        # ----- Add admin to temp cache -----
+        try:
+            inp1 = user_name or user_first_name
+            admins_group = ADMIN_CACHE[m.chat.id]
+            admins_group.append((user_id, inp1))
+            ADMIN_CACHE[m.chat.id] = admins_group
+        except KeyError:
+            await admin_cache_reload(m, "promote_key_error")
+
+    except ChatAdminRequired:
+        await m.reply_text(tlang(m, "admin.not_admin"))
+    except RightForbidden:
+        await m.reply_text(tlang(m, "admin.promote.bot_no_right"))
+    except UserAdminInvalid:
+        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
+    except RPCError as e:
+        await m.reply_text(
+            (tlang(m, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=e,
+            ),
+        )
+        LOGGER.error(e)
+        LOGGER.error(format_exc())
+    return
+
+
+@Gojo.on_message(command("promote") & promote_filter)
+async def promote_usr(c: Gojo, m: Message):
+
+    global ADMIN_CACHE
+
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text(tlang(m, "admin.promote.no_target"))
+        return
+
+    try:
+        user_id, user_first_name, user_name = await extract_user(c, m)
+    except Exception:
+        return
+
+    bot = await c.get_chat_member(m.chat.id, Config.BOT_ID)
+
+    if user_id == Config.BOT_ID:
+        await m.reply_text("Huh, how can I even promote myself?")
+        return
+
+    if not bot.can_promote_members:
+        return await m.reply_text(
+            "I don't have enough permissions",
+        )  # This should be here
+    # If user is alreay admin
+    try:
+        admin_list = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admin_list = {
+            i[0] for i in (await admin_cache_reload(m, "promote_cache_update"))
+        }
+
+    if user_id in admin_list:
+        await m.reply_text(
+            "This user is already an admin, how am I supposed to re-promote them?",
+        )
+        return
+
+    try:
+        await m.chat.promote_member(
+            user_id=user_id,
+            can_change_info=bot.can_change_info,
+            can_invite_users=bot.can_invite_users,
+            can_delete_messages=bot.can_delete_messages,
+            can_restrict_members=bot.can_restrict_members,
+            can_pin_messages=bot.can_pin_messages,
+            # can_promote_members=bot.can_promote_members,
+            can_manage_chat=bot.can_manage_chat,
+            can_manage_voice_chats=bot.can_manage_voice_chats,
+        )
+
+        title = "Itadori"  # Deafult title
+        if len(m.text.split()) == 3 and not m.reply_to_message:
+            title = m.text.split()[2]
+        elif len(m.text.split()) == 2 and m.reply_to_message:
+            title = m.text.split()[1]
+        if title and len(title) > 16:
+            title = title[0:16]  # trim title to 16 characters
+
+        try:
+            await c.set_administrator_title(m.chat.id, user_id, title)
+        except RPCError as e:
+            LOGGER.error(e)
+
+        LOGGER.info(
+            f"{m.from_user.id} promoted {user_id} in {m.chat.id} with title '{title}'",
+        )
+
+        await m.reply_text(
+            (tlang(m, "admin.promote.promoted_user")).format(
+                promoter=(await mention_html(m.from_user.first_name, m.from_user.id)),
+                promoted=(await mention_html(user_first_name, user_id)),
+                chat_title=f"{escape(m.chat.title)} title set to {title}"
+                if title
+                else f"{escape(m.chat.title)} title set to Admin",
+            ),
+        )
+
+        # If user is approved, disapprove them as they willbe promoted and get even more rights
+        if Approve(m.chat.id).check_approve(user_id):
+            Approve(m.chat.id).remove_approve(user_id)
+
+        # ----- Add admin to temp cache -----
+        try:
+            inp1 = user_name or user_first_name
+            admins_group = ADMIN_CACHE[m.chat.id]
+            admins_group.append((user_id, inp1))
+            ADMIN_CACHE[m.chat.id] = admins_group
+        except KeyError:
+            await admin_cache_reload(m, "promote_key_error")
+
+    except ChatAdminRequired:
+        await m.reply_text(tlang(m, "admin.not_admin"))
+    except RightForbidden:
+        await m.reply_text(tlang(m, "admin.promote.bot_no_right"))
+    except UserAdminInvalid:
+        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
+    except RPCError as e:
+        await m.reply_text(
+            (tlang(m, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=e,
+            ),
+        )
+        LOGGER.error(e)
+        LOGGER.error(format_exc())
+    return
+
+
+
+@Gojo.on_message(command("spromote") & promote_filter)
+async def superpromote_usr(c: Gojo, m: Message):
+
+    global ADMIN_CACHE
+
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text(tlang(m, "admin.promote.no_target"))
+        return
+
+    try:
+        user_id, user_first_name, user_name = await extract_user(c, m)
+    except Exception:
+        return
+
+    bot = await c.get_chat_member(m.chat.id, Config.BOT_ID)
+
+    if user_id == Config.BOT_ID:
+        await m.reply_text("Huh, how can I even promote myself?")
+        return
+
+    if not bot.can_promote_members:
+        return await m.reply_text(
+            "I don't have enough permissions",
+        )  # This should be here
+    # If user is alreay admin
+    try:
+        admin_list = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admin_list = {
+            i[0] for i in (await admin_cache_reload(m, "promote_cache_update"))
+        }
+
+    if user_id in admin_list:
+        await m.reply_text(
+            "This user is already an admin, how am I supposed to re-promote them?",
+        )
+        return
+
+    try:
+        await m.chat.promote_member(
+            user_id=user_id,
+            can_change_info=bot.can_change_info,
+            can_invite_users=bot.can_invite_users,
+            can_delete_messages=bot.can_delete_messages,
+            can_restrict_members=bot.can_restrict_members,
+            can_pin_messages=bot.can_pin_messages,
+            can_promote_members=bot.can_promote_members,
+            can_manage_chat=bot.can_manage_chat,
+            can_manage_voice_chats=bot.can_manage_voice_chats,
+        )
+
+        title = "Gojo"  # Deafult title
+        if len(m.text.split()) == 3 and not m.reply_to_message:
+            title = m.text.split()[2]
+        elif len(m.text.split()) == 2 and m.reply_to_message:
+            title = m.text.split()[1]
+        if title and len(title) > 16:
+            title = title[0:16]  # trim title to 16 characters
+
+        try:
+            await c.set_administrator_title(m.chat.id, user_id, title)
+        except RPCError as e:
+            LOGGER.error(e)
+
+        LOGGER.info(
+            f"{m.from_user.id} super promoted {user_id} in {m.chat.id} with title '{title}'",
+        )
+
+        await m.reply_text(
+            (tlang(m, "admin.promote.promoted_user")).format(
+                promoter=(await mention_html(m.from_user.first_name, m.from_user.id)),
+                promoted=(await mention_html(user_first_name, user_id)),
+                chat_title=f"{escape(m.chat.title)} title set to {title}"
+                if title
+                else f"{escape(m.chat.title)} title set to Admin",
+            ),
+        )
+
+        # If user is approved, disapprove them as they willbe promoted and get even more rights
+        if Approve(m.chat.id).check_approve(user_id):
+            Approve(m.chat.id).remove_approve(user_id)
+
+        # ----- Add admin to temp cache -----
+        try:
+            inp1 = user_name or user_first_name
+            admins_group = ADMIN_CACHE[m.chat.id]
+            admins_group.append((user_id, inp1))
+            ADMIN_CACHE[m.chat.id] = admins_group
+        except KeyError:
+            await admin_cache_reload(m, "promote_key_error")
+
+    except ChatAdminRequired:
+        await m.reply_text(tlang(m, "admin.not_admin"))
+    except RightForbidden:
+        await m.reply_text(tlang(m, "admin.promote.bot_no_right"))
+    except UserAdminInvalid:
+        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
+    except RPCError as e:
+        await m.reply_text(
+            (tlang(m, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=e,
+            ),
+        )
+        LOGGER.error(e)
+        LOGGER.error(format_exc())
+    return
+
+
+@Gojo.on_message(command("demote") & promote_filter)
+async def demote_usr(c: Gojo, m: Message):
+
+    global ADMIN_CACHE
+
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text(tlang(m, "admin.demote.no_target"))
+        return
+
+    try:
+        user_id, user_first_name, _ = await extract_user(c, m)
+    except Exception:
+        return
+
+    if user_id == Config.BOT_ID:
+        await m.reply_text("Get an admin to demote me!")
+        return
+
+    # If user not alreay admin
+    try:
+        admin_list = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admin_list = {
+            i[0] for i in (await admin_cache_reload(m, "demote_cache_update"))
+        }
+
+    if user_id not in admin_list:
+        await m.reply_text(
+            "This user is not an admin, how am I supposed to re-demote them?",
+        )
+        return
+
+    try:
+        await m.chat.promote_member(
+            user_id=user_id,
+            can_change_info=False,
+            can_invite_users=False,
+            can_delete_messages=False,
+            can_restrict_members=False,
+            can_pin_messages=False,
+            can_promote_members=False,
+            can_manage_chat=False,
+            can_manage_voice_chats=False,
+        )
+        LOGGER.info(f"{m.from_user.id} demoted {user_id} in {m.chat.id}")
+
+        # ----- Remove admin from cache -----
+        try:
+            admin_list = ADMIN_CACHE[m.chat.id]
+            user = next(user for user in admin_list if user[0] == user_id)
+            admin_list.remove(user)
+            ADMIN_CACHE[m.chat.id] = admin_list
+        except (KeyError, StopIteration):
+            await admin_cache_reload(m, "demote_key_stopiter_error")
+
+        await m.reply_text(
+            (tlang(m, "admin.demote.demoted_user")).format(
+                demoter=(
+                    await mention_html(
+                        m.from_user.first_name,
+                        m.from_user.id,
+                    )
+                ),
+                demoted=(await mention_html(user_first_name, user_id)),
+                chat_title=m.chat.title,
+            ),
+        )
+
+    except ChatAdminRequired:
+        await m.reply_text(tlang(m, "admin.not_admin"))
+    except RightForbidden:
+        await m.reply_text(tlang(m, "admin.demote.bot_no_right"))
+    except UserAdminInvalid:
+        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
+    except RPCError as ef:
+        await m.reply_text(
+            (tlang(m, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=ef,
+            ),
+        )
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+
+    return
+
+
+
+
+@Gojo.on_message(command("invitelink"))
+async def get_invitelink(c: Gojo, m: Message):
+    # Bypass the bot devs, sudos and owner
+    if m.from_user.id not in DEV_LEVEL:
+        user = await m.chat.get_member(m.from_user.id)
+
+        if not user.can_invite_users and user.status != "creator":
+            await m.reply_text(tlang(m, "admin.no_user_invite_perm"))
+            return False
+
+    try:
+        link = await c.export_chat_invite_link(m.chat.id)
+        await m.reply_text(
+            (tlang(m, "admin.invitelink")).format(
+                chat_name=m.chat.id,
+                link=link,
+            ),
+            disable_web_page_preview=True,
+        )
+        LOGGER.info(f"{m.from_user.id} exported invite link in {m.chat.id}")
+    except ChatAdminRequired:
+        await m.reply_text(tlang(m, "admin.not_admin"))
+    except ChatAdminInviteRequired:
+        await m.reply_text(tlang(m, "admin.no_invite_perm"))
+    except RightForbidden:
+        await m.reply_text(tlang(m, "admin.no_user_invite_perm"))
+    except RPCError as ef:
+        await m.reply_text(
+            (tlang(m, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=ef,
+            ),
+        )
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+
+    return
+
+
+@Gojo.on_message(command("setgtitle") & admin_filter)
+async def setgtitle(_, m: Message):
+    user = await m.chat.get_member(m.from_user.id)
+
+    if not user.can_change_info and user.status != "creator":
+        await m.reply_text(
+            "You don't have enough permission to use this command!",
+        )
+        return False
+
+    if len(m.command) < 1:
+        return await m.reply_text("Please read /help for using it!")
+
+    gtit = m.text.split(None, 1)[1]
+    try:
+        await m.chat.set_title(gtit)
+    except Exception as e:
+        return await m.reply_text(f"Error: {e}")
+    return await m.reply_text(
+        f"Successfully Changed Group Title From {m.chat.title} To {gtit}",
+    )
+
+
+@Gojo.on_message(command("setgdes") & admin_filter)
+async def setgdes(_, m: Message):
+
+    user = await m.chat.get_member(m.from_user.id)
+    if not user.can_change_info and user.status != "creator":
+        await m.reply_text(
+            "You don't have enough permission to use this command!",
+        )
+        return False
+
+    if len(m.command) < 1:
+        return await m.reply_text("Please read /help for using it!")
+
+    desp = m.text.split(None, 1)[1]
+    try:
+        await m.chat.set_description(desp)
+    except Exception as e:
+        return await m.reply_text(f"Error: {e}")
+    return await m.reply_text(
+        f"Successfully Changed Group description From {m.chat.description} To {desp}",
+    )
+
+
+@Gojo.on_message(command("title") & admin_filter)
+async def set_user_title(c: Gojo, m: Message):
+
+    user = await m.chat.get_member(m.from_user.id)
+    if not user.can_promote_members and user.status != "creator":
+        await m.reply_text(
+            "You don't have enough permission to use this command!",
+        )
+        return False
+
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        return await m.reply_text("To whom??")
+
+    if m.reply_to_message:
+        if len(m.text.split()) >= 2:
+            reason = m.text.split(None, 1)[1]
+    else:
+        if len(m.text.split()) >= 3:
+            reason = m.text.split(None, 2)[2]
+    try:
+        user_id, _, _ = await extract_user(c, m)
+    except Exception:
+        return
+
+    if not user_id:
+        return await m.reply_text("Cannot find user!")
+
+    if user_id == Config.BOT_ID:
+        return await m.reply_text("Huh, why ?")
+
+    if not reason:
+        return await m.reply_text("Read /help please!")
+
+    from_user = await c.get_users(user_id)
+    title = reason
+    try:
+        await c.set_administrator_title(m.chat.id, from_user.id, title)
+    except Exception as e:
+        return await m.reply_text(f"Error: {e}")
+    return await m.reply_text(
+        f"Successfully Changed {from_user.mention}'s Admin Title To {title}",
+    )
+
+
+@Gojo.on_message(command("setgpic") & admin_filter)
+async def setgpic(c: Gojo, m: Message):
+    user = await m.chat.get_member(m.from_user.id)
+    if not user.can_change_info and user.status != "creator":
+        await m.reply_text(
+            "You don't have enough permission to use this command!",
+        )
+        return False
+    if not m.reply_to_message:
+        return await m.reply_text("Reply to a photo to set it as chat photo")
+    if not m.reply_to_message.photo and not m.reply_to_message.document:
+        return await m.reply_text("Reply to a photo to set it as chat photo")
+    photo = await m.reply_to_message.download()
+    try:
+        await m.chat.set_photo(photo)
+    except Exception as e:
+        remove(photo)
+        return await m.reply_text(f"Error: {e}")
+    await m.reply_text("Successfully Changed Group Photo!")
+    remove(photo)
+
+
+__PLUGIN__ = "admin"
+
+__alt_name__ = [
+    "admins",
+    "promote",
+    "spromote",
+    "demote",
+    "adminlist",
+    "setgpic",
+    "title",
+    "setgtitle",
+    "fullpromote",
+    "invitelink",
+    "setgdes",
+    "zombies",
+]

Powers/plugins/antispam.py

@@ -0,0 +1,181 @@
+from datetime import datetime
+from io import BytesIO
+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
+from Powers.bot_class import Gojo
+from Powers.database.antispam_db import GBan
+from Powers.database.users_db import Users
+from Powers.tr_engine import tlang
+from Powers.utils.clean_file import remove_markdown_and_html
+from Powers.utils.custom_filters import command
+from Powers.utils.extract_user import extract_user
+from Powers.utils.parser import mention_html
+from Powers.vars import Config
+
+# Initialize
+db = GBan()
+
+
+@Gojo.on_message(command(["gban", "globalban"], sudo_cmd=True))
+async def gban(c: Gojo, m: Message):
+    if len(m.text.split()) == 1:
+        await m.reply_text(tlang(m, "antispam.gban.how_to"))
+        return
+
+    if len(m.text.split()) == 2 and not m.reply_to_message:
+        await m.reply_text(tlang(m, "antispam.gban.enter_reason"))
+        return
+
+    user_id, user_first_name, _ = await extract_user(c, m)
+
+    if m.reply_to_message:
+        gban_reason = m.text.split(None, 1)[1]
+    else:
+        gban_reason = m.text.split(None, 2)[2]
+
+    if user_id in SUPPORT_STAFF:
+        await m.reply_text(tlang(m, "antispam.part_of_support"))
+        return
+
+    if user_id == Config.BOT_ID:
+        await m.reply_text(tlang(m, "antispam.gban.not_self"))
+        return
+
+    if db.check_gban(user_id):
+        db.update_gban_reason(user_id, gban_reason)
+        await m.reply_text(
+            (tlang(m, "antispam.gban.updated_reason")).format(
+                gban_reason=gban_reason,
+            ),
+        )
+        return
+
+    db.add_gban(user_id, gban_reason, m.from_user.id)
+    await m.reply_text(
+        (tlang(m, "antispam.gban.added_to_watch")).format(
+            first_name=user_first_name,
+        ),
+    )
+    LOGGER.info(f"{m.from_user.id} gbanned {user_id} from {m.chat.id}")
+    log_msg = (tlang(m, "antispam.gban.log_msg")).format(
+        chat_id=m.chat.id,
+        ban_admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
+        gbanned_user=(await mention_html(user_first_name, user_id)),
+        gban_user_id=user_id,
+        time=(datetime.utcnow().strftime("%H:%M - %d-%m-%Y")),
+    )
+    await c.send_message(MESSAGE_DUMP, log_msg)
+    try:
+        # Send message to user telling that he's gbanned
+        await c.send_message(
+            user_id,
+            (tlang(m, "antispam.gban.user_added_to_watch")).format(
+                gban_reason=gban_reason,
+                SUPPORT_GROUP=SUPPORT_GROUP,
+            ),
+        )
+    except UserIsBlocked:
+        LOGGER.error("Could not send PM Message, user blocked bot")
+    except PeerIdInvalid:
+        LOGGER.error(
+            "Haven't seen this user anywhere, mind forwarding one of their messages to me?",
+        )
+    except Exception as ef:  # TO DO: Improve Error Detection
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+    return
+
+
+@Gojo.on_message(
+    command(["ungban", "unglobalban", "globalunban"], sudo_cmd=True),
+)
+async def ungban(c: Gojo, m: Message):
+    if len(m.text.split()) == 1:
+        await m.reply_text(tlang(m, "antispam.pass_user_id"))
+        return
+
+    user_id, user_first_name, _ = await extract_user(c, m)
+
+    if user_id in SUPPORT_STAFF:
+        await m.reply_text(tlang(m, "antispam.part_of_support"))
+        return
+
+    if user_id == Config.BOT_ID:
+        await m.reply_text(tlang(m, "antispam.ungban.not_self"))
+        return
+
+    if db.check_gban(user_id):
+        db.remove_gban(user_id)
+        await m.reply_text(
+            (tlang(m, "antispam.ungban.removed_from_list")).format(
+                first_name=user_first_name,
+            ),
+        )
+        LOGGER.info(f"{m.from_user.id} ungbanned {user_id} from {m.chat.id}")
+        log_msg = (tlang(m, "amtispam.ungban.log_msg")).format(
+            chat_id=m.chat.id,
+            ungban_admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
+            ungbaned_user=(await mention_html(user_first_name, user_id)),
+            ungbanned_user_id=user_id,
+            time=(datetime.utcnow().strftime("%H:%M - %d-%m-%Y")),
+        )
+        await c.send_message(MESSAGE_DUMP, log_msg)
+        try:
+            # Send message to user telling that he's ungbanned
+            await c.send_message(
+                user_id,
+                (tlang(m, "antispam.ungban.user_removed_from_list")),
+            )
+        except Exception as ef:  # TODO: Improve Error Detection
+            LOGGER.error(ef)
+            LOGGER.error(format_exc())
+        return
+
+    await m.reply_text(tlang(m, "antispam.ungban.non_gbanned"))
+    return
+
+
+@Gojo.on_message(
+    command(["numgbans", "countgbans", "gbancount", "gbanscount"], sudo_cmd=True),
+)
+async def gban_count(_, m: Message):
+    await m.reply_text(
+        (tlang(m, "antispam.num_gbans")).format(count=(db.count_gbans())),
+    )
+    LOGGER.info(f"{m.from_user.id} counting gbans in {m.chat.id}")
+    return
+
+
+@Gojo.on_message(
+    command(["gbanlist", "globalbanlist"], sudo_cmd=True),
+)
+async def gban_list(_, m: Message):
+    banned_users = db.load_from_db()
+
+    if not banned_users:
+        await m.reply_text(tlang(m, "antispam.none_gbanned"))
+        return
+
+    banfile = tlang(m, "antispam.here_gbanned_start")
+    for user in banned_users:
+        banfile += f"[x] <b>{Users.get_user_info(user['_id'])['name']}</b> - <code>{user['_id']}</code>\n"
+        if user["reason"]:
+            banfile += f"<b>Reason:</b> {user['reason']}\n"
+
+    try:
+        await m.reply_text(banfile)
+    except MessageTooLong:
+        with BytesIO(str.encode(await remove_markdown_and_html(banfile))) as f:
+            f.name = "gbanlist.txt"
+            await m.reply_document(
+                document=f,
+                caption=tlang(m, "antispam.here_gbanned_start"),
+            )
+
+    LOGGER.info(f"{m.from_user.id} exported gbanlist in {m.chat.id}")
+
+    return

Powers/plugins/approve.py

@@ -0,0 +1,234 @@
+from pyrogram import filters
+from pyrogram.errors import PeerIdInvalid, RPCError, UserNotParticipant
+from pyrogram.types import CallbackQuery, ChatPermissions, Message
+
+from Powers import LOGGER, SUPPORT_GROUP
+from Powers.bot_class import Gojo
+from Powers.database.approve_db import Approve
+from Powers.utils.custom_filters import admin_filter, command, owner_filter
+from Powers.utils.extract_user import extract_user
+from Powers.utils.kbhelpers import ikb
+from Powers.utils.parser import mention_html
+
+
+@Gojo.on_message(command("approve") & admin_filter)
+async def approve_user(c: Gojo, m: Message):
+    db = Approve(m.chat.id)
+
+    chat_title = m.chat.title
+
+    try:
+        user_id, user_first_name, _ = await extract_user(c, m)
+    except Exception:
+        return
+
+    if not user_id:
+        await m.reply_text(
+            "I don't know who you're talking about, you're going to need to specify a user!",
+        )
+        return
+    try:
+        member = await m.chat.get_member(user_id)
+    except UserNotParticipant:
+        await m.reply_text("This user is not in this chat!")
+        return
+
+    except RPCError as ef:
+        await m.reply_text(
+            f"<b>Error</b>: <code>{ef}</code>\nReport it to @{SUPPORT_GROUP}",
+        )
+        return
+    if member.status in ("administrator", "creator"):
+        await m.reply_text(
+            "User is already admin - blacklists and locks already don't apply to them.",
+        )
+        return
+    already_approved = db.check_approve(user_id)
+    if already_approved:
+        await m.reply_text(
+            f"{(await mention_html(user_first_name, user_id))} is already approved in {chat_title}",
+        )
+        return
+    db.add_approve(user_id, user_first_name)
+    LOGGER.info(f"{user_id} approved by {m.from_user.id} in {m.chat.id}")
+
+    # Allow all permissions
+    try:
+        await m.chat.unban_member(user_id=user_id)
+    except RPCError as g:
+        await m.reply_text(f"Error: {g}")
+        return
+    await m.reply_text(
+        (
+            f"{(await mention_html(user_first_name, user_id))} has been approved in {chat_title}!\n"
+            "They will now be ignored by blacklists, locks and antiflood!"
+        ),
+    )
+    return
+
+
+@Gojo.on_message(
+    command(["disapprove", "unapprove"]) & admin_filter,
+)
+async def disapprove_user(c: Gojo, m: Message):
+    db = Approve(m.chat.id)
+
+    chat_title = m.chat.title
+    try:
+        user_id, user_first_name, _ = await extract_user(c, m)
+    except Exception:
+        return
+    already_approved = db.check_approve(user_id)
+    if not user_id:
+        await m.reply_text(
+            "I don't know who you're talking about, you're going to need to specify a user!",
+        )
+        return
+    try:
+        member = await m.chat.get_member(user_id)
+    except UserNotParticipant:
+        if already_approved:  # If user is approved and not in chat, unapprove them.
+            db.remove_approve(user_id)
+            LOGGER.info(f"{user_id} disapproved in {m.chat.id} as UserNotParticipant")
+        await m.reply_text("This user is not in this chat, unapproved them.")
+        return
+    except RPCError as ef:
+        await m.reply_text(
+            f"<b>Error</b>: <code>{ef}</code>\nReport it to @{SUPPORT_GROUP}",
+        )
+        return
+
+    if member.status in ("administrator", "creator"):
+        await m.reply_text("This user is an admin, they can't be disapproved.")
+        return
+
+    if not already_approved:
+        await m.reply_text(
+            f"{(await mention_html(user_first_name, user_id))} isn't approved yet!",
+        )
+        return
+
+    db.remove_approve(user_id)
+    LOGGER.info(f"{user_id} disapproved by {m.from_user.id} in {m.chat.id}")
+
+    # Set permission same as of current user by fetching them from chat!
+    await m.chat.restrict_member(
+        user_id=user_id,
+        permissions=m.chat.permissions,
+    )
+
+    await m.reply_text(
+        f"{(await mention_html(user_first_name, user_id))} is no longer approved in {chat_title}.",
+    )
+    return
+
+
+@Gojo.on_message(command("approved") & admin_filter)
+async def check_approved(_, m: Message):
+    db = Approve(m.chat.id)
+
+    chat = m.chat
+    chat_title = chat.title
+    msg = "The following users are approved:\n"
+    approved_people = db.list_approved()
+
+    if not approved_people:
+        await m.reply_text(f"No users are approved in {chat_title}.")
+        return
+
+    for user_id, user_name in approved_people.items():
+        try:
+            await chat.get_member(user_id)  # Check if user is in chat or not
+        except UserNotParticipant:
+            db.remove_approve(user_id)
+            continue
+        except PeerIdInvalid:
+            pass
+        msg += f"- `{user_id}`: {user_name}\n"
+    await m.reply_text(msg)
+    LOGGER.info(f"{m.from_user.id} checking approved users in {m.chat.id}")
+    return
+
+
+@Gojo.on_message(command("approval") & filters.group)
+async def check_approval(c: Gojo, m: Message):
+    db = Approve(m.chat.id)
+
+    try:
+        user_id, user_first_name, _ = await extract_user(c, m)
+    except Exception:
+        return
+    check_approve = db.check_approve(user_id)
+    LOGGER.info(f"{m.from_user.id} checking approval of {user_id} in {m.chat.id}")
+
+    if not user_id:
+        await m.reply_text(
+            "I don't know who you're talking about, you're going to need to specify a user!",
+        )
+        return
+    if check_approve:
+        await m.reply_text(
+            f"{(await mention_html(user_first_name, user_id))} is an approved user. Locks, antiflood, and blacklists won't apply to them.",
+        )
+    else:
+        await m.reply_text(
+            f"{(await mention_html(user_first_name, user_id))} is not an approved user. They are affected by normal commands.",
+        )
+    return
+
+
+@Gojo.on_message(
+    command("unapproveall") & filters.group & owner_filter,
+)
+async def unapproveall_users(_, m: Message):
+    db = Approve(m.chat.id)
+
+    all_approved = db.list_approved()
+    if not all_approved:
+        await m.reply_text("No one is approved in this chat.")
+        return
+
+    await m.reply_text(
+        "Are you sure you want to remove everyone who is approved in this chat?",
+        reply_markup=ikb(
+            [[("⚠️ Confirm", "unapprove_all"), ("❌ Cancel", "close_admin")]],
+        ),
+    )
+    return
+
+
+@Gojo.on_callback_query(filters.regex("^unapprove_all$"))
+async def unapproveall_callback(_, q: CallbackQuery):
+    user_id = q.from_user.id
+    db = Approve(q.message.chat.id)
+    approved_people = db.list_approved()
+    user_status = (await q.message.chat.get_member(user_id)).status
+    if user_status not in {"creator", "administrator"}:
+        await q.answer(
+            "You're not even an admin, don't try this explosive shit!",
+            show_alert=True,
+        )
+        return
+    if user_status != "creator":
+        await q.answer(
+            "You're just an admin, not owner\nStay in your limits!",
+            show_alert=True,
+        )
+        return
+    db.unapprove_all()
+    for i in approved_people:
+        await q.message.chat.restrict_member(
+            user_id=i[0],
+            permissions=q.message.chat.permissions,
+        )
+    await q.message.delete()
+    LOGGER.info(f"{user_id} disapproved all users in {q.message.chat.id}")
+    await q.answer("Disapproved all users!", show_alert=True)
+    return
+
+
+__PLUGIN__ = "approve"
+
+_DISABLE_CMDS_ = ["approval"]
+
+__alt_name__ = ["approved"]

Powers/plugins/bans.py

@@ -0,0 +1,901 @@
+from traceback import format_exc
+import random
+
+from pyrogram.errors import (
+    ChatAdminRequired,
+    PeerIdInvalid,
+    RightForbidden,
+    RPCError,
+    UserAdminInvalid,
+)
+from pyrogram.filters import regex
+from pyrogram.types import (
+    CallbackQuery,
+    InlineKeyboardButton,
+    InlineKeyboardMarkup,
+    Message,
+)
+
+from Powers import LOGGER, OWNER_ID, SUPPORT_GROUP, SUPPORT_STAFF
+from Powers.bot_class import Gojo
+from Powers.utils.fun_strings import BAN_GIFS, KICK_GIFS
+from Powers.tr_engine import tlang
+from Powers.utils.caching import ADMIN_CACHE, admin_cache_reload
+from Powers.utils.custom_filters import command, restrict_filter
+from Powers.utils.extract_user import extract_user
+from Powers.utils.parser import mention_html
+from Powers.utils.string import extract_time
+from Powers.vars import Config
+
+
+BAN_MEDIA = random.choice(BAN_GIFS)
+KICK_MEDIA = random.choice(KICK_GIFS)
+
+@Gojo.on_message(command("tban") & restrict_filter)
+async def tban_usr(c: Gojo, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text(tlang(m, "Provide me an user id or username or atleast reply to user"))
+        await m.stop_propagation()
+
+    try:
+        user_id, user_first_name, _ = await extract_user(c, m)
+    except Exception:
+        return
+
+    if not user_id:
+        await m.reply_text("Cannot find user to ban")
+        return
+    if user_id == Config.BOT_ID:
+        await m.reply_text("WTF??  Why would I ban myself?")
+        await m.stop_propagation()
+
+    if user_id in SUPPORT_STAFF:
+        await m.reply_text(tlang(m, "If I will ban this user....then who will going to manage me?"))
+        LOGGER.info(
+            f"{m.from_user.id} trying to ban {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        await m.stop_propagation()
+
+    r_id = m.reply_to_message.message_id if m.reply_to_message else m.message_id
+
+    if m.reply_to_message and len(m.text.split()) >= 2:
+        reason = m.text.split(None, 2)[1]
+    elif not m.reply_to_message and len(m.text.split()) >= 3:
+        reason = m.text.split(None, 2)[2]
+    else:
+        await m.reply_text("Read /help !!")
+        return
+
+    if not reason:
+        await m.reply_text("You haven't specified a time to ban this user for!")
+        return
+
+    split_reason = reason.split(None, 1)
+    time_val = split_reason[0].lower()
+    reason = split_reason[1] if len(split_reason) > 1 else ""
+
+    bantime = await extract_time(m, time_val)
+
+    if not bantime:
+        return
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = await admin_cache_reload(m, "ban")
+
+    if user_id in admins_group:
+        await m.reply_text(tlang(m, "I am not going to ban an admin"))
+        await m.stop_propagation()
+
+    try:
+        LOGGER.info(f"{m.from_user.id} tbanned {user_id} in {m.chat.id}")
+        await m.chat.ban_member(user_id, until_date=int(bantime))
+        txt = (tlang(m, "Successfully banned the user")).format(
+            admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
+            banned=(await mention_html(user_first_name, user_id)),
+            chat_title=m.chat.title,
+        )
+        txt += f"\n<b>Reason</b>: {reason}" if reason else ""
+        keyboard = InlineKeyboardMarkup(
+            [
+                [
+                    InlineKeyboardButton(
+                        "Unban",
+                        callback_data=f"unban_={user_id}",
+                    ),
+                ],
+            ],
+        )
+        await m.reply_animation(reply_to_message_id = r_id, animation = BAN_MEDIA, caption = txt,  reply_markup=keyboard, parse_mode="html")
+       # await m.reply_text(txt, reply_markup=keyboard, reply_to_message_id=r_id)
+    except ChatAdminRequired:
+        await m.reply_text(tlang(m, "You are not an admin here so stay in your limit bud...."))
+    except PeerIdInvalid:
+        await m.reply_text(
+            "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
+        )
+    except UserAdminInvalid:
+        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
+    except RightForbidden:
+        await m.reply_text(tlang(m, tlang(m, "I don't have rights to ban members.....")))
+    except RPCError as ef:
+        await m.reply_text(
+            (tlang(m, "It's a general error contact support staff to know more...")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=ef,
+            ),
+        )
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+    return
+
+
+@Gojo.on_message(command("stban") & restrict_filter)
+async def stban_usr(c: Gojo, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text(tlang(m, "Provide me an user id or username or atleast reply to user"))
+        await m.stop_propagation()
+
+    try:
+        user_id, _, _ = await extract_user(c, m)
+    except Exception:
+        return
+
+    if not user_id:
+        await m.reply_text("Cannot find user to ban")
+        return
+    if user_id == Config.BOT_ID:
+        await m.reply_text("What the heck? Why would I ban myself?")
+        await m.stop_propagation()
+
+    if user_id in SUPPORT_STAFF:
+        await m.reply_text(tlang(m, "I am not going to ban one of my support staff"))
+        LOGGER.info(
+            f"{m.from_user.id} trying to ban {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        await m.stop_propagation()
+
+    if m.reply_to_message and len(m.text.split()) >= 2:
+        reason = m.text.split(None, 2)[1]
+    elif not m.reply_to_message and len(m.text.split()) >= 3:
+        reason = m.text.split(None, 2)[2]
+    else:
+        await m.reply_text("Read /help !!")
+        return
+
+    if not reason:
+        await m.reply_text("You haven't specified a time to ban this user for!")
+        return
+
+    split_reason = reason.split(None, 1)
+    time_val = split_reason[0].lower()
+    reason = split_reason[1] if len(split_reason) > 1 else ""
+
+    bantime = await extract_time(m, time_val)
+
+    if not bantime:
+        return
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = await admin_cache_reload(m, "ban")
+
+    if user_id in admins_group:
+        await m.reply_text(tlang(m, "I am not going to ban an admin..."))
+        await m.stop_propagation()
+
+    try:
+        LOGGER.info(f"{m.from_user.id} stbanned {user_id} in {m.chat.id}")
+        await m.chat.ban_member(user_id, until_date=int(bantime))
+        await m.delete()
+        if m.reply_to_message:
+            await m.reply_to_message.delete()
+            return
+        return
+    except ChatAdminRequired:
+        await m.reply_text(tlang(m, "Stay in your limits....."))
+    except PeerIdInvalid:
+        await m.reply_text(
+            "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
+        )
+    except UserAdminInvalid:
+        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
+    except RightForbidden:
+        await m.reply_text(tlang(m, tlang(m, "I don't have power to ban....")))
+    except RPCError as ef:
+        await m.reply_text(
+            (tlang(m, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=ef,
+            ),
+        )
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+    return
+
+
+@Gojo.on_message(command("dtban") & restrict_filter)
+async def dtban_usr(c: Gojo, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text(tlang(m, "admin.ban.no_target"))
+        await m.stop_propagation()
+
+    if not m.reply_to_message:
+        await m.reply_text(
+            "Reply to a message with this command to temp ban and delete the message.",
+        )
+        await m.stop_propagation()
+
+    user_id = m.reply_to_message.from_user.id
+    user_first_name = m.reply_to_message.from_user.first_name
+
+    if not user_id:
+        await m.reply_text("Cannot find user to ban")
+        return
+    if user_id == Config.BOT_ID:
+        await m.reply_text("Huh, why would I ban myself?")
+        await m.stop_propagation()
+
+    if user_id in SUPPORT_STAFF:
+        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        LOGGER.info(
+            f"{m.from_user.id} trying to ban {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        await m.stop_propagation()
+
+    if m.reply_to_message and len(m.text.split()) >= 2:
+        reason = m.text.split(None, 2)[1]
+    elif not m.reply_to_message and len(m.text.split()) >= 3:
+        reason = m.text.split(None, 2)[2]
+    else:
+        await m.reply_text("Read /help !!")
+        return
+
+    if not reason:
+        await m.reply_text("You haven't specified a time to ban this user for!")
+        return
+
+    split_reason = reason.split(None, 1)
+    time_val = split_reason[0].lower()
+    reason = split_reason[1] if len(split_reason) > 1 else ""
+
+    bantime = await extract_time(m, time_val)
+
+    if not bantime:
+        return
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = await admin_cache_reload(m, "ban")
+
+    if user_id in admins_group:
+        await m.reply_text(tlang(m, "admin.ban.admin_cannot_ban"))
+        await m.stop_propagation()
+
+    try:
+        LOGGER.info(f"{m.from_user.id} dtbanned {user_id} in {m.chat.id}")
+        await m.chat.ban_member(user_id, until_date=int(bantime))
+        await m.reply_to_message.delete()
+        txt = (tlang(m, "admin.ban.banned_user")).format(
+            admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
+            banned=(await mention_html(user_first_name, user_id)),
+            chat_title=m.chat.title,
+        )
+        txt += f"\n<b>Reason</b>: {reason}" if reason else ""
+        keyboard = InlineKeyboardMarkup(
+            [
+                [
+                    InlineKeyboardButton(
+                        "Unban",
+                        callback_data=f"unban_={user_id}",
+                    ),
+                ],
+            ],
+        )
+        await c.send_animation(chat_id = m.chat.id, animation = BAN_MEDIA, caption = txt,  reply_markup=keyboard, parse_mode="html")
+        # await c.send_message(m.chat.id, txt, reply_markup=keyboard)
+    except ChatAdminRequired:
+        await m.reply_text(tlang(m, "admin.not_admin"))
+    except PeerIdInvalid:
+        await m.reply_text(
+            "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
+        )
+    except UserAdminInvalid:
+        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
+    except RightForbidden:
+        await m.reply_text(tlang(m, tlang(m, "admin.ban.bot_no_right")))
+    except RPCError as ef:
+        await m.reply_text(
+            (tlang(m, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=ef,
+            ),
+        )
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+    return
+
+
+@Gojo.on_message(command("kick") & restrict_filter)
+async def kick_usr(c: Gojo, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text(tlang(m, "admin.kick.no_target"))
+        return
+
+    reason = None
+
+    if m.reply_to_message:
+        r_id = m.reply_to_message.message_id
+        if len(m.text.split()) >= 2:
+            reason = m.text.split(None, 1)[1]
+    else:
+        r_id = m.message_id
+        if len(m.text.split()) >= 3:
+            reason = m.text.split(None, 2)[2]
+    try:
+        user_id, user_first_name, _ = await extract_user(c, m)
+    except Exception:
+        return
+
+    if not user_id:
+        await m.reply_text("Cannot find user to kick")
+        return
+
+    if user_id == Config.BOT_ID:
+        await m.reply_text("Huh, why would I kick myself?")
+        await m.stop_propagation()
+
+    if user_id in SUPPORT_STAFF:
+        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        LOGGER.info(
+            f"{m.from_user.id} trying to kick {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        await m.stop_propagation()
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = await admin_cache_reload(m, "kick")
+
+    if user_id in admins_group:
+        await m.reply_text(tlang(m, "admin.kick.admin_cannot_kick"))
+        await m.stop_propagation()
+
+    try:
+        LOGGER.info(f"{m.from_user.id} kicked {user_id} in {m.chat.id}")
+        await m.chat.ban_member(user_id)
+        txt = (tlang(m, "admin.kick.kicked_user")).format(
+            admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
+            kicked=(await mention_html(user_first_name, user_id)),
+            chat_title=m.chat.title,
+        )
+        txt += f"\n<b>Reason</b>: {reason}" if reason else ""
+       # await m.reply_text(txt, reply_to_message_id=r_id)
+        await m.reply_animation(reply_to_message_id = r_id, animation = KICK_MEDIA, caption = txt,  parse_mode="html")
+        await m.chat.unban_member(user_id)
+    except ChatAdminRequired:
+        await m.reply_text(tlang(m, "admin.not_admin"))
+    except PeerIdInvalid:
+        await m.reply_text(
+            "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
+        )
+    except UserAdminInvalid:
+        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
+    except RightForbidden:
+        await m.reply_text(tlang(m, "admin.kick.bot_no_right"))
+    except RPCError as ef:
+        await m.reply_text(
+            (tlang(m, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=ef,
+            ),
+        )
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+
+    return
+
+
+@Gojo.on_message(command("skick") & restrict_filter)
+async def skick_usr(c: Gojo, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text(tlang(m, "admin.kick.no_target"))
+        return
+
+    try:
+        user_id, _, _ = await extract_user(c, m)
+    except Exception:
+        return
+
+    if not user_id:
+        await m.reply_text("Cannot find user to kick")
+        return
+
+    if user_id == Config.BOT_ID:
+        await m.reply_text("Huh, why would I kick myself?")
+        await m.stop_propagation()
+
+    if user_id in SUPPORT_STAFF:
+        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        LOGGER.info(
+            f"{m.from_user.id} trying to skick {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        await m.stop_propagation()
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = await admin_cache_reload(m, "kick")
+
+    if user_id in admins_group:
+        await m.reply_text(tlang(m, "admin.kick.admin_cannot_kick"))
+        await m.stop_propagation()
+
+    try:
+        LOGGER.info(f"{m.from_user.id} skicked {user_id} in {m.chat.id}")
+        await m.chat.ban_member(user_id)
+        await m.delete()
+        if m.reply_to_message:
+            await m.reply_to_message.delete()
+        await m.chat.unban_member(user_id)
+    except ChatAdminRequired:
+        await m.reply_text(tlang(m, "admin.not_admin"))
+    except PeerIdInvalid:
+        await m.reply_text(
+            "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
+        )
+    except UserAdminInvalid:
+        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
+    except RightForbidden:
+        await m.reply_text(tlang(m, "admin.kick.bot_no_right"))
+    except RPCError as ef:
+        await m.reply_text(
+            (tlang(m, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=ef,
+            ),
+        )
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+
+    return
+
+
+@Gojo.on_message(command("dkick") & restrict_filter)
+async def dkick_usr(c: Gojo, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text(tlang(m, "admin.kick.no_target"))
+        return
+    if not m.reply_to_message:
+        return await m.reply_text("Reply to a message to delete it and kick the user!")
+
+    reason = None
+
+    user_id = m.reply_to_message.from_user.id
+    user_first_name = m.reply_to_message.from_user.first_name
+
+    if not user_id:
+        await m.reply_text("Cannot find user to kick")
+        return
+
+    if user_id == Config.BOT_ID:
+        await m.reply_text("Huh, why would I kick myself?")
+        await m.stop_propagation()
+
+    if user_id in SUPPORT_STAFF:
+        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        LOGGER.info(
+            f"{m.from_user.id} trying to dkick {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        await m.stop_propagation()
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = await admin_cache_reload(m, "kick")
+
+    if user_id in admins_group:
+        await m.reply_text(tlang(m, "admin.kick.admin_cannot_kick"))
+        await m.stop_propagation()
+
+    try:
+        LOGGER.info(f"{m.from_user.id} dkicked {user_id} in {m.chat.id}")
+        await m.reply_to_message.delete()
+        await m.chat.ban_member(user_id)
+        txt = (tlang(m, "admin.kick.kicked_user")).format(
+            admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
+            kicked=(await mention_html(user_first_name, user_id)),
+            chat_title=m.chat.title,
+        )
+        txt += f"\n<b>Reason</b>: {reason}" if reason else ""
+        await c.send_message(m.chat.id, txt)
+        await c.send_animation(chat_id = m.chat.id, animation = KICK_MEDIA, caption = txt,  parse_mode="html")
+        await m.chat.unban_member(user_id)
+    except ChatAdminRequired:
+        await m.reply_text(tlang(m, "admin.not_admin"))
+    except PeerIdInvalid:
+        await m.reply_text(
+            "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
+        )
+    except UserAdminInvalid:
+        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
+    except RightForbidden:
+        await m.reply_text(tlang(m, "admin.kick.bot_no_right"))
+    except RPCError as ef:
+        await m.reply_text(
+            (tlang(m, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=ef,
+            ),
+        )
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+
+    return
+
+
+@Gojo.on_message(command("unban") & restrict_filter)
+async def unban_usr(c: Gojo, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text(tlang(m, "admin.unban.no_target"))
+        await m.stop_propagation()
+
+    if m.reply_to_message and not m.reply_to_message.from_user:
+        user_id, user_first_name = (
+            m.reply_to_message.sender_chat.id,
+            m.reply_to_message.sender_chat.title,
+        )
+    else:
+        try:
+            user_id, user_first_name, _ = await extract_user(c, m)
+        except Exception:
+            return
+
+    if m.reply_to_message and len(m.text.split()) >= 2:
+        reason = m.text.split(None, 2)[1]
+    elif not m.reply_to_message and len(m.text.split()) >= 3:
+        reason = m.text.split(None, 2)[2]
+    else:
+        reason = None
+
+    try:
+        await m.chat.unban_member(user_id)
+        txt = (tlang(m, "admin.unban.unbanned_user")).format(
+            admin=m.from_user.mention,
+            unbanned=(await mention_html(user_first_name, user_id)),
+            chat_title=m.chat.title,
+        )
+        txt += f"\n<b>Reason</b>: {reason}" if reason else ""
+        await m.reply_text(txt)
+    except ChatAdminRequired:
+        await m.reply_text(tlang(m, "admin.not_admin"))
+    except RightForbidden:
+        await m.reply_text(tlang(m, tlang(m, "admin.unban.bot_no_right")))
+    except RPCError as ef:
+        await m.reply_text(
+            (tlang(m, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=ef,
+            ),
+        )
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+
+    return
+
+
+@Gojo.on_message(command("sban") & restrict_filter)
+async def sban_usr(c: Gojo, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text(tlang(m, "admin.ban.no_target"))
+        await m.stop_propagation()
+
+    if m.reply_to_message and not m.reply_to_message.from_user:
+        user_id = m.reply_to_message.sender_chat.id
+    else:
+        try:
+            user_id, _, _ = await extract_user(c, m)
+        except Exception:
+            return
+
+    if not user_id:
+        await m.reply_text("Cannot find user to ban")
+        return
+    if user_id == m.chat.id:
+        await m.reply_text("That's an admin!")
+        await m.stop_propagation()
+    if user_id == Config.BOT_ID:
+        await m.reply_text("Huh, why would I ban myself?")
+        await m.stop_propagation()
+
+    if user_id in SUPPORT_STAFF:
+        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        LOGGER.info(
+            f"{m.from_user.id} trying to sban {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        await m.stop_propagation()
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = await admin_cache_reload(m, "ban")
+
+    if user_id in admins_group:
+        await m.reply_text(tlang(m, "admin.ban.admin_cannot_ban"))
+        await m.stop_propagation()
+
+    try:
+        LOGGER.info(f"{m.from_user.id} sbanned {user_id} in {m.chat.id}")
+        await m.chat.ban_member(user_id)
+        await m.delete()
+        if m.reply_to_message:
+            await m.reply_to_message.delete()
+    except ChatAdminRequired:
+        await m.reply_text(tlang(m, "admin.not_admin"))
+    except PeerIdInvalid:
+        await m.reply_text(
+            "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
+        )
+    except UserAdminInvalid:
+        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
+    except RightForbidden:
+        await m.reply_text(tlang(m, tlang(m, "admin.ban.bot_no_right")))
+    except RPCError as ef:
+        await m.reply_text(
+            (tlang(m, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=ef,
+            ),
+        )
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+    return
+
+
+@Gojo.on_message(command("dban") & restrict_filter)
+async def dban_usr(c: Gojo, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text(tlang(m, "admin.ban.no_target"))
+        await m.stop_propagation()
+
+    if not m.reply_to_message:
+        return await m.reply_text("Reply to a message to delete it and ban the user!")
+
+    if m.reply_to_message and not m.reply_to_message.from_user:
+        user_id, user_first_name = (
+            m.reply_to_message.sender_chat.id,
+            m.reply_to_message.sender_chat.title,
+        )
+    else:
+        user_id, user_first_name = (
+            m.reply_to_message.from_user.id,
+            m.reply_to_message.from_user.first_name,
+        )
+
+    if not user_id:
+        await m.reply_text("Cannot find user to ban")
+        return
+    if user_id == m.chat.id:
+        await m.reply_text("That's an admin!")
+        await m.stop_propagation()
+    if user_id == Config.BOT_ID:
+        await m.reply_text("Huh, why would I ban myself?")
+        await m.stop_propagation()
+
+    if user_id in SUPPORT_STAFF:
+        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        LOGGER.info(
+            f"{m.from_user.id} trying to dban {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        await m.stop_propagation()
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = await admin_cache_reload(m, "ban")
+
+    if user_id in admins_group:
+        await m.reply_text(tlang(m, "admin.ban.admin_cannot_ban"))
+        await m.stop_propagation()
+
+    reason = None
+    if len(m.text.split()) >= 2:
+        reason = m.text.split(None, 1)[1]
+
+    try:
+        LOGGER.info(f"{m.from_user.id} dbanned {user_id} in {m.chat.id}")
+        await m.reply_to_message.delete()
+        await m.chat.ban_member(user_id)
+        txt = (tlang(m, "admin.ban.banned_user")).format(
+            admin=m.from_user.mention,
+            banned=m.reply_to_message.from_user.mention,
+            chat_title=m.chat.title,
+        )
+        txt += f"\n<b>Reason</b>: {reason}" if reason else ""
+        keyboard = InlineKeyboardMarkup(
+            [
+                [
+                    InlineKeyboardButton(
+                        "Unban",
+                        callback_data=f"unban_={user_id}",
+                    ),
+                ],
+            ],
+        )
+        await c.send_message(m.chat.id, txt, reply_markup=keyboard)
+    except ChatAdminRequired:
+        await m.reply_text(tlang(m, "admin.not_admin"))
+    except PeerIdInvalid:
+        await m.reply_text(
+            "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
+        )
+    except UserAdminInvalid:
+        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
+    except RightForbidden:
+        await m.reply_text(tlang(m, tlang(m, "admin.ban.bot_no_right")))
+    except RPCError as ef:
+        await m.reply_text(
+            (tlang(m, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=ef,
+            ),
+        )
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+    return
+
+
+@Gojo.on_message(command("ban") & restrict_filter)
+async def ban_usr(c: Gojo, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text(tlang(m, "admin.ban.no_target"))
+        await m.stop_propagation()
+
+    if m.reply_to_message and not m.reply_to_message.from_user:
+        user_id, user_first_name = (
+            m.reply_to_message.sender_chat.id,
+            m.reply_to_message.sender_chat.title,
+        )
+    else:
+        try:
+            user_id, user_first_name, _ = await extract_user(c, m)
+        except Exception:
+            return
+
+    if not user_id:
+        await m.reply_text("Cannot find user to ban")
+        await m.stop_propagation()
+    if user_id == m.chat.id:
+        await m.reply_text("That's an admin!")
+        await m.stop_propagation()
+    if user_id == Config.BOT_ID:
+        await m.reply_text("Huh, why would I ban myself?")
+        await m.stop_propagation()
+
+    if user_id in SUPPORT_STAFF:
+        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        LOGGER.info(
+            f"{m.from_user.id} trying to ban {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        await m.stop_propagation()
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = await admin_cache_reload(m, "ban")
+
+    if user_id in admins_group:
+        await m.reply_text(tlang(m, "admin.ban.admin_cannot_ban"))
+        await m.stop_propagation()
+
+    reason = None
+    if m.reply_to_message:
+        r_id = m.reply_to_message.message_id
+        if len(m.text.split()) >= 2:
+            reason = m.text.split(None, 1)[1]
+    else:
+        r_id = m.message_id
+        if len(m.text.split()) >= 3:
+            reason = m.text.split(None, 2)[2]
+
+    try:
+        LOGGER.info(f"{m.from_user.id} banned {user_id} in {m.chat.id}")
+        await m.chat.ban_member(user_id)
+        txt = (tlang(m, "admin.ban.banned_user")).format(
+            admin=m.from_user.mention,
+            banned=(await mention_html(user_first_name, user_id)),
+            chat_title=m.chat.title,
+        )
+        txt += f"\n<b>Reason</b>: {reason}" if reason else ""
+        keyboard = InlineKeyboardMarkup(
+            [
+                [
+                    InlineKeyboardButton(
+                        "Unban",
+                        callback_data=f"unban_={user_id}",
+                    ),
+                ],
+            ],
+        )
+        await m.reply_text(txt, reply_markup=keyboard, reply_to_message_id=r_id)
+    except ChatAdminRequired:
+        await m.reply_text(tlang(m, "admin.not_admin"))
+    except PeerIdInvalid:
+        await m.reply_text(
+            "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
+        )
+    except UserAdminInvalid:
+        await m.reply_text(tlang(m, "admin.user_admin_invalid"))
+    except RightForbidden:
+        await m.reply_text(tlang(m, tlang(m, "admin.ban.bot_no_right")))
+    except RPCError as ef:
+        await m.reply_text(
+            (tlang(m, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=ef,
+            ),
+        )
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+    return
+
+
+@Gojo.on_callback_query(regex("^unban_"))
+async def unbanbutton(c: Gojo, q: CallbackQuery):
+    splitter = (str(q.data).replace("unban_", "")).split("=")
+    user_id = int(splitter[1])
+    user = await q.message.chat.get_member(q.from_user.id)
+
+    if not user.can_restrict_members and q.from_user.id != OWNER_ID:
+        await q.answer(
+            "You don't have enough permission to do this!\nStay in your limits!",
+            show_alert=True,
+        )
+        return
+    whoo = await c.get_chat(user_id)
+    doneto = whoo.first_name if whoo.first_name else whoo.title
+    try:
+        await q.message.chat.unban_member(user_id)
+    except RPCError as e:
+        await q.message.edit_text(f"Error: {e}")
+        return
+    await q.message.edit_text(f"{q.from_user.mention} unbanned {doneto}!")
+    return
+
+
+@Gojo.on_message(command("kickme"))
+async def kickme(_, m: Message):
+    reason = None
+    if len(m.text.split()) >= 2:
+        reason = m.text.split(None, 1)[1]
+    try:
+        LOGGER.info(f"{m.from_user.id} kickme used by {m.from_user.id} in {m.chat.id}")
+        await m.chat.ban_member(m.from_user.id)
+        txt = "Why not let me help you!"
+        txt += f"\n<b>Reason</b>: {reason}" if reason else ""
+        await m.reply_text(txt)
+        await m.chat.unban_member(m.from_user.id)
+    except RPCError as ef:
+        await m.reply_text(
+            (tlang(m, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=ef,
+            ),
+        )
+    return
+
+
+__PLUGIN__ = "bans"
+
+_DISABLE_CMDS_ = ["kickme"]
+
+__alt_name__ = [
+    "ban",
+    "unban",
+    "kickme",
+    "kick",
+    "tban",
+]

Powers/plugins/blacklist.py

@@ -0,0 +1,218 @@
+from html import escape
+
+from pyrogram import filters
+from pyrogram.types import CallbackQuery, Message
+
+from Powers import LOGGER
+from Powers.bot_class import Gojo
+from Powers.database.blacklist_db import Blacklist
+from Powers.tr_engine import tlang
+from Powers.utils.custom_filters import command, owner_filter, restrict_filter
+from Powers.utils.kbhelpers import ikb
+
+
+@Gojo.on_message(command("blacklist") & filters.group)
+async def view_blacklist(_, m: Message):
+    db = Blacklist(m.chat.id)
+
+    LOGGER.info(f"{m.from_user.id} checking blacklists in {m.chat.id}")
+
+    chat_title = m.chat.title
+    blacklists_chat = (tlang(m, "blacklist.curr_blacklist_initial")).format(
+        chat_title=chat_title,
+    )
+    all_blacklisted = db.get_blacklists()
+
+    if not all_blacklisted:
+        await m.reply_text(
+            (tlang(m, "blacklist.no_blacklist")).format(
+                chat_title=chat_title,
+            ),
+        )
+        return
+
+    blacklists_chat += "\n".join(
+        f" • <code>{escape(i)}</code>" for i in all_blacklisted
+    )
+
+    await m.reply_text(blacklists_chat)
+    return
+
+
+@Gojo.on_message(command("addblacklist") & restrict_filter)
+async def add_blacklist(_, m: Message):
+    db = Blacklist(m.chat.id)
+
+    if len(m.text.split()) < 2:
+        await m.reply_text(tlang(m, "general.check_help"))
+        return
+
+    bl_words = ((m.text.split(None, 1)[1]).lower()).split()
+    all_blacklisted = db.get_blacklists()
+    already_added_words, rep_text = [], ""
+
+    for bl_word in bl_words:
+        if bl_word in all_blacklisted:
+            already_added_words.append(bl_word)
+            continue
+        db.add_blacklist(bl_word)
+
+    if already_added_words:
+        rep_text = (
+            ", ".join([f"<code>{i}</code>" for i in bl_words])
+            + " already added in blacklist, skipped them!"
+        )
+    LOGGER.info(f"{m.from_user.id} added new blacklists ({bl_words}) in {m.chat.id}")
+    await m.reply_text(
+        (tlang(m, "blacklist.added_blacklist")).format(
+            trigger=", ".join(f"<code>{i}</code>" for i in bl_words),
+        )
+        + (f"\n{rep_text}" if rep_text else ""),
+    )
+
+    await m.stop_propagation()
+
+
+@Gojo.on_message(
+    command(["blwarning", "blreason", "blacklistreason"]) & restrict_filter,
+)
+async def blacklistreason(_, m: Message):
+    db = Blacklist(m.chat.id)
+
+    if len(m.text.split()) == 1:
+        curr = db.get_reason()
+        await m.reply_text(
+            f"The current reason for blacklists warn is:\n<code>{curr}</code>",
+        )
+    else:
+        reason = m.text.split(None, 1)[1]
+        db.set_reason(reason)
+        await m.reply_text(
+            f"Updated reason for blacklists warn is:\n<code>{reason}</code>",
+        )
+    return
+
+
+@Gojo.on_message(
+    command(["rmblacklist", "unblacklist"]) & restrict_filter,
+)
+async def rm_blacklist(_, m: Message):
+    db = Blacklist(m.chat.id)
+
+    if len(m.text.split()) < 2:
+        await m.reply_text(tlang(m, "general.check_help"))
+        return
+
+    chat_bl = db.get_blacklists()
+    non_found_words, rep_text = [], ""
+    bl_words = ((m.text.split(None, 1)[1]).lower()).split()
+
+    for bl_word in bl_words:
+        if bl_word not in chat_bl:
+            non_found_words.append(bl_word)
+            continue
+        db.remove_blacklist(bl_word)
+
+    if non_found_words == bl_words:
+        return await m.reply_text("Blacklists not found!")
+
+    if non_found_words:
+        rep_text = (
+            "Could not find " + ", ".join(f"<code>{i}</code>" for i in non_found_words)
+        ) + " in blcklisted words, skipped them."
+
+    LOGGER.info(f"{m.from_user.id} removed blacklists ({bl_words}) in {m.chat.id}")
+    await m.reply_text(
+        (tlang(m, "blacklist.rm_blacklist")).format(
+            bl_words=", ".join(f"<code>{i}</code>" for i in bl_words),
+        )
+        + (f"\n{rep_text}" if rep_text else ""),
+    )
+
+    await m.stop_propagation()
+
+
+@Gojo.on_message(
+    command(["blaction", "blacklistaction", "blacklistmode"]) & restrict_filter,
+)
+async def set_bl_action(_, m: Message):
+    db = Blacklist(m.chat.id)
+
+    if len(m.text.split()) == 2:
+        action = m.text.split(None, 1)[1]
+        valid_actions = ("ban", "kick", "mute", "warn", "none")
+        if action not in valid_actions:
+            await m.reply_text(
+                (
+                    "Choose a valid blacklist action from "
+                    + ", ".join(f"<code>{i}</code>" for i in valid_actions)
+                ),
+            )
+
+            return
+        db.set_action(action)
+        LOGGER.info(
+            f"{m.from_user.id} set blacklist action to '{action}' in {m.chat.id}",
+        )
+        await m.reply_text(
+            (tlang(m, "blacklist.action_set")).format(action=action),
+        )
+    elif len(m.text.split()) == 1:
+        action = db.get_action()
+        LOGGER.info(f"{m.from_user.id} checking blacklist action in {m.chat.id}")
+        await m.reply_text(
+            (tlang(m, "blacklist.action_get")).format(action=action),
+        )
+    else:
+        await m.reply_text(tlang(m, "general.check_help"))
+
+    return
+
+
+@Gojo.on_message(
+    command("rmallblacklist") & owner_filter,
+)
+async def rm_allblacklist(_, m: Message):
+    db = Blacklist(m.chat.id)
+
+    all_bls = db.get_blacklists()
+    if not all_bls:
+        await m.reply_text("No notes are blacklists in this chat")
+        return
+
+    await m.reply_text(
+        "Are you sure you want to clear all blacklists?",
+        reply_markup=ikb(
+            [[("⚠️ Confirm", "rm_allblacklist"), ("❌ Cancel", "close_admin")]],
+        ),
+    )
+    return
+
+
+@Gojo.on_callback_query(filters.regex("^rm_allblacklist$"))
+async def rm_allbl_callback(_, q: CallbackQuery):
+    user_id = q.from_user.id
+    db = Blacklist(q.message.chat.id)
+    user_status = (await q.message.chat.get_member(user_id)).status
+    if user_status not in {"creator", "administrator"}:
+        await q.answer(
+            "You're not even an admin, don't try this explosive shit!",
+            show_alert=True,
+        )
+        return
+    if user_status != "creator":
+        await q.answer(
+            "You're just an admin, not owner\nStay in your limits!",
+            show_alert=True,
+        )
+        return
+    db.rm_all_blacklist()
+    await q.message.delete()
+    LOGGER.info(f"{user_id} removed all blacklists in {q.message.chat.id}")
+    await q.answer("Cleared all Blacklists!", show_alert=True)
+    return
+
+
+__PLUGIN__ = "blacklist"
+
+__alt_name__ = ["blacklists", "blaction"]

Powers/plugins/botstaff.py

@@ -0,0 +1,54 @@
+from pyrogram.errors import RPCError
+from pyrogram.types import Message
+
+from Powers import DEV_USERS, LOGGER, OWNER_ID, SUDO_USERS, WHITELIST_USERS
+from Powers.bot_class import Gojo
+from Powers.utils.custom_filters import command
+from Powers.utils.parser import mention_html
+
+
+@Gojo.on_message(command("botstaff", dev_cmd=True))
+async def botstaff(c: Gojo, m: Message):
+    try:
+        owner = await c.get_users(OWNER_ID)
+        reply = f"<b>🌟 Owner:</b> {(await mention_html(owner.first_name, OWNER_ID))} (<code>{OWNER_ID}</code>)\n"
+    except RPCError:
+        pass
+    true_dev = list(set(DEV_USERS) - {OWNER_ID})
+    reply += "\n<b>Developers ⚡️:</b>\n"
+    if true_dev == []:
+        reply += "No Dev Users\n"
+    else:
+        for each_user in true_dev:
+            user_id = int(each_user)
+            try:
+                user = await c.get_users(user_id)
+                reply += f"• {(await mention_html(user.first_name, user_id))} (<code>{user_id}</code>)\n"
+            except RPCError:
+                pass
+    true_sudo = list(set(SUDO_USERS) - set(DEV_USERS))
+    reply += "\n<b>Sudo Users 🐉:</b>\n"
+    if true_sudo == []:
+        reply += "No Sudo Users\n"
+    else:
+        for each_user in true_sudo:
+            user_id = int(each_user)
+            try:
+                user = await c.get_users(user_id)
+                reply += f"• {(await mention_html(user.first_name, user_id))} (<code>{user_id}</code>)\n"
+            except RPCError:
+                pass
+    reply += "\n<b>Whitelisted Users 🐺:</b>\n"
+    if WHITELIST_USERS == []:
+        reply += "No additional whitelisted users\n"
+    else:
+        for each_user in WHITELIST_USERS:
+            user_id = int(each_user)
+            try:
+                user = await c.get_users(user_id)
+                reply += f"• {(await mention_html(user.first_name, user_id))} (<code>{user_id}</code>)\n"
+            except RPCError:
+                pass
+    await m.reply_text(reply)
+    LOGGER.info(f"{m.from_user.id} fetched botstaff in {m.chat.id}")
+    return

Powers/plugins/chat_blacklist.py

@@ -0,0 +1,86 @@
+from traceback import format_exc
+
+from pyrogram.errors import PeerIdInvalid, RPCError
+from pyrogram.types import Message
+
+from Powers import LOGGER
+from Powers.bot_class import Gojo
+from Powers.database.group_blacklist import GroupBlacklist
+from Powers.utils.custom_filters import command
+
+# initialise database
+db = GroupBlacklist()
+
+
+@Gojo.on_message(command("blchat", dev_cmd=True))
+async def blacklist_chat(c: Gojo, m: Message):
+    if len(m.text.split()) >= 2:
+        chat_ids = m.text.split()[1:]
+        replymsg = await m.reply_text(f"Adding {len(chat_ids)} chats to blacklist")
+        LOGGER.info(f"{m.from_user.id} blacklisted {chat_ids} groups for bot")
+        for chat in chat_ids:
+            try:
+                get_chat = await c.get_chat(chat)
+                chat_id = get_chat.id
+                db.add_chat(chat_id)
+            except PeerIdInvalid:
+                await replymsg.edit_text(
+                    "Haven't seen this group in this session, maybe try again later?",
+                )
+            except RPCError as ef:
+                LOGGER.error(ef)
+                LOGGER.error(format_exc())
+        await replymsg.edit_text(
+            f"Added the following chats to Blacklist.\n<code>{', '.join(chat_ids)}</code>.",
+        )
+    return
+
+
+@Gojo.on_message(
+    command(["rmblchat", "unblchat"], dev_cmd=True),
+)
+async def unblacklist_chat(c: Gojo, m: Message):
+    if len(m.text.split()) >= 2:
+        chat_ids = m.text.split()[1:]
+        replymsg = await m.reply_text(f"Removing {len(chat_ids)} chats from blacklist")
+        LOGGER.info(f"{m.from_user.id} removed blacklisted {chat_ids} groups for bot")
+        bl_chats = db.list_all_chats()
+        for chat in chat_ids:
+            try:
+                get_chat = await c.get_chat(chat)
+                chat_id = get_chat.id
+                if chat_id not in bl_chats:
+                    # If chat is not blaklisted, continue loop
+                    continue
+                db.remove_chat(chat_id)
+            except PeerIdInvalid:
+                await replymsg.edit_text(
+                    "Haven't seen this group in this session, maybe try again later?",
+                )
+            except RPCError as ef:
+                LOGGER.error(ef)
+                LOGGER.error(format_exc())
+        await replymsg.edit_text(
+            f"Removed the following chats to Blacklist.\n<code>{', '.join(chat_ids)}</code>.",
+        )
+    return
+
+
+@Gojo.on_message(
+    command(["blchatlist", "blchats"], dev_cmd=True),
+)
+async def list_blacklist_chats(_, m: Message):
+    bl_chats = db.list_all_chats()
+    LOGGER.info(f"{m.from_user.id} checking group blacklists in {m.chat.id}")
+    if bl_chats:
+        txt = (
+            (
+                "These Chats are Blacklisted:\n"
+                + "\n".join(f"<code>{i}</code>" for i in bl_chats)
+            ),
+        )
+
+    else:
+        txt = "No chats are currently blacklisted!"
+    await m.reply_text(txt)
+    return

Powers/plugins/dev.py

@@ -0,0 +1,360 @@
+import sys
+from asyncio import create_subprocess_shell, sleep, subprocess
+from io import BytesIO, StringIO
+from time import gmtime, strftime, time
+from traceback import format_exc
+
+from pyrogram.errors import (
+    ChannelInvalid,
+    ChannelPrivate,
+    ChatAdminRequired,
+    FloodWait,
+    MessageTooLong,
+    PeerIdInvalid,
+    RPCError,
+)
+from pyrogram.types import Message
+from speedtest import Speedtest
+
+from Powers import LOGFILE, LOGGER, MESSAGE_DUMP, UPTIME
+from Powers.bot_class import Gojo
+from Powers.database.chats_db import Chats
+from Powers.tr_engine import tlang
+from Powers.utils.clean_file import remove_markdown_and_html
+from Powers.utils.custom_filters import command
+from Powers.utils.http_helper import HTTPx
+from Powers.utils.kbhelpers import ikb
+from Powers.utils.parser import mention_markdown
+from Powers.vars import Config
+
+
+@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}")
+    start = time()
+    replymsg = await m.reply_text((tlang(m, "utils.ping.pinging")), quote=True)
+    delta_ping = time() - start
+    await replymsg.edit_text(f"<b>Pong!</b>\n{delta_ping * 1000:.3f} ms")
+    return
+
+
+@Gojo.on_message(command("logs", dev_cmd=True))
+async def send_log(c: Gojo, m: Message):
+    replymsg = await m.reply_text("Sending logs...!")
+    await c.send_message(
+        MESSAGE_DUMP,
+        f"#LOGS\n\n**User:** {(await mention_markdown(m.from_user.first_name, m.from_user.id))}",
+    )
+    # Send logs
+    with open(LOGFILE) as f:
+        raw = (await (f.read()))[1]
+    await m.reply_document(
+        document=LOGFILE,
+        quote=True,
+    )
+    await replymsg.delete()
+    return
+
+
+@Gojo.on_message(command("ginfo", sudo_cmd=True))
+async def group_info(c: Gojo, m: Message):
+    if len(m.text.split()) != 2:
+        await m.reply_text(
+            f"It works like this: <code>{Config.PREFIX_HANDLER} chat_id</code>",
+        )
+        return
+
+    chat_id = m.text.split(None, 1)[1]
+
+    replymsg = await m.reply_text("Fetching info about group...!")
+    grp_data = await c.get_chat(chat_id)
+    msg = (
+        f"Information for group: {chat_id}\n\n"
+        f"Group Name: {grp_data['title']}\n"
+        f"Members Count: {grp_data['members_count']}\n"
+        f"Type: {grp_data['type']}\n"
+        f"Group ID: {grp_data['id']}"
+    )
+    await replymsg.edit_text(msg)
+    return
+
+
+@Gojo.on_message(command("speedtest", dev_cmd=True))
+async def test_speed(c: Gojo, m: Message):
+    await c.send_message(
+        MESSAGE_DUMP,
+        f"#SPEEDTEST\n\n**User:** {(await mention_markdown(m.from_user.first_name, m.from_user.id))}",
+    )
+    sent = await m.reply_text(tlang(m, "dev.speedtest.start_speedtest"))
+    s = Speedtest()
+    bs = s.get_best_server()
+    dl = round(s.download() / 1024 / 1024, 2)
+    ul = round(s.upload() / 1024 / 1024, 2)
+    await sent.edit_text(
+        (tlang(m, "dev.speedtest.speedtest_txt")).format(
+            host=bs["sponsor"],
+            ping=int(bs["latency"]),
+            download=dl,
+            upload=ul,
+        ),
+    )
+    return
+
+
+@Gojo.on_message(command("neofetch", dev_cmd=True))
+async def neofetch_stats(_, m: Message):
+    cmd = "neofetch --stdout"
+
+    process = await create_subprocess_shell(
+        cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    stdout, stderr = await process.communicate()
+    e = stderr.decode()
+    if not e:
+        e = "No Error"
+    OUTPUT = stdout.decode()
+    if not OUTPUT:
+        OUTPUT = "No Output"
+
+    try:
+        await m.reply_text(OUTPUT, quote=True)
+    except MessageTooLong:
+        with BytesIO(str.encode(await remove_markdown_and_html(OUTPUT))) as f:
+            f.name = "neofetch.txt"
+            await m.reply_document(document=f, caption="neofetch result")
+        await m.delete()
+    return
+
+
+@Gojo.on_message(command(["eval", "py"], dev_cmd=True))
+async def evaluate_code(c: Gojo, m: Message):
+    if len(m.text.split()) == 1:
+        await m.reply_text(tlang(m, "dev.execute_cmd_err"))
+        return
+    sm = await m.reply_text("`Processing...`")
+    cmd = m.text.split(None, maxsplit=1)[1]
+
+    reply_to_id = m.message_id
+    if m.reply_to_message:
+        reply_to_id = m.reply_to_message.message_id
+
+    old_stderr = sys.stderr
+    old_stdout = sys.stdout
+    redirected_output = sys.stdout = StringIO()
+    redirected_error = sys.stderr = StringIO()
+    stdout, stderr, exc = None, None, None
+
+    try:
+        await aexec(cmd, c, m)
+    except Exception as ef:
+        LOGGER.error(ef)
+        exc = format_exc()
+
+    stdout = redirected_output.getvalue()
+    stderr = redirected_error.getvalue()
+    sys.stdout = old_stdout
+    sys.stderr = old_stderr
+
+    evaluation = ""
+    if exc:
+        evaluation = exc
+    elif stderr:
+        evaluation = stderr
+    elif stdout:
+        evaluation = stdout
+    else:
+        evaluation = "Success"
+
+    final_output = f"<b>EVAL</b>: <code>{cmd}</code>\n\n<b>OUTPUT</b>:\n<code>{evaluation.strip()}</code> \n"
+
+    try:
+        await sm.edit(final_output)
+    except MessageTooLong:
+        with BytesIO(str.encode(await remove_markdown_and_html(final_output))) as f:
+            f.name = "py.txt"
+            await m.reply_document(
+                document=f,
+                caption=cmd,
+                disable_notification=True,
+                reply_to_message_id=reply_to_id,
+            )
+        await sm.delete()
+
+    return
+
+
+async def aexec(code, c, m):
+    exec("async def __aexec(c, m): " + "".join(f"\n {l}" for l in code.split("\n")))
+    return await locals()["__aexec"](c, m)
+
+
+@Gojo.on_message(command(["exec", "sh"], dev_cmd=True))
+async def execution(_, m: Message):
+    if len(m.text.split()) == 1:
+        await m.reply_text(tlang(m, "dev.execute_cmd_err"))
+        return
+    sm = await m.reply_text("`Processing...`")
+    cmd = m.text.split(maxsplit=1)[1]
+    reply_to_id = m.message_id
+    if m.reply_to_message:
+        reply_to_id = m.reply_to_message.message_id
+
+    process = await create_subprocess_shell(
+        cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    stdout, stderr = await process.communicate()
+    e = stderr.decode()
+    if not e:
+        e = "No Error"
+    o = stdout.decode()
+    if not o:
+        o = "No Output"
+
+    OUTPUT = ""
+    OUTPUT += f"<b>QUERY:</b>\n<u>Command:</u>\n<code>{cmd}</code> \n"
+    OUTPUT += f"<u>PID</u>: <code>{process.pid}</code>\n\n"
+    OUTPUT += f"<b>stderr</b>: \n<code>{e}</code>\n\n"
+    OUTPUT += f"<b>stdout</b>: \n<code>{o}</code>"
+
+    try:
+        await sm.edit_text(OUTPUT)
+    except MessageTooLong:
+        with BytesIO(str.encode(await remove_markdown_and_html(OUTPUT))) as f:
+            f.name = "sh.txt"
+            await m.reply_document(
+                document=f,
+                caption=cmd,
+                disable_notification=True,
+                reply_to_message_id=reply_to_id,
+            )
+        await sm.delete()
+    return
+
+
+@Gojo.on_message(command("ip", dev_cmd=True))
+async def public_ip(c: Gojo, m: Message):
+    ip = await HTTPx.get("https://api.ipify.org")
+    await c.send_message(
+        MESSAGE_DUMP,
+        f"#IP\n\n**User:** {(await mention_markdown(m.from_user.first_name, m.from_user.id))}",
+    )
+    await m.reply_text(
+        (tlang(m, "dev.bot_ip")).format(ip=f"<code>{ip.text}</code>"),
+        quote=True,
+    )
+    return
+
+
+@Gojo.on_message(command("chatlist", dev_cmd=True))
+async def chats(c: Gojo, m: Message):
+    exmsg = await m.reply_text(tlang(m, "dev.chatlist.exporting"))
+    await c.send_message(
+        MESSAGE_DUMP,
+        f"#CHATLIST\n\n**User:** {(await mention_markdown(m.from_user.first_name, m.from_user.id))}",
+    )
+    all_chats = (Chats.list_chats_full()) or {}
+    chatfile = tlang(m, "dev.chatlist.header")
+    P = 1
+    for chat in all_chats:
+        try:
+            chat_info = await c.get_chat(chat["_id"])
+            chat_members = chat_info.members_count
+            try:
+                invitelink = chat_info.invite_link
+            except KeyError:
+                invitelink = "No Link!"
+            chatfile += f"{P}. {chat['chat_name']} | {chat['_id']} | {chat_members} | {invitelink}\n"
+            P += 1
+        except ChatAdminRequired:
+            pass
+        except (ChannelPrivate, ChannelInvalid):
+            Chats.remove_chat(chat["_id"])
+        except PeerIdInvalid:
+            LOGGER.warning(f"Peer not found {chat['_id']}")
+        except FloodWait as ef:
+            LOGGER.error("FloodWait required, Sleeping for 60s")
+            LOGGER.error(ef)
+            sleep(60)
+        except RPCError as ef:
+            LOGGER.error(ef)
+            await m.reply_text(f"**Error:**\n{ef}")
+
+    with BytesIO(str.encode(await remove_markdown_and_html(chatfile))) as f:
+        f.name = "chatlist.txt"
+        await m.reply_document(
+            document=f,
+            caption=(tlang(m, "dev.chatlist.chats_in_db")),
+        )
+    await exmsg.delete()
+    return
+
+
+@Gojo.on_message(command("uptime", dev_cmd=True))
+async def uptime(_, m: Message):
+    up = strftime("%Hh %Mm %Ss", gmtime(time() - UPTIME))
+    await m.reply_text((tlang(m, "dev.uptime")).format(uptime=up), quote=True)
+    return
+
+
+@Gojo.on_message(command("leavechat", dev_cmd=True))
+async def leave_chat(c: Gojo, m: Message):
+    if len(m.text.split()) != 2:
+        await m.reply_text("Supply a chat id which I should leave!", quoet=True)
+        return
+
+    chat_id = m.text.split(None, 1)[1]
+
+    replymsg = await m.reply_text(f"Trying to leave chat {chat_id}...", quote=True)
+    try:
+        await c.leave_chat(chat_id)
+        await replymsg.edit_text(f"Left <code>{chat_id}</code>.")
+    except PeerIdInvalid:
+        await replymsg.edit_text("Haven't seen this group in this session!")
+    except RPCError as ef:
+        LOGGER.error(ef)
+        await replymsg.edit_text(f"Failed to leave chat!\nError: <code>{ef}</code>.")
+    return
+
+
+@Gojo.on_message(command("chatbroadcast", dev_cmd=True))
+async def chat_broadcast(c: Gojo, m: Message):
+    if m.reply_to_message:
+        msg = m.reply_to_message.text.markdown
+    else:
+        await m.reply_text("Reply to a message to broadcast it")
+        return
+
+    exmsg = await m.reply_text("Started broadcasting!")
+    all_chats = (Chats.list_chats_by_id()) or {}
+    err_str, done_broadcast = "", 0
+
+    for chat in all_chats:
+        try:
+            await c.send_message(chat, msg, disable_web_page_preview=True)
+            done_broadcast += 1
+            await sleep(0.1)
+        except RPCError as ef:
+            LOGGER.error(ef)
+            err_str += str(ef)
+            continue
+
+    await exmsg.edit_text(
+        f"Done broadcasting ✅\nSent message to {done_broadcast} chats",
+    )
+
+    if err_str:
+        with BytesIO(str.encode(await remove_markdown_and_html(err_str))) as f:
+            f.name = "error_broadcast.txt"
+            await m.reply_document(
+                document=f,
+                caption="Broadcast Error",
+            )
+
+    return
+
+
+_DISABLE_CMDS_ = ["ping"]

Powers/plugins/disable.py

@@ -0,0 +1,156 @@
+from html import escape
+
+from pyrogram import filters
+from pyrogram.types import (
+    CallbackQuery,
+    InlineKeyboardButton,
+    InlineKeyboardMarkup,
+    Message,
+)
+
+from Powers import HELP_COMMANDS, LOGGER
+from Powers.bot_class import Gojo
+from Powers.database.disable_db import Disabling
+from Powers.utils.custom_filters import (
+    admin_filter,
+    can_change_filter,
+    command,
+    owner_filter,
+)
+
+
+@Gojo.on_message(command("disable") & can_change_filter)
+async def disableit(_, m: Message):
+    if len(m.text.split()) < 2:
+        return await m.reply_text("What to disable?")
+    disable_cmd_keys = sorted(
+        k
+        for j in [HELP_COMMANDS[i]["disablable"] for i in list(HELP_COMMANDS.keys())]
+        for k in j
+    )
+
+    db = Disabling(m.chat.id)
+    disable_list = db.get_disabled()
+    LOGGER.info(f"{m.from_user.id} used disabled cmd in {m.chat.id}")
+
+    if str(m.text.split(None, 1)[1]) in disable_list:
+        return await m.reply_text("It's already disabled!")
+
+    if str((m.text.split(None, 1)[1]).lower()) in disable_cmd_keys:
+        db.add_disable((str(m.text.split(None, 1)[1])).lower())
+        return await m.reply_text(f"Disabled {m.text.split(None, 1)[1]}!")
+    if str(m.text.split(None, 1)[1]) not in disable_cmd_keys:
+        return await m.reply_text("Can't do it sorry !")
+
+
+@Gojo.on_message(command("disabledel") & can_change_filter)
+async def set_dsbl_action(_, m: Message):
+    db = Disabling(m.chat.id)
+
+    status = db.get_action()
+    if status == "none":
+        cur = False
+    else:
+        cur = True
+    args = m.text.split(" ", 1)
+
+    LOGGER.info(f"{m.from_user.id} disabledel used in {m.chat.id}")
+
+    if len(args) >= 2:
+        if args[1].lower() == "on":
+            db.set_action("del")
+            await m.reply_text("Oke done!")
+        elif args[1].lower() == "off":
+            db.set_action("none")
+            await m.reply_text("Oke i will not delete!")
+        else:
+            await m.reply_text("what are you trying to do ??")
+    else:
+        await m.reply_text(f"Current settings:- {cur}")
+    return
+
+
+@Gojo.on_message(command("enable") & can_change_filter)
+async def enableit(_, m: Message):
+    if len(m.text.split()) < 2:
+        return await m.reply_text("What to enable?")
+    db = Disabling(m.chat.id)
+    disable_list = db.get_disabled()
+    if str(m.text.split(None, 1)[1]) not in disable_list:
+        return await m.reply_text("It's not disabled!")
+    db.remove_disabled((str(m.text.split(None, 1)[1])).lower())
+    LOGGER.info(f"{m.from_user.id} enabled something in {m.chat.id}")
+    return await m.reply_text(f"Enabled {m.text.split(None, 1)[1]}!")
+
+
+@Gojo.on_message(command("disableable") & can_change_filter)
+async def disabling(_, m: Message):
+    disable_cmd_keys = sorted(
+        k
+        for j in [HELP_COMMANDS[i]["disablable"] for i in list(HELP_COMMANDS.keys())]
+        for k in j
+    )
+    tes = "List of commnds that can be disabled:\n"
+    tes += "\n".join(f" • <code>{escape(i)}</code>" for i in disable_cmd_keys)
+    LOGGER.info(f"{m.from_user.id} checked disableable {m.chat.id}")
+    return await m.reply_text(tes)
+
+
+@Gojo.on_message(command("disabled") & admin_filter)
+async def disabled(_, m: Message):
+    db = Disabling(m.chat.id)
+    disable_list = db.get_disabled()
+    if not disable_list:
+        await m.reply_text("No disabled items!")
+        return
+    tex = "Disabled commands:\n"
+    tex += "\n".join(f" • <code>{escape(i)}</code>" for i in disable_list)
+    LOGGER.info(f"{m.from_user.id} checked disabled {m.chat.id}")
+    return await m.reply_text(tex)
+
+
+@Gojo.on_message(command("enableall") & owner_filter)
+async def rm_alldisbl(_, m: Message):
+    db = Disabling(m.chat.id)
+    all_dsbl = db.get_disabled()
+    if not all_dsbl:
+        await m.reply_text("No disabled commands in this chat")
+        return
+    await m.reply_text(
+        "Are you sure you want to enable all?",
+        reply_markup=InlineKeyboardMarkup(
+            [
+                [
+                    InlineKeyboardButton(
+                        "Confirm",
+                        callback_data="enableallcmds",
+                    ),
+                    InlineKeyboardButton("Cancel", callback_data="close_admin"),
+                ],
+            ],
+        ),
+    )
+    return
+
+
+@Gojo.on_callback_query(filters.regex("^enableallcmds$"))
+async def enablealll(_, q: CallbackQuery):
+    user_id = q.from_user.id
+    user_status = (await q.message.chat.get_member(user_id)).status
+    if user_status not in {"creator", "administrator"}:
+        await q.answer(
+            "You're not even an admin, don't try this explosive shit!",
+            show_alert=True,
+        )
+        return
+    if user_status != "creator":
+        await q.answer(
+            "You're just an admin, not owner\nStay in your limits!",
+            show_alert=True,
+        )
+        return
+    db = Disabling(q.message.chat.id)
+    db.rm_all_disabled()
+    LOGGER.info(f"{user_id} enabled all in {q.message.chat.id}")
+    await q.message.edit_text("Enabled all!", show_alert=True)
+    return

Powers/plugins/filters.py

@@ -0,0 +1,301 @@
+from re import escape as re_escape
+from secrets import choice
+from traceback import format_exc
+
+from pyrogram import filters
+from pyrogram.errors import RPCError
+from pyrogram.types import CallbackQuery, InlineKeyboardMarkup, Message
+
+from Powers.bot_class import LOGGER, Gojo
+from Powers.database.filters_db import Filters
+from Powers.utils.cmd_senders import send_cmd
+from Powers.utils.custom_filters import admin_filter, command, owner_filter
+from Powers.utils.kbhelpers import ikb
+from Powers.utils.msg_types import Types, get_filter_type
+from Powers.utils.regex_utils import regex_searcher
+from Powers.utils.string import (
+    build_keyboard,
+    escape_mentions_using_curly_brackets,
+    parse_button,
+    split_quotes,
+)
+
+# Initialise
+db = Filters()
+
+
+@Gojo.on_message(command("filters") & filters.group & ~filters.bot)
+async def view_filters(_, m: Message):
+    LOGGER.info(f"{m.from_user.id} checking filters in {m.chat.id}")
+
+    filters_chat = f"Filters in <b>{m.chat.title}</b>:\n"
+    all_filters = db.get_all_filters(m.chat.id)
+    actual_filters = [j for i in all_filters for j in i.split("|")]
+
+    if not actual_filters:
+        await m.reply_text(f"There are no filters in {m.chat.title}")
+        return
+
+    filters_chat += "\n".join(
+        [
+            f" • {' | '.join([f'<code>{i}</code>' for i in i.split('|')])}"
+            for i in all_filters
+        ],
+    )
+    return await m.reply_text(filters_chat, disable_web_page_preview=True)
+
+
+@Gojo.on_message(command(["filter", "addfilter"]) & admin_filter & ~filters.bot)
+async def add_filter(_, m: Message):
+
+    args = m.text.split(" ", 1)
+    all_filters = db.get_all_filters(m.chat.id)
+    actual_filters = {j for i in all_filters for j in i.split("|")}
+
+    if (len(all_filters) >= 50) and (len(actual_filters) >= 150):
+        await m.reply_text(
+            "Only 50 filters and 150 aliases are allowed per chat!\nTo add more filters, remove the existing ones.",
+        )
+        return
+
+    if not m.reply_to_message and len(m.text.split()) < 3:
+        return await m.reply_text("Please read help section for how to save a filter!")
+
+    if m.reply_to_message and len(args) < 2:
+        return await m.reply_text("Please read help section for how to save a filter!")
+
+    extracted = await split_quotes(args[1])
+    keyword = extracted[0].lower()
+
+    for k in keyword.split("|"):
+        if k in actual_filters:
+            return await m.reply_text(f"Filter <code>{k}</code> already exists!")
+
+    if not keyword:
+        return await m.reply_text(
+            f"<code>{m.text}</code>\n\nError: You must give a name for this Filter!",
+        )
+
+    if keyword.startswith("<") or keyword.startswith(">"):
+        return await m.reply_text("Cannot save a filter which starts with '<' or '>'")
+
+    eee, msgtype, file_id = await get_filter_type(m)
+    lol = eee if m.reply_to_message else extracted[1]
+    teks = lol if msgtype == Types.TEXT else eee
+
+    if not m.reply_to_message and msgtype == Types.TEXT and len(m.text.split()) < 3:
+        return await m.reply_text(
+            f"<code>{m.text}</code>\n\nError: There is no text in here!",
+        )
+
+    if not teks and not msgtype:
+        return await m.reply_text(
+            'Please provide keyword for this filter reply with!\nEnclose filter in <code>"double quotes"</code>',
+        )
+
+    if not msgtype:
+        return await m.reply_text(
+            "Please provide data for this filter reply with!",
+        )
+
+    add = db.save_filter(m.chat.id, keyword, teks, msgtype, file_id)
+    LOGGER.info(f"{m.from_user.id} added new filter ({keyword}) in {m.chat.id}")
+    if add:
+        await m.reply_text(
+            f"Saved filter for '<code>{', '.join(keyword.split('|'))}</code>' in <b>{m.chat.title}</b>!",
+        )
+    await m.stop_propagation()
+
+
+@Gojo.on_message(command(["stop", "unfilter"]) & admin_filter & ~filters.bot)
+async def stop_filter(_, m: Message):
+    args = m.command
+
+    if len(args) < 1:
+        return await m.reply_text("What should I stop replying to?")
+
+    chat_filters = db.get_all_filters(m.chat.id)
+    act_filters = {j for i in chat_filters for j in i.split("|")}
+
+    if not chat_filters:
+        return await m.reply_text("No filters active here!")
+
+    for keyword in act_filters:
+        if keyword == m.text.split(None, 1)[1].lower():
+            db.rm_filter(m.chat.id, m.text.split(None, 1)[1].lower())
+            LOGGER.info(f"{m.from_user.id} removed filter ({keyword}) in {m.chat.id}")
+            await m.reply_text(
+                f"Okay, I'll stop replying to that filter and it's aliases in <b>{m.chat.title}</b>.",
+            )
+            await m.stop_propagation()
+
+    await m.reply_text(
+        "That's not a filter - Click: /filters to get currently active filters.",
+    )
+    await m.stop_propagation()
+
+
+@Gojo.on_message(
+    command(
+        ["rmallfilters", "removeallfilters", "stopall", "stopallfilters"],
+    )
+    & owner_filter,
+)
+async def rm_allfilters(_, m: Message):
+    all_bls = db.get_all_filters(m.chat.id)
+    if not all_bls:
+        return await m.reply_text("No filters to stop in this chat.")
+
+    return await m.reply_text(
+        "Are you sure you want to clear all filters?",
+        reply_markup=ikb(
+            [[("⚠️ Confirm", "rm_allfilters"), ("❌ Cancel", "close_admin")]],
+        ),
+    )
+
+
+@Gojo.on_callback_query(filters.regex("^rm_allfilters$"))
+async def rm_allfilters_callback(_, q: CallbackQuery):
+    user_id = q.from_user.id
+    user_status = (await q.message.chat.get_member(user_id)).status
+    if user_status not in {"creator", "administrator"}:
+        await q.answer(
+            "You're not even an admin, don't try this explosive shit!",
+            show_alert=True,
+        )
+        return
+    if user_status != "creator":
+        await q.answer(
+            "You're just an admin, not owner\nStay in your limits!",
+            show_alert=True,
+        )
+        return
+    db.rm_all_filters(q.message.chat.id)
+    await q.message.edit_text(f"Cleared all filters for {q.message.chat.title}")
+    LOGGER.info(f"{user_id} removed all filter from {q.message.chat.id}")
+    await q.answer("Cleared all Filters!", show_alert=True)
+    return
+
+
+async def send_filter_reply(c: Gojo, m: Message, trigger: str):
+    """Reply with assigned filter for the trigger"""
+    getfilter = db.get_filter(m.chat.id, trigger)
+    if m and not m.from_user:
+        return
+
+    if not getfilter:
+        return await m.reply_text(
+            "<b>Error:</b> Cannot find a type for this filter!!",
+            quote=True,
+        )
+
+    msgtype = getfilter["msgtype"]
+    if not msgtype:
+        return await m.reply_text("<b>Error:</b> Cannot find a type for this filter!!")
+
+    try:
+        # support for random filter texts
+        splitter = "%%%"
+        filter_reply = getfilter["filter_reply"].split(splitter)
+        filter_reply = choice(filter_reply)
+    except KeyError:
+        filter_reply = ""
+
+    parse_words = [
+        "first",
+        "last",
+        "fullname",
+        "id",
+        "mention",
+        "username",
+        "chatname",
+    ]
+    text = await escape_mentions_using_curly_brackets(m, filter_reply, parse_words)
+    teks, button = await parse_button(text)
+    button = await build_keyboard(button)
+    button = InlineKeyboardMarkup(button) if button else None
+    textt = teks
+    try:
+        if msgtype == Types.TEXT:
+            if button:
+                try:
+                    await m.reply_text(
+                        textt,
+                        # parse_mode="markdown",
+                        reply_markup=button,
+                        disable_web_page_preview=True,
+                        quote=True,
+                    )
+                    return
+                except RPCError as ef:
+                    await m.reply_text(
+                        "An error has occured! Cannot parse note.",
+                        quote=True,
+                    )
+                    LOGGER.error(ef)
+                    LOGGER.error(format_exc())
+                    return
+            else:
+                await m.reply_text(
+                    textt,
+                    # parse_mode="markdown",
+                    quote=True,
+                    disable_web_page_preview=True,
+                )
+                return
+
+        elif msgtype in (
+            Types.STICKER,
+            Types.VIDEO_NOTE,
+            Types.CONTACT,
+            Types.ANIMATED_STICKER,
+        ):
+            await (await send_cmd(c, msgtype))(
+                m.chat.id,
+                getfilter["fileid"],
+                reply_markup=button,
+                reply_to_message_id=m.message_id,
+            )
+        else:
+            await (await send_cmd(c, msgtype))(
+                m.chat.id,
+                getfilter["fileid"],
+                caption=textt,
+                #   parse_mode="markdown",
+                reply_markup=button,
+                reply_to_message_id=m.message_id,
+            )
+    except Exception as ef:
+        await m.reply_text(f"Error in filters: {ef}")
+        return msgtype
+
+    return msgtype
+
+
+@Gojo.on_message(filters.text & filters.group & ~filters.bot, group=69)
+async def filters_watcher(c: Gojo, m: Message):
+
+    chat_filters = db.get_all_filters(m.chat.id)
+    actual_filters = {j for i in chat_filters for j in i.split("|")}
+
+    for trigger in actual_filters:
+        pattern = r"( |^|[^\w])" + re_escape(trigger) + r"( |$|[^\w])"
+        match = await regex_searcher(pattern, m.text.lower())
+        if match:
+            try:
+                msgtype = await send_filter_reply(c, m, trigger)
+                LOGGER.info(f"Replied with {msgtype} to {trigger} in {m.chat.id}")
+            except Exception as ef:
+                await m.reply_text(f"Error: {ef}")
+                LOGGER.error(ef)
+                LOGGER.error(format_exc())
+            break
+        continue
+    return
+
+
+__PLUGIN__ = "filters"
+
+_DISABLE_CMDS_ = ["filters"]
+
+__alt_name__ = ["filters", "autoreply"]

Powers/plugins/formatting.py

@@ -0,0 +1,84 @@
+from pyrogram import filters
+from pyrogram.types import CallbackQuery, Message
+
+from Powers import LOGGER
+from Powers.bot_class import Gojo
+from Powers.tr_engine import tlang
+from Powers.utils.custom_filters import command
+from Powers.utils.kbhelpers import ikb
+
+
+async def gen_formatting_kb(m):
+    return ikb(
+        [
+            [
+                ("Markdown Formatting", "formatting.md_formatting"),
+                ("Fillings", "formatting.fillings"),
+            ],
+            [("Random Content", "formatting.random_content")],
+            [(("« " + (tlang(m, "general.back_btn"))), "commands")],
+        ],
+    )
+
+
+@Gojo.on_message(
+    command(["markdownhelp", "formatting"]) & filters.private,
+)
+async def markdownhelp(_, m: Message):
+    await m.reply_text(
+        tlang(m, f"plugins.{__PLUGIN__}.help"),
+        quote=True,
+        reply_markup=(await gen_formatting_kb(m)),
+    )
+    LOGGER.info(f"{m.from_user.id} used cmd '{m.command}' in {m.chat.id}")
+    return
+
+
+@Gojo.on_callback_query(filters.regex("^formatting."))
+async def get_formatting_info(_, q: CallbackQuery):
+    cmd = q.data.split(".")[1]
+    kb = ikb([[((tlang(q, "general.back_btn")), "back.formatting")]])
+
+    if cmd == "md_formatting":
+        await q.message.edit_text(
+            tlang(q, "formatting.md_help"),
+            reply_markup=kb,
+            parse_mode="html",
+        )
+    elif cmd == "fillings":
+        await q.message.edit_text(
+            tlang(q, "formatting.filling_help"),
+            reply_markup=kb,
+            parse_mode="html",
+        )
+    elif cmd == "random_content":
+        await q.message.edit_text(
+            tlang(q, "formatting.random_help"),
+            reply_markup=kb,
+            parse_mode="html",
+        )
+
+    await q.answer()
+    return
+
+
+@Gojo.on_callback_query(filters.regex("^back."))
+async def send_mod_help(_, q: CallbackQuery):
+    await q.message.edit_text(
+        (tlang(q, "plugins.formatting.help")),
+        reply_markup=(await gen_formatting_kb(q.message)),
+    )
+    await q.answer()
+    return
+
+
+__PLUGIN__ = "formatting"
+
+__alt_name__ = ["formatting", "markdownhelp", "markdown"]
+__buttons__ = [
+    [
+        ("Markdown Formatting", "formatting.md_formatting"),
+        ("Fillings", "formatting.fillings"),
+    ],
+    [("Random Content", "formatting.random_content")],
+]

Powers/plugins/fun.py

@@ -0,0 +1,195 @@
+from html import escape
+from secrets import choice
+import random
+
+from pyrogram.errors import MessageTooLong
+from pyrogram.types import Message
+
+from Powers import LOGGER, DEV_USERS
+from Powers.bot_class import Gojo
+from Powers.tr_engine import tlang
+from Powers.utils import fun_strings
+from Powers.utils.custom_filters import command
+from Powers.utils.extract_user import extract_user
+
+
+
+@Gojo.on_message(command("shout"))
+async def fun_shout(_, m: Message):
+    if len(m.text.split()) == 1:
+        await m.reply_text(
+            (tlang(m, "general.check_help")),
+            quote=True,
+        )
+        return
+    try:
+        text = " ".join(m.text.split(None, 1)[1])
+        result = [" ".join(list(text))]
+        for pos, symbol in enumerate(text[1:]):
+            result.append(symbol + " " + "  " * pos + symbol)
+        result = list("\n".join(result))
+        result[0] = text[0]
+        result = "".join(result)
+        msg = "```\n" + result + "```"
+        await m.reply_text(msg, parse_mode="markdown")
+        LOGGER.info(f"{m.from_user.id} shouted in {m.chat.id}")
+        return
+    except MessageTooLong as e:
+        await m.reply_text(f"Error: {e}")
+        return
+
+
+@Gojo.on_message(command("runs"))
+async def fun_run(_, m: Message):
+    await m.reply_text(choice(fun_strings.RUN_STRINGS))
+    LOGGER.info(f"{m.from_user.id} runed in {m.chat.id}")
+    return
+
+
+@Gojo.on_message(command("slap"))
+async def fun_slap(c: Gojo, m: Message):
+    me = await c.get_me()
+
+    reply_text = m.reply_to_message.reply_text if m.reply_to_message else m.reply_text
+
+    curr_user = escape(m.from_user.first_name)
+    try:
+        user_id, user_first_name, _ = await extract_user(c, m)
+    except Exception:
+        return
+
+    if user_id == me.id:
+        temp = choice(fun_strings.SLAP_GOJO_TEMPLATES)
+    else:
+        temp = choice(fun_strings.SLAP_TEMPLATES)
+
+    if user_id:
+        user1 = curr_user
+        user2 = escape(user_first_name)
+
+    else:
+        user1 = me.first_name
+        user2 = curr_user
+
+    item = choice(fun_strings.ITEMS)
+    hit = choice(fun_strings.HIT)
+    throw = choice(fun_strings.THROW)
+
+    reply = temp.format(user1=user1, user2=user2, item=item, hits=hit, throws=throw)
+    await reply_text(reply)
+    LOGGER.info(f"{m.from_user.id} slaped in {m.chat.id}")
+    return
+
+
+@Gojo.on_message(command("roll"))
+async def fun_roll(_, m: Message):
+    reply_text = m.reply_to_message.reply_text if m.reply_to_message else m.reply_text
+    await reply_text(choice(range(1, 7)))
+    LOGGER.info(f"{m.from_user.id} roll in {m.chat.id}")
+    return
+
+
+@Gojo.on_message(command("toss"))
+async def fun_toss(_, m: Message):
+    reply_text = m.reply_to_message.reply_text if m.reply_to_message else m.reply_text
+    await reply_text(choice(fun_strings.TOSS))
+    LOGGER.info(f"{m.from_user.id} tossed in {m.chat.id}")
+    return
+
+@Gojo.on_message(command("insult"))
+async def insult(c : Gojo , m: Message):
+    try:
+        user_id, user_first_name, _ = await extract_user(c, m)
+    except:
+        return
+    if user_id in DEV_USERS:
+        await m.reply_text("Sorry! I can't insult my devs....")
+    Insult_omp = random.choice(fun_strings.INSULT_STRINGS)
+    reply_text = m.reply_to_message.reply_text if m.reply_to_message else m.reply_text
+    await reply_text(Insult_omp)
+    LOGGER.info(f"{m.from_user.id} insulted {user_first_name} in {m.chat.id}")
+    
+
+
+@Gojo.on_message(command("shrug"))
+async def fun_shrug(_, m: Message):
+    reply_text = m.reply_to_message.reply_text if m.reply_to_message else m.reply_text
+    await reply_text(r"¯\_(ツ)_/¯")
+    LOGGER.info(f"{m.from_user.id} shruged in {m.chat.id}")
+    return
+
+
+@Gojo.on_message(command("bluetext"))
+async def fun_bluetext(_, m: Message):
+    reply_text = m.reply_to_message.reply_text if m.reply_to_message else m.reply_text
+    await reply_text(
+        "/BLUE /TEXT\n/MUST /CLICK\n/I /AM /A /STUPID /ANIMAL /THAT /IS /ATTRACTED /TO /COLORS",
+    )
+    LOGGER.info(f"{m.from_user.id} bluetexted in {m.chat.id}")
+    return
+
+
+@Gojo.on_message(command("decide"))
+async def fun_decide(_, m: Message):
+    reply_text = m.reply_to_message.reply_text if m.reply_to_message else m.reply_text
+    await reply_text(choice(fun_strings.DECIDE))
+    LOGGER.info(f"{m.from_user.id} decided in {m.chat.id}")
+    return
+
+
+@Gojo.on_message(command("react"))
+async def fun_table(_, m: Message):
+    reply_text = m.reply_to_message.reply_text if m.reply_to_message else m.reply_text
+    await reply_text(choice(fun_strings.REACTIONS))
+    LOGGER.info(f"{m.from_user.id} reacted in {m.chat.id}")
+    return
+
+
+@Gojo.on_message(command("weebify"))
+async def weebify(_, m: Message):
+    if len(m.text.split()) >= 2:
+        args = m.text.split(None, 1)[1]
+    elif m.reply_to_message and len(m.text.split()) == 1:
+        args = m.reply_to_message.text
+    else:
+        await m.reply_text(
+            "Please reply to a message or enter text after command to weebify it.",
+        )
+        return
+    if not args:
+        await m.reply_text(tlang(m, "utils.weebify.weebify_what"))
+        return
+
+    # Use split to convert to list
+    # Not using list itself becuase black changes it to long format...
+    normiefont = "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".split()
+    weebyfont = "卂 乃 匚 刀 乇 下 厶 卄 工 丁 长 乚 从 𠘨 口 尸 㔿 尺 丂 丅 凵 リ 山 乂 丫 乙".split()
+
+    string = "  ".join(args).lower()
+    for normiecharacter in string:
+        if normiecharacter in normiefont:
+            weebycharacter = weebyfont[normiefont.index(normiecharacter)]
+            string = string.replace(normiecharacter, weebycharacter)
+
+    await m.reply_text(
+        (tlang(m, "utils.weebify.weebified_string").format(string=string)),
+    )
+    LOGGER.info(f"{m.from_user.id} weebified '{args}' in {m.chat.id}")
+    return
+
+
+__PLUGIN__ = "fun"
+
+_DISABLE_CMDS_ = [
+    "weebify",
+    "decide",
+    "react",
+    "bluetext",
+    "toss",
+    "roll",
+    "slap",
+    "runs",
+    "shout",
+    "insult",
+    "shrug",
+]

Powers/plugins/greetings.py

@@ -0,0 +1,479 @@
+from html import escape
+from secrets import choice
+
+from pyrogram import filters
+from pyrogram.errors import ChatAdminRequired, RPCError
+from pyrogram.types import ChatMemberUpdated, InlineKeyboardMarkup, Message
+
+from Powers import OWNER_ID
+from Powers.bot_class import Gojo
+from Powers.database.antispam_db import GBan
+from Powers.database.greetings_db import Greetings
+from Powers.utils.custom_filters import admin_filter, bot_admin_filter, command
+from Powers.utils.msg_types import Types, get_wlcm_type
+from Powers.utils.parser import escape_markdown, mention_html
+from Powers.utils.string import (
+    build_keyboard,
+    escape_invalid_curly_brackets,
+    parse_button,
+)
+from Powers.vars import Config
+
+# Initialize
+gdb = GBan()
+
+
+async def escape_mentions_using_curly_brackets_wl(
+    m: ChatMemberUpdated,
+    n: bool,
+    text: str,
+    parse_words: list,
+) -> str:
+    teks = await escape_invalid_curly_brackets(text, parse_words)
+    if n:
+        user = m.new_chat_member.user if m.new_chat_member else m.from_user
+    else:
+        user = m.old_chat_member.user if m.old_chat_member else m.from_user
+    if teks:
+        teks = teks.format(
+            first=escape(user.first_name),
+            last=escape(user.last_name or user.first_name),
+            fullname=" ".join(
+                [
+                    escape(user.first_name),
+                    escape(user.last_name),
+                ]
+                if user.last_name
+                else [escape(user.first_name)],
+            ),
+            username=(
+                "@" + (await escape_markdown(escape(user.username)))
+                if user.username
+                else (await (mention_html(escape(user.first_name), user.id)))
+            ),
+            mention=await (mention_html(escape(user.first_name), user.id)),
+            chatname=escape(m.chat.title)
+            if m.chat.type != "private"
+            else escape(user.first_name),
+            id=user.id,
+        )
+    else:
+        teks = ""
+
+    return teks
+
+
+@Gojo.on_message(command("cleanwelcome") & admin_filter)
+async def cleanwlcm(_, m: Message):
+    db = Greetings(m.chat.id)
+    status = db.get_current_cleanwelcome_settings()
+    args = m.text.split(" ", 1)
+
+    if len(args) >= 2:
+        if args[1].lower() == "on":
+            db.set_current_cleanwelcome_settings(True)
+            await m.reply_text("Turned on!")
+            return
+        if args[1].lower() == "off":
+            db.set_current_cleanwelcome_settings(False)
+            await m.reply_text("Turned off!")
+            return
+        await m.reply_text("what are you trying to do ??")
+        return
+    await m.reply_text(f"Current settings:- {status}")
+    return
+
+
+@Gojo.on_message(command("cleangoodbye") & admin_filter)
+async def cleangdbye(_, m: Message):
+    db = Greetings(m.chat.id)
+    status = db.get_current_cleangoodbye_settings()
+    args = m.text.split(" ", 1)
+
+    if len(args) >= 2:
+        if args[1].lower() == "on":
+            db.set_current_cleangoodbye_settings(True)
+            await m.reply_text("Turned on!")
+            return
+        if args[1].lower() == "off":
+            db.set_current_cleangoodbye_settings(False)
+            await m.reply_text("Turned off!")
+            return
+        await m.reply_text("what are you trying to do ??")
+        return
+    await m.reply_text(f"Current settings:- {status}")
+    return
+
+
+@Gojo.on_message(command("cleanservice") & admin_filter)
+async def cleanservice(_, m: Message):
+    db = Greetings(m.chat.id)
+    status = db.get_current_cleanservice_settings()
+    args = m.text.split(" ", 1)
+
+    if len(args) >= 2:
+        if args[1].lower() == "on":
+            db.set_current_cleanservice_settings(True)
+            await m.reply_text("Turned on!")
+            return
+        if args[1].lower() == "off":
+            db.set_current_cleanservice_settings(False)
+            await m.reply_text("Turned off!")
+            return
+        await m.reply_text("what are you trying to do ??")
+        return
+    await m.reply_text(f"Current settings:- {status}")
+    return
+
+
+@Gojo.on_message(command("setwelcome") & admin_filter & bot_admin_filter)
+async def save_wlcm(_, m: Message):
+    db = Greetings(m.chat.id)
+    if m and not m.from_user:
+        return
+    args = m.text.split(None, 1)
+
+    if len(args) >= 4096:
+        await m.reply_text(
+            "Word limit exceed !!",
+        )
+        return
+    if not (m.reply_to_message and m.reply_to_message.text) and len(m.command) == 0:
+        await m.reply_text(
+            "Error: There is no text in here! and only text with buttons are supported currently !",
+        )
+        return
+    text, msgtype, _ = await get_wlcm_type(m)
+
+    if not m.reply_to_message and msgtype == Types.TEXT and len(m.command) <= 2:
+        await m.reply_text(f"<code>{m.text}</code>\n\nError: There is no data in here!")
+        return
+
+    if not text and not msgtype:
+        await m.reply_text(
+            "Please provide some data!",
+        )
+        return
+
+    if not msgtype:
+        await m.reply_text("Please provide some data for this to reply with!")
+        return
+
+    db.set_welcome_text(text)
+    await m.reply_text("Saved welcome!")
+    return
+
+
+@Gojo.on_message(command("setgoodbye") & admin_filter & bot_admin_filter)
+async def save_gdbye(_, m: Message):
+    db = Greetings(m.chat.id)
+    if m and not m.from_user:
+        return
+    args = m.text.split(None, 1)
+
+    if len(args) >= 4096:
+        await m.reply_text(
+            "Word limit exceeds !!",
+        )
+        return
+    if not (m.reply_to_message and m.reply_to_message.text) and len(m.command) == 0:
+        await m.reply_text(
+            "Error: There is no text in here! and only text with buttons are supported currently !",
+        )
+        return
+    text, msgtype, _ = await get_wlcm_type(m)
+
+    if not m.reply_to_message and msgtype == Types.TEXT and len(m.command) <= 2:
+        await m.reply_text(f"<code>{m.text}</code>\n\nError: There is no data in here!")
+        return
+
+    if not text and not msgtype:
+        await m.reply_text(
+            "Please provide some data!",
+        )
+        return
+
+    if not msgtype:
+        await m.reply_text("Please provide some data for this to reply with!")
+        return
+
+    db.set_goodbye_text(text)
+    await m.reply_text("Saved goodbye!")
+    return
+
+
+@Gojo.on_message(command("resetgoodbye") & admin_filter & bot_admin_filter)
+async def resetgb(_, m: Message):
+    db = Greetings(m.chat.id)
+    if m and not m.from_user:
+        return
+    text = "Sad to see you leaving {first}.\nTake Care!"
+    db.set_goodbye_text(text)
+    await m.reply_text("Ok Done!")
+    return
+
+
+@Gojo.on_message(command("resetwelcome") & admin_filter & bot_admin_filter)
+async def resetwlcm(_, m: Message):
+    db = Greetings(m.chat.id)
+    if m and not m.from_user:
+        return
+    text = "Hey {first}, welcome to {chatname}!"
+    db.set_welcome_text(text)
+    await m.reply_text("Done!")
+    return
+
+
+@Gojo.on_message(filters.service & filters.group, group=59)
+async def cleannnnn(_, m: Message):
+    db = Greetings(m.chat.id)
+    clean = db.get_current_cleanservice_settings()
+    try:
+        if clean:
+            await m.delete()
+    except Exception:
+        pass
+
+
+@Gojo.on_chat_member_updated(filters.group, group=69)
+async def member_has_joined(c: Gojo, member: ChatMemberUpdated):
+
+    if (
+        member.new_chat_member
+        and member.new_chat_member.status not in {"banned", "left", "restricted"}
+        and not member.old_chat_member
+    ):
+        pass
+    else:
+        return
+
+    user = member.new_chat_member.user if member.new_chat_member else member.from_user
+
+    db = Greetings(member.chat.id)
+    banned_users = gdb.check_gban(user.id)
+    try:
+        if user.id == Config.BOT_ID:
+            return
+        if user.id == OWNER_ID:
+            await c.send_message(
+                member.chat.id,
+                "Wew My Owner has also joined the chat!",
+            )
+            return
+        if banned_users:
+            await member.chat.ban_member(user.id)
+            await c.send_message(
+                member.chat.id,
+                f"{user.mention} was globally banned so i banned!",
+            )
+            return
+        if user.is_bot:
+            return  # ignore bots
+    except ChatAdminRequired:
+        return
+    status = db.get_welcome_status()
+    oo = db.get_welcome_text()
+    parse_words = [
+        "first",
+        "last",
+        "fullname",
+        "username",
+        "mention",
+        "id",
+        "chatname",
+    ]
+    hmm = await escape_mentions_using_curly_brackets_wl(member, True, oo, parse_words)
+    if status:
+        tek, button = await parse_button(hmm)
+        button = await build_keyboard(button)
+        button = InlineKeyboardMarkup(button) if button else None
+
+        if "%%%" in tek:
+            filter_reply = tek.split("%%%")
+            teks = choice(filter_reply)
+        else:
+            teks = tek
+        ifff = db.get_current_cleanwelcome_id()
+        gg = db.get_current_cleanwelcome_settings()
+        if ifff and gg:
+            try:
+                await c.delete_messages(member.chat.id, int(ifff))
+            except RPCError:
+                pass
+        try:
+            jj = await c.send_message(
+                member.chat.id,
+                text=teks,
+                reply_markup=button,
+                disable_web_page_preview=True,
+            )
+            if jj:
+                db.set_cleanwlcm_id(int(jj.message_id))
+        except RPCError as e:
+            print(e)
+            return
+    else:
+        return
+
+
+@Gojo.on_chat_member_updated(filters.group, group=99)
+async def member_has_left(c: Gojo, member: ChatMemberUpdated):
+
+    if (
+        not member.new_chat_member
+        and member.old_chat_member.status not in {"banned", "restricted"}
+        and member.old_chat_member
+    ):
+        pass
+    else:
+        return
+    db = Greetings(member.chat.id)
+    status = db.get_goodbye_status()
+    oo = db.get_goodbye_text()
+    parse_words = [
+        "first",
+        "last",
+        "fullname",
+        "id",
+        "username",
+        "mention",
+        "chatname",
+    ]
+
+    user = member.old_chat_member.user if member.old_chat_member else member.from_user
+
+    hmm = await escape_mentions_using_curly_brackets_wl(member, False, oo, parse_words)
+    if status:
+        tek, button = await parse_button(hmm)
+        button = await build_keyboard(button)
+        button = InlineKeyboardMarkup(button) if button else None
+
+        if "%%%" in tek:
+            filter_reply = tek.split("%%%")
+            teks = choice(filter_reply)
+        else:
+            teks = tek
+        ifff = db.get_current_cleangoodbye_id()
+        iii = db.get_current_cleangoodbye_settings()
+        if ifff and iii:
+            try:
+                await c.delete_messages(member.chat.id, int(ifff))
+            except RPCError:
+                pass
+        if user.id == OWNER_ID:
+            await c.send_message(
+                member.chat.id,
+                "Will miss you :)",
+            )
+            return
+        try:
+            ooo = await c.send_message(
+                member.chat.id,
+                text=teks,
+                reply_markup=button,
+                disable_web_page_preview=True,
+            )
+            if ooo:
+                db.set_cleangoodbye_id(int(ooo.message_id))
+            return
+        except RPCError as e:
+            print(e)
+            return
+    else:
+        return
+
+
+@Gojo.on_message(command("welcome") & admin_filter)
+async def welcome(c: Gojo, m: Message):
+    db = Greetings(m.chat.id)
+    status = db.get_welcome_status()
+    oo = db.get_welcome_text()
+    args = m.text.split(" ", 1)
+
+    if m and not m.from_user:
+        return
+
+    if len(args) >= 2:
+        if args[1].lower() == "noformat":
+            await m.reply_text(
+                f"""Current welcome settings:-
+            Welcome power: {status}
+            Clean Welcome: {db.get_current_cleanwelcome_settings()}
+            Cleaning service: {db.get_current_cleanservice_settings()}
+            Welcome text in no formating:
+            """,
+            )
+            await c.send_message(m.chat.id, text=oo, parse_mode=None)
+            return
+        if args[1].lower() == "on":
+            db.set_current_welcome_settings(True)
+            await m.reply_text("Turned on!")
+            return
+        if args[1].lower() == "off":
+            db.set_current_welcome_settings(False)
+            await m.reply_text("Turned off!")
+            return
+        await m.reply_text("what are you trying to do ??")
+        return
+    await m.reply_text(
+        f"""Current welcome settings:-
+    Welcome power: {status}
+    Clean Welcome: {db.get_current_cleanwelcome_settings()}
+    Cleaning service: {db.get_current_cleanservice_settings()}
+    Welcome text:
+    """,
+    )
+    tek, button = await parse_button(oo)
+    button = await build_keyboard(button)
+    button = InlineKeyboardMarkup(button) if button else None
+    await c.send_message(m.chat.id, text=tek, reply_markup=button)
+    return
+
+
+@Gojo.on_message(command("goodbye") & admin_filter)
+async def goodbye(c: Gojo, m: Message):
+    db = Greetings(m.chat.id)
+    status = db.get_goodbye_status()
+    oo = db.get_goodbye_text()
+    args = m.text.split(" ", 1)
+    if m and not m.from_user:
+        return
+    if len(args) >= 2:
+        if args[1].lower() == "noformat":
+            await m.reply_text(
+                f"""Current goodbye settings:-
+            Goodbye power: {status}
+            Clean Goodbye: {db.get_current_cleangoodbye_settings()}
+            Cleaning service: {db.get_current_cleanservice_settings()}
+            Goodbye text in no formating:
+            """,
+            )
+            await c.send_message(m.chat.id, text=oo, parse_mode=None)
+            return
+        if args[1].lower() == "on":
+            db.set_current_goodbye_settings(True)
+            await m.reply_text("Turned on!")
+            return
+        if args[1].lower() == "off":
+            db.set_current_goodbye_settings(False)
+            await m.reply_text("Turned off!")
+            return
+        await m.reply_text("what are you trying to do ??")
+        return
+    await m.reply_text(
+        f"""Current Goodbye settings:-
+    Goodbye power: {status}
+    Clean Goodbye: {db.get_current_cleangoodbye_settings()}
+    Cleaning service: {db.get_current_cleanservice_settings()}
+    Goodbye text:
+    """,
+    )
+    tek, button = await parse_button(oo)
+    button = await build_keyboard(button)
+    button = InlineKeyboardMarkup(button) if button else None
+    await c.send_message(m.chat.id, text=tek, reply_markup=button)
+    return
+
+
+__PLUGIN__ = "greetings"
+__alt_name__ = ["welcome", "goodbye", "cleanservice"]

Powers/plugins/initial.py

@@ -0,0 +1,114 @@
+from pyrogram import filters
+from pyrogram.errors import RPCError
+from pyrogram.types import Message
+
+from Powers import LOGGER
+from Powers.bot_class import Gojo
+from Powers.database.approve_db import Approve
+from Powers.database.blacklist_db import Blacklist
+from Powers.database.chats_db import Chats
+from Powers.database.disable_db import Disabling
+from Powers.database.filters_db import Filters
+from Powers.database.greetings_db import Greetings
+from Powers.database.lang_db import Langs
+from Powers.database.notes_db import Notes, NotesSettings
+from Powers.database.pins_db import Pins
+from Powers.database.reporting_db import Reporting
+from Powers.database.rules_db import Rules
+from Powers.database.users_db import Users
+
+
+@Gojo.on_message(filters.group, group=4)
+async def initial_works(_, m: Message):
+    chatdb = Chats(m.chat.id)
+    try:
+        if m.migrate_to_chat_id or m.migrate_from_chat_id:
+            new_chat = m.migrate_to_chat_id or m.chat.id
+            try:
+                await migrate_chat(m, new_chat)
+            except RPCError as ef:
+                LOGGER.error(ef)
+                return
+        elif m.reply_to_message and not m.forward_from:
+            chatdb.update_chat(
+                m.chat.title,
+                m.reply_to_message.from_user.id,
+            )
+            Users(m.reply_to_message.from_user.id).update_user(
+                (
+                    f"{m.reply_to_message.from_user.first_name} {m.reply_to_message.from_user.last_name}"
+                    if m.reply_to_message.from_user.last_name
+                    else m.reply_to_message.from_user.first_name
+                ),
+                m.reply_to_message.from_user.username,
+            )
+        elif m.forward_from and not m.reply_to_message:
+            chatdb.update_chat(
+                m.chat.title,
+                m.forward_from.id,
+            )
+            Users(m.forward_from.id).update_user(
+                (
+                    f"{m.forward_from.first_name} {m.forward_from.last_name}"
+                    if m.forward_from.last_name
+                    else m.forward_from.first_name
+                ),
+                m.forward_from.username,
+            )
+        elif m.reply_to_message:
+            chatdb.update_chat(
+                m.chat.title,
+                m.reply_to_message.forward_from.id,
+            )
+            Users(m.forward_from.id).update_user(
+                (
+                    f"{m.reply_to_message.forward_from.first_name} {m.reply_to_message.forward_from.last_name}"
+                    if m.reply_to_message.forward_from.last_name
+                    else m.reply_to_message.forward_from.first_name
+                ),
+                m.forward_from.username,
+            )
+        else:
+            chatdb.update_chat(m.chat.title, m.from_user.id)
+            Users(m.from_user.id).update_user(
+                (
+                    f"{m.from_user.first_name} {m.from_user.last_name}"
+                    if m.from_user.last_name
+                    else m.from_user.first_name
+                ),
+                m.from_user.username,
+            )
+    except AttributeError:
+        pass  # Skip attribute errors!
+    return
+
+
+async def migrate_chat(m: Message, new_chat: int) -> None:
+    LOGGER.info(f"Migrating from {m.chat.id} to {new_chat}...")
+    langdb = Langs(m.chat.id)
+    notedb = Notes()
+    gdb = Greetings(m.chat.id)
+    ruledb = Rules(m.chat.id)
+    userdb = Users(m.chat.id)
+    chatdb = Chats(m.chat.id)
+    bldb = Blacklist(m.chat.id)
+    approvedb = Approve(m.chat.id)
+    reportdb = Reporting(m.chat.id)
+    notes_settings = NotesSettings()
+    pins_db = Pins(m.chat.id)
+    fldb = Filters()
+    disabl = Disabling(m.chat.id)
+    disabl.migrate_chat(new_chat)
+    gdb.migrate_chat(new_chat)
+    chatdb.migrate_chat(new_chat)
+    userdb.migrate_chat(new_chat)
+    langdb.migrate_chat(new_chat)
+    ruledb.migrate_chat(new_chat)
+    bldb.migrate_chat(new_chat)
+    notedb.migrate_chat(m.chat.id, new_chat)
+    approvedb.migrate_chat(new_chat)
+    reportdb.migrate_chat(new_chat)
+    notes_settings.migrate_chat(m.chat.id, new_chat)
+    pins_db.migrate_chat(new_chat)
+    fldb.migrate_chat(m.chat.id, new_chat)
+    LOGGER.info(f"Successfully migrated from {m.chat.id} to {new_chat}!")

Powers/plugins/langs.py

@@ -0,0 +1,119 @@
+from asyncio import sleep
+
+from pyrogram import filters
+from pyrogram.types import CallbackQuery, Message
+
+from Powers import LOGGER
+from Powers.bot_class import Gojo
+from Powers.database.lang_db import Langs
+from Powers.tr_engine import lang_dict, tlang
+from Powers.utils.custom_filters import admin_filter, command
+from Powers.utils.kbhelpers import ikb
+
+
+async def gen_langs_kb():
+    langs = sorted(list(lang_dict.keys()))
+    return [
+        [
+            (
+                f"{lang_dict[lang]['main']['language_flag']} {lang_dict[lang]['main']['language_name']} ({lang_dict[lang]['main']['lang_sample']})",
+                f"set_lang.{lang}",
+            )
+            for lang in langs
+        ],
+        [
+            (
+                "🌎 Help us with translations!",
+                "https://crowdin.com/project/Gojo_Satarou",
+                "url",
+            ),
+        ],
+    ]
+
+
+@Gojo.on_callback_query(filters.regex("^chlang$"))
+async def chlang_callback(_, q: CallbackQuery):
+    kb = await gen_langs_kb()
+    kb.append([(f"« {(tlang(q, 'general.back_btn'))}", "start_back")])
+
+    await q.message.edit_text(
+        (tlang(q, "langs.changelang")),
+        reply_markup=ikb(kb),
+    )
+    await q.answer()
+    return
+
+
+@Gojo.on_callback_query(filters.regex("^close$"), group=3)
+async def close_btn_callback(_, q: CallbackQuery):
+    await q.message.delete()
+    try:
+        await q.message.reply_to_message.delete()
+    except Exception as ef:
+        LOGGER.error(f"Error: Cannot delete message\n{ef}")
+    await q.answer()
+    return
+
+
+@Gojo.on_callback_query(filters.regex("^set_lang."))
+async def set_lang_callback(_, q: CallbackQuery):
+    lang_code = q.data.split(".")[1]
+
+    Langs(q.message.chat.id).set_lang(lang_code)
+    await sleep(0.1)
+
+    if q.message.chat.type == "private":
+        keyboard = ikb([[(f"« {(tlang(q, 'general.back_btn'))}", "start_back")]])
+    else:
+        keyboard = None
+    await q.message.edit_text(
+        f"🌐 {((tlang(q, 'langs.changed')).format(lang_code=lang_code))}",
+        reply_markup=keyboard,
+    )
+    await q.answer()
+    return
+
+
+@Gojo.on_message(
+    command(["lang", "setlang"]) & (admin_filter | filters.private),
+    group=7,
+)
+async def set_lang(_, m: Message):
+    args = m.text.split()
+
+    if len(args) > 2:
+        await m.reply_text(tlang(m, "langs.correct_usage"))
+        return
+    if len(args) == 2:
+        lang_code = args[1]
+        avail_langs = set(lang_dict.keys())
+        if lang_code not in avail_langs:
+            await m.reply_text(
+                f"Please choose a valid language code from: {', '.join(avail_langs)}",
+            )
+            return
+        Langs(m.chat.id).set_lang(lang_code)
+        LOGGER.info(f"{m.from_user.id} change language to {lang_code} in {m.chat.id}")
+        await m.reply_text(
+            f"🌐 {((tlang(m, 'langs.changed')).format(lang_code=lang_code))}",
+        )
+        return
+    await m.reply_text(
+        (tlang(m, "langs.changelang")),
+        reply_markup=ikb(await gen_langs_kb()),
+    )
+    return
+
+
+__PLUGIN__ = "language"
+
+__alt_name__ = ["lang", "langs", "languages"]
+__buttons__ = [
+    [
+        (
+            "🌎 Help us with translations!",
+            "https://t.me/gojo_updates",
+            "url",
+        ),
+    ],
+]

Powers/plugins/locks.py

@@ -0,0 +1,322 @@
+from asyncio import sleep
+
+from pyrogram.errors import ChatAdminRequired, ChatNotModified, RPCError
+from pyrogram.types import ChatPermissions, Message
+
+from Powers import LOGGER
+from Powers.bot_class import Gojo
+from Powers.database.approve_db import Approve
+from Powers.tr_engine import tlang
+from Powers.utils.custom_filters import command, restrict_filter
+
+
+@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"
+        ),
+    )
+    return
+
+
+@Gojo.on_message(command("lock") & restrict_filter)
+async def lock_perm(c: Gojo, m: Message):
+    if len(m.text.split()) < 2:
+        await m.reply_text("Please enter a permission to lock!")
+        return
+    lock_type = m.text.split(None, 1)[1]
+    chat_id = m.chat.id
+
+    if not lock_type:
+        await m.reply_text(tlang(m, "locks.locks_perm_sp"))
+        return
+
+    get_perm = m.chat.permissions
+
+    msg = get_perm.can_send_messages
+    media = get_perm.can_send_media_messages
+    webprev = get_perm.can_add_web_page_previews
+    polls = get_perm.can_send_polls
+    info = get_perm.can_change_info
+    invite = get_perm.can_invite_users
+    pin = get_perm.can_pin_messages
+    stickers = animations = games = inlinebots = None
+
+    if lock_type == "all":
+        try:
+            await c.set_chat_permissions(chat_id, ChatPermissions())
+            LOGGER.info(f"{m.from_user.id} locked all permissions in {m.chat.id}")
+        except ChatNotModified:
+            pass
+        except ChatAdminRequired:
+            await m.reply_text(tlang(m, "general.no_perm_admin"))
+        await m.reply_text("🔒 " + (tlang(m, "locks.lock_all")))
+        await prevent_approved(m)
+        return
+
+    if lock_type == "msg":
+        msg = False
+        perm = "messages"
+
+    elif lock_type == "media":
+        media = False
+        perm = "audios, documents, photos, videos, video notes, voice notes"
+
+    elif lock_type == "stickers":
+        stickers = False
+        perm = "stickers"
+
+    elif lock_type == "animations":
+        animations = False
+        perm = "animations"
+
+    elif lock_type == "games":
+        games = False
+        perm = "games"
+
+    elif lock_type in ("inlinebots", "inline"):
+        inlinebots = False
+        perm = "inline bots"
+
+    elif lock_type == "webprev":
+        webprev = False
+        perm = "web page previews"
+
+    elif lock_type == "polls":
+        polls = False
+        perm = "polls"
+
+    elif lock_type == "info":
+        info = False
+        perm = "info"
+
+    elif lock_type == "invite":
+        invite = False
+        perm = "invite"
+
+    elif lock_type == "pin":
+        pin = False
+        perm = "pin"
+
+    else:
+        await m.reply_text(tlang(m, "locks.invalid_lock"))
+        return
+
+    try:
+        await c.set_chat_permissions(
+            chat_id,
+            ChatPermissions(
+                can_send_messages=msg,
+                can_send_media_messages=media,
+                can_send_other_messages=any([stickers, animations, games, inlinebots]),
+                can_add_web_page_previews=webprev,
+                can_send_polls=polls,
+                can_change_info=info,
+                can_invite_users=invite,
+                can_pin_messages=pin,
+            ),
+        )
+        LOGGER.info(f"{m.from_user.id} locked selected permissions in {m.chat.id}")
+    except ChatNotModified:
+        pass
+    except ChatAdminRequired:
+        await m.reply_text(tlang(m, "general.no_perm_admin"))
+    await m.reply_text(
+        "🔒 " + (tlang(m, "locks.locked_perm").format(perm=perm)),
+    )
+    await prevent_approved(m)
+    return
+
+
+@Gojo.on_message(command("locks") & restrict_filter)
+async def view_locks(_, m: Message):
+    chkmsg = await m.reply_text(tlang(m, "locks.check_perm_msg"))
+    v_perm = m.chat.permissions
+
+    async def convert_to_emoji(val: bool):
+        if val:
+            return "✅"
+        return "❌"
+
+    vmsg = await convert_to_emoji(v_perm.can_send_messages)
+    vmedia = await convert_to_emoji(v_perm.can_send_media_messages)
+    vother = await convert_to_emoji(v_perm.can_send_other_messages)
+    vwebprev = await convert_to_emoji(v_perm.can_add_web_page_previews)
+    vpolls = await convert_to_emoji(v_perm.can_send_polls)
+    vinfo = await convert_to_emoji(v_perm.can_change_info)
+    vinvite = await convert_to_emoji(v_perm.can_invite_users)
+    vpin = await convert_to_emoji(v_perm.can_pin_messages)
+
+    if v_perm is not None:
+        try:
+            permission_view_str = (tlang(m, "locks.view_perm")).format(
+                vmsg=vmsg,
+                vmedia=vmedia,
+                vother=vother,
+                vwebprev=vwebprev,
+                vpolls=vpolls,
+                vinfo=vinfo,
+                vinvite=vinvite,
+                vpin=vpin,
+            )
+            LOGGER.info(f"{m.from_user.id} used locks cmd in {m.chat.id}")
+            await chkmsg.edit_text(permission_view_str)
+
+        except RPCError as e_f:
+            await chkmsg.edit_text(tlang(m, "general.something_wrong"))
+            await m.reply_text(e_f)
+    return
+
+
+@Gojo.on_message(command("unlock") & restrict_filter)
+async def unlock_perm(c: Gojo, m: Message):
+    if len(m.text.split()) < 2:
+        await m.reply_text("Please enter a permission to unlock!")
+        return
+    unlock_type = m.text.split(None, 1)[1]
+    chat_id = m.chat.id
+
+    if not unlock_type:
+        await m.reply_text(tlang(m, "locks.unlocks_perm_sp"))
+        return
+
+    if unlock_type == "all":
+        try:
+            await c.set_chat_permissions(
+                chat_id,
+                ChatPermissions(
+                    can_send_messages=True,
+                    can_send_media_messages=True,
+                    can_send_other_messages=True,
+                    can_add_web_page_previews=True,
+                    can_send_polls=True,
+                    can_change_info=True,
+                    can_invite_users=True,
+                    can_pin_messages=True,
+                ),
+            )
+            LOGGER.info(f"{m.from_user.id} unlocked all permissions in {m.chat.id}")
+        except ChatNotModified:
+            pass
+        except ChatAdminRequired:
+            await m.reply_text(tlang(m, "general.no_perm_admin"))
+        await m.reply_text("🔓 " + (tlang(m, "locks.unlock_all")))
+        await prevent_approved(m)
+        return
+
+    get_uperm = m.chat.permissions
+
+    umsg = get_uperm.can_send_messages
+    umedia = get_uperm.can_send_media_messages
+    uwebprev = get_uperm.can_add_web_page_previews
+    upolls = get_uperm.can_send_polls
+    uinfo = get_uperm.can_change_info
+    uinvite = get_uperm.can_invite_users
+    upin = get_uperm.can_pin_messages
+    ustickers = uanimations = ugames = uinlinebots = None
+
+    if unlock_type == "msg":
+        umsg = True
+        uperm = "messages"
+
+    elif unlock_type == "media":
+        umedia = True
+        uperm = "audios, documents, photos, videos, video notes, voice notes"
+
+    elif unlock_type == "stickers":
+        ustickers = True
+        uperm = "stickers"
+
+    elif unlock_type == "animations":
+        uanimations = True
+        uperm = "animations"
+
+    elif unlock_type == "games":
+        ugames = True
+        uperm = "games"
+
+    elif unlock_type in ("inlinebots", "inline"):
+        uinlinebots = True
+        uperm = "inline bots"
+
+    elif unlock_type == "webprev":
+        uwebprev = True
+        uperm = "web page previews"
+
+    elif unlock_type == "polls":
+        upolls = True
+        uperm = "polls"
+
+    elif unlock_type == "info":
+        uinfo = True
+        uperm = "info"
+
+    elif unlock_type == "invite":
+        uinvite = True
+        uperm = "invite"
+
+    elif unlock_type == "pin":
+        upin = True
+        uperm = "pin"
+
+    else:
+        await m.reply_text(tlang(m, "locks.invalid_lock"))
+        return
+
+    try:
+        LOGGER.info(f"{m.from_user.id} unlocked selected permissions in {m.chat.id}")
+        await c.set_chat_permissions(
+            chat_id,
+            ChatPermissions(
+                can_send_messages=umsg,
+                can_send_media_messages=umedia,
+                can_send_other_messages=any(
+                    [ustickers, uanimations, ugames, uinlinebots],
+                ),
+                can_add_web_page_previews=uwebprev,
+                can_send_polls=upolls,
+                can_change_info=uinfo,
+                can_invite_users=uinvite,
+                can_pin_messages=upin,
+            ),
+        )
+    except ChatNotModified:
+        pass
+    except ChatAdminRequired:
+        await m.reply_text(tlang(m, "general.no_perm_admin"))
+    await m.reply_text(
+        "🔓 " + (tlang(m, "locks.unlocked_perm").format(uperm=uperm)),
+    )
+    await prevent_approved(m)
+    return
+
+
+async def prevent_approved(m: Message):
+    approved_users = Approve(m.chat.id).list_approved()
+    ul = [user[0] for user in approved_users]
+    for i in ul:
+        try:
+            await m.chat.unban_member(user_id=i)
+        except (ChatAdminRequired, ChatNotModified, RPCError):
+            continue
+        LOGGER.info(f"Approved {i} in {m.chat.id}")
+        await sleep(0.1)
+    return
+
+
+__PLUGIN__ = "locks"
+
+__alt_name__ = ["grouplock", "lock", "grouplocks"]

Powers/plugins/muting.py

@@ -0,0 +1,609 @@
+from pyrogram.errors import (
+    ChatAdminRequired,
+    RightForbidden,
+    RPCError,
+    UserNotParticipant,
+)
+from pyrogram.filters import regex
+from pyrogram.types import (
+    CallbackQuery,
+    ChatPermissions,
+    InlineKeyboardButton,
+    InlineKeyboardMarkup,
+    Message,
+)
+
+from Powers import LOGGER, OWNER_ID, SUPPORT_GROUP, SUPPORT_STAFF
+from Powers.bot_class import Gojo
+from Powers.tr_engine import tlang
+from Powers.utils.caching import ADMIN_CACHE, admin_cache_reload
+from Powers.utils.custom_filters import command, restrict_filter
+from Powers.utils.extract_user import extract_user
+from Powers.utils.parser import mention_html
+from Powers.utils.string import extract_time
+from Powers.vars import Config
+
+
+@Gojo.on_message(command("tmute") & restrict_filter)
+async def tmute_usr(c: Gojo, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text("I can't mute nothing!")
+        return
+
+    try:
+        user_id, user_first_name, _ = await extract_user(c, m)
+    except Exception:
+        return
+
+    if not user_id:
+        await m.reply_text("Cannot find user to mute !")
+        return
+    if user_id == Config.BOT_ID:
+        await m.reply_text("Huh, why would I mute myself?")
+        return
+
+    if user_id in SUPPORT_STAFF:
+        LOGGER.info(
+            f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        return
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = await admin_cache_reload(m, "mute")
+
+    if user_id in admins_group:
+        await m.reply_text(tlang(m, "admin.mute.admin_cannot_mute"))
+        return
+
+    r_id = m.reply_to_message.message_id if m.reply_to_message else m.message_id
+
+    if m.reply_to_message and len(m.text.split()) >= 2:
+        reason = m.text.split(None, 2)[1]
+    elif not m.reply_to_message and len(m.text.split()) >= 3:
+        reason = m.text.split(None, 2)[2]
+    else:
+        await m.reply_text("Read /help !!")
+        return
+
+    if not reason:
+        await m.reply_text("You haven't specified a time to mute this user for!")
+        return
+
+    split_reason = reason.split(None, 1)
+    time_val = split_reason[0].lower()
+
+    reason = split_reason[1] if len(split_reason) > 1 else ""
+
+    mutetime = await extract_time(m, time_val)
+
+    if not mutetime:
+        return
+
+    try:
+        await m.chat.restrict_member(
+            user_id,
+            ChatPermissions(),
+            mutetime,
+        )
+        LOGGER.info(f"{m.from_user.id} tmuted {user_id} in {m.chat.id}")
+        txt = (tlang(m, "admin.mute.muted_user")).format(
+            admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
+            muted=(await mention_html(user_first_name, user_id)),
+        )
+        if reason:
+            txt += f"\n<b>Reason</b>: {reason}"
+        keyboard = InlineKeyboardMarkup(
+            [
+                [
+                    InlineKeyboardButton(
+                        "Unmute",
+                        callback_data=f"unmute_={user_id}",
+                    ),
+                ],
+            ],
+        )
+        await m.reply_text(txt, reply_markup=keyboard, reply_to_message_id=r_id)
+    except ChatAdminRequired:
+        await m.reply_text(tlang(m, "admin.not_admin"))
+    except RightForbidden:
+        await m.reply_text(tlang(m, "admin.mute.bot_no_right"))
+    except UserNotParticipant:
+        await m.reply_text("How can I mute a user who is not a part of this chat?")
+    except RPCError as ef:
+        await m.reply_text(
+            (tlang(m, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=ef,
+            ),
+        )
+        LOGGER.error(ef)
+
+    return
+
+
+@Gojo.on_message(command("dtmute") & restrict_filter)
+async def dtmute_usr(c: Gojo, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text("I can't mute nothing!")
+        return
+
+    if not m.reply_to_message:
+        return await m.reply_text("No replied message and user to delete and mute!")
+
+    reason = None
+    user_id = m.reply_to_message.from_user.id
+    user_first_name = m.reply_to_message.from_user.first_name
+
+    if not user_id:
+        await m.reply_text("Cannot find user to mute !")
+        return
+    if user_id == Config.BOT_ID:
+        await m.reply_text("Huh, why would I mute myself?")
+        return
+
+    if user_id in SUPPORT_STAFF:
+        LOGGER.info(
+            f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        return
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = await admin_cache_reload(m, "mute")
+
+    if user_id in admins_group:
+        await m.reply_text(tlang(m, "admin.mute.admin_cannot_mute"))
+        return
+
+    if m.reply_to_message and len(m.text.split()) >= 2:
+        reason = m.text.split(None, 2)[1]
+    elif not m.reply_to_message and len(m.text.split()) >= 3:
+        reason = m.text.split(None, 2)[2]
+    else:
+        await m.reply_text("Read /help !!")
+        return
+
+    if not reason:
+        await m.reply_text("You haven't specified a time to mute this user for!")
+        return
+
+    split_reason = reason.split(None, 1)
+    time_val = split_reason[0].lower()
+    reason = split_reason[1] if len(split_reason) > 1 else ""
+
+    mutetime = await extract_time(m, time_val)
+
+    if not mutetime:
+        return
+
+    try:
+        await m.chat.restrict_member(
+            user_id,
+            ChatPermissions(),
+            mutetime,
+        )
+        LOGGER.info(f"{m.from_user.id} dtmuted {user_id} in {m.chat.id}")
+        await m.reply_to_message.delete()
+        txt = (tlang(m, "admin.mute.muted_user")).format(
+            admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
+            muted=(await mention_html(user_first_name, user_id)),
+        )
+        if reason:
+            txt += f"\n<b>Reason</b>: {reason}"
+        keyboard = InlineKeyboardMarkup(
+            [
+                [
+                    InlineKeyboardButton(
+                        "Unmute",
+                        callback_data=f"unmute_={user_id}",
+                    ),
+                ],
+            ],
+        )
+        await c.send_message(m.chat.id, txt, reply_markup=keyboard)
+    except ChatAdminRequired:
+        await m.reply_text(tlang(m, "admin.not_admin"))
+    except RightForbidden:
+        await m.reply_text(tlang(m, "admin.mute.bot_no_right"))
+    except UserNotParticipant:
+        await m.reply_text("How can I mute a user who is not a part of this chat?")
+    except RPCError as ef:
+        await m.reply_text(
+            (tlang(m, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=ef,
+            ),
+        )
+        LOGGER.error(ef)
+
+    return
+
+
+@Gojo.on_message(command("stmute") & restrict_filter)
+async def stmute_usr(c: Gojo, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text("I can't mute nothing!")
+        return
+
+    try:
+        user_id, _, _ = await extract_user(c, m)
+    except Exception:
+        return
+
+    if not user_id:
+        await m.reply_text("Cannot find user to mute !")
+        return
+    if user_id == Config.BOT_ID:
+        await m.reply_text("Huh, why would I mute myself?")
+        return
+
+    if user_id in SUPPORT_STAFF:
+        LOGGER.info(
+            f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        return
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = await admin_cache_reload(m, "mute")
+
+    if user_id in admins_group:
+        await m.reply_text(tlang(m, "admin.mute.admin_cannot_mute"))
+        return
+
+    if m.reply_to_message and len(m.text.split()) >= 2:
+        reason = m.text.split(None, 2)[1]
+    elif not m.reply_to_message and len(m.text.split()) >= 3:
+        reason = m.text.split(None, 2)[2]
+    else:
+        await m.reply_text("Read /help !!")
+        return
+
+    if not reason:
+        await m.reply_text("You haven't specified a time to mute this user for!")
+        return
+
+    split_reason = reason.split(None, 1)
+    time_val = split_reason[0].lower()
+    reason = split_reason[1] if len(split_reason) > 1 else ""
+
+    mutetime = await extract_time(m, time_val)
+
+    if not mutetime:
+        return
+
+    try:
+        await m.chat.restrict_member(
+            user_id,
+            ChatPermissions(),
+            mutetime,
+        )
+        LOGGER.info(f"{m.from_user.id} stmuted {user_id} in {m.chat.id}")
+        await m.delete()
+        if m.reply_to_message:
+            await m.reply_to_message.delete()
+    except ChatAdminRequired:
+        await m.reply_text(tlang(m, "admin.not_admin"))
+    except RightForbidden:
+        await m.reply_text(tlang(m, "admin.mute.bot_no_right"))
+    except UserNotParticipant:
+        await m.reply_text("How can I mute a user who is not a part of this chat?")
+    except RPCError as ef:
+        await m.reply_text(
+            (tlang(m, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=ef,
+            ),
+        )
+        LOGGER.error(ef)
+
+    return
+
+
+@Gojo.on_message(command("mute") & restrict_filter)
+async def mute_usr(c: Gojo, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text("I can't mute nothing!")
+        return
+
+    reason = None
+    if m.reply_to_message:
+        r_id = m.reply_to_message.message_id
+        if len(m.text.split()) >= 2:
+            reason = m.text.split(None, 1)[1]
+    else:
+        r_id = m.message_id
+        if len(m.text.split()) >= 3:
+            reason = m.text.split(None, 2)[2]
+    try:
+        user_id, user_first_name, _ = await extract_user(c, m)
+    except Exception:
+        return
+
+    if not user_id:
+        await m.reply_text("Cannot find user to mute")
+        return
+    if user_id == Config.BOT_ID:
+        await m.reply_text("Huh, why would I mute myself?")
+        return
+
+    if user_id in SUPPORT_STAFF:
+        LOGGER.info(
+            f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        return
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = await admin_cache_reload(m, "mute")
+
+    if user_id in admins_group:
+        await m.reply_text(tlang(m, "admin.mute.admin_cannot_mute"))
+        return
+
+    try:
+        await m.chat.restrict_member(
+            user_id,
+            ChatPermissions(),
+        )
+        LOGGER.info(f"{m.from_user.id} muted {user_id} in {m.chat.id}")
+        txt = (tlang(m, "admin.mute.muted_user")).format(
+            admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
+            muted=(await mention_html(user_first_name, user_id)),
+        )
+        if reason:
+            txt += f"\n<b>Reason</b>: {reason}"
+        keyboard = InlineKeyboardMarkup(
+            [
+                [
+                    InlineKeyboardButton(
+                        "Unmute",
+                        callback_data=f"unmute_={user_id}",
+                    ),
+                ],
+            ],
+        )
+        await m.reply_text(txt, reply_markup=keyboard, reply_to_message_id=r_id)
+    except ChatAdminRequired:
+        await m.reply_text(tlang(m, "admin.not_admin"))
+    except RightForbidden:
+        await m.reply_text(tlang(m, "admin.mute.bot_no_right"))
+    except UserNotParticipant:
+        await m.reply_text("How can I mute a user who is not a part of this chat?")
+    except RPCError as ef:
+        await m.reply_text(
+            (tlang(m, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=ef,
+            ),
+        )
+        LOGGER.error(ef)
+
+    return
+
+
+@Gojo.on_message(command("smute") & restrict_filter)
+async def smute_usr(c: Gojo, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text("I can't mute nothing!")
+        return
+
+    try:
+        user_id, _, _ = await extract_user(c, m)
+    except Exception:
+        return
+
+    if not user_id:
+        await m.reply_text("Cannot find user to mute")
+        return
+    if user_id == Config.BOT_ID:
+        await m.reply_text("Huh, why would I mute myself?")
+        return
+
+    if user_id in SUPPORT_STAFF:
+        LOGGER.info(
+            f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        return
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = await admin_cache_reload(m, "mute")
+
+    if user_id in admins_group:
+        await m.reply_text(tlang(m, "admin.mute.admin_cannot_mute"))
+        return
+
+    try:
+        await m.chat.restrict_member(
+            user_id,
+            ChatPermissions(),
+        )
+        LOGGER.info(f"{m.from_user.id} smuted {user_id} in {m.chat.id}")
+        await m.delete()
+        if m.reply_to_message:
+            await m.reply_to_message.delete()
+            return
+        return
+    except ChatAdminRequired:
+        await m.reply_text(tlang(m, "admin.not_admin"))
+    except RightForbidden:
+        await m.reply_text(tlang(m, "admin.mute.bot_no_right"))
+    except UserNotParticipant:
+        await m.reply_text("How can I mute a user who is not a part of this chat?")
+    except RPCError as ef:
+        await m.reply_text(
+            (tlang(m, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=ef,
+            ),
+        )
+        LOGGER.error(ef)
+
+    return
+
+
+@Gojo.on_message(command("dmute") & restrict_filter)
+async def dmute_usr(c: Gojo, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text("I can't mute nothing!")
+        return
+    if not m.reply_to_message:
+        return await m.reply_text("No replied message and user to delete and mute!")
+
+    reason = None
+    if m.reply_to_message:
+        if len(m.text.split()) >= 2:
+            reason = m.text.split(None, 1)[1]
+    else:
+        if len(m.text.split()) >= 3:
+            reason = m.text.split(None, 2)[2]
+    user_id = m.reply_to_message.from_user.id
+    user_first_name = m.reply_to_message.from_user.first_name
+
+    if not user_id:
+        await m.reply_text("Cannot find user to mute")
+        return
+    if user_id == Config.BOT_ID:
+        await m.reply_text("Huh, why would I mute myself?")
+        return
+
+    if user_id in SUPPORT_STAFF:
+        LOGGER.info(
+            f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        return
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = await admin_cache_reload(m, "mute")
+
+    if user_id in admins_group:
+        await m.reply_text(tlang(m, "admin.mute.admin_cannot_mute"))
+        return
+
+    try:
+        await m.chat.restrict_member(
+            user_id,
+            ChatPermissions(),
+        )
+        LOGGER.info(f"{m.from_user.id} dmuted {user_id} in {m.chat.id}")
+        await m.reply_to_message.delete()
+        txt = (tlang(m, "admin.mute.muted_user")).format(
+            admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
+            muted=(await mention_html(user_first_name, user_id)),
+        )
+        if reason:
+            txt += f"\n<b>Reason</b>: {reason}"
+        keyboard = InlineKeyboardMarkup(
+            [
+                [
+                    InlineKeyboardButton(
+                        "Unmute",
+                        callback_data=f"unmute_={user_id}",
+                    ),
+                ],
+            ],
+        )
+        await c.send_message(m.chat.id, txt, reply_markup=keyboard)
+    except ChatAdminRequired:
+        await m.reply_text(tlang(m, "admin.not_admin"))
+    except RightForbidden:
+        await m.reply_text(tlang(m, "admin.mute.bot_no_right"))
+    except UserNotParticipant:
+        await m.reply_text("How can I mute a user who is not a part of this chat?")
+    except RPCError as ef:
+        await m.reply_text(
+            (tlang(m, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=ef,
+            ),
+        )
+        LOGGER.error(ef)
+
+    return
+
+
+@Gojo.on_message(command("unmute") & restrict_filter)
+async def unmute_usr(c: Gojo, m: Message):
+    if len(m.text.split()) == 1 and not m.reply_to_message:
+        await m.reply_text("I can't unmute nothing!")
+        return
+
+    try:
+        user_id, user_first_name, _ = await extract_user(c, m)
+    except Exception:
+        return
+
+    if user_id == Config.BOT_ID:
+        await m.reply_text("Huh, why would I unmute myself if you are using me?")
+        return
+
+    try:
+        await m.chat.unban_member(user_id)
+        LOGGER.info(f"{m.from_user.id} unmuted {user_id} in {m.chat.id}")
+        await m.reply_text(
+            (tlang(m, "admin.unmute.unmuted_user")).format(
+                admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
+                unmuted=(await mention_html(user_first_name, user_id)),
+            ),
+        )
+    except ChatAdminRequired:
+        await m.reply_text(tlang(m, "admin.not_admin"))
+    except UserNotParticipant:
+        await m.reply_text("How can I unmute a user who is not a part of this chat?")
+    except RightForbidden:
+        await m.reply_text(tlang(m, "admin.unmute.bot_no_right"))
+    except RPCError as ef:
+        await m.reply_text(
+            (tlang(m, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=ef,
+            ),
+        )
+        LOGGER.error(ef)
+    return
+
+
+@Gojo.on_callback_query(regex("^unmute_"))
+async def unmutebutton(c: Gojo, q: CallbackQuery):
+    splitter = (str(q.data).replace("unmute_", "")).split("=")
+    user_id = int(splitter[1])
+    user = await q.message.chat.get_member(q.from_user.id)
+
+    if not user.can_restrict_members and user.id != OWNER_ID:
+        await q.answer(
+            "You don't have enough permission to do this!\nStay in your limits!",
+            show_alert=True,
+        )
+        return
+    whoo = await c.get_users(user_id)
+    try:
+        await q.message.chat.unban_member(user_id)
+    except RPCError as e:
+        await q.message.edit_text(f"Error: {e}")
+        return
+    await q.message.edit_text(f"{q.from_user.mention} unmuted {whoo.mention}!")
+    return
+
+
+__PLUGIN__ = "muting"
+
+__alt_name__ = [
+    "mute",
+    "tmute",
+    "unmute",
+]

Powers/plugins/notes.py

@@ -0,0 +1,426 @@
+from secrets import choice
+from traceback import format_exc
+
+from pyrogram import filters
+from pyrogram.errors import RPCError
+from pyrogram.types import CallbackQuery, InlineKeyboardMarkup, Message
+
+from Powers import LOGGER
+from Powers.bot_class import Gojo
+from Powers.database.notes_db import Notes, NotesSettings
+from Powers.utils.cmd_senders import send_cmd
+from Powers.utils.custom_filters import admin_filter, command, owner_filter
+from Powers.utils.kbhelpers import ikb
+from Powers.utils.msg_types import Types, get_note_type
+from Powers.utils.string import (
+    build_keyboard,
+    escape_mentions_using_curly_brackets,
+    parse_button,
+)
+from Powers.vars import Config
+
+# Initialise
+db = Notes()
+db_settings = NotesSettings()
+
+
+@Gojo.on_message(command("save") & admin_filter & ~filters.bot)
+async def save_note(_, m: Message):
+    existing_notes = {i[0] for i in db.get_all_notes(m.chat.id)}
+    name, text, data_type, content = await get_note_type(m)
+    total_notes = db.get_all_notes(m.chat.id)
+
+    if len(total_notes) >= 1000:
+        await m.reply_text(
+            "Only 1000 Notes are allowed per chat!\nTo add more Notes, remove the existing ones.",
+        )
+        return
+
+    if not name:
+        await m.reply_text(
+            f"<code>{m.text}</code>\n\nError: You must give a name for this note!",
+        )
+        return
+    note_name = name.lower()
+    if note_name in existing_notes:
+        await m.reply_text(f"This note ({note_name}) already exists!")
+        return
+
+    if note_name.startswith("<") or note_name.startswith(">"):
+        await m.reply_text("Cannot save a note which starts with '<' or '>'")
+        return
+
+    if not m.reply_to_message and data_type == Types.TEXT and len(m.text.split()) < 3:
+        await m.reply_text(f"<code>{m.text}</code>\n\nError: There is no text in here!")
+        return
+
+    if not data_type:
+        await m.reply_text(
+            f"<code>{m.text}</code>\n\nError: There is no data in here!",
+        )
+        return
+
+    db.save_note(m.chat.id, note_name, text, data_type, content)
+    LOGGER.info(f"{m.from_user.id} saved note ({note_name}) in {m.chat.id}")
+    await m.reply_text(
+        f"Saved note <code>{note_name}</code>!\nGet it with <code>/get {note_name}</code> or <code>#{note_name}</code>",
+    )
+    return
+
+
+async def get_note_func(c: Gojo, m: Message, note_name, priv_notes_status):
+    """Get the note in normal mode, with parsing enabled."""
+    reply_text = m.reply_to_message.reply_text if m.reply_to_message else m.reply_text
+    reply_msg_id = m.reply_to_message.message_id if m.reply_to_message else m.message_id
+    if m and not m.from_user:
+        return
+
+    if priv_notes_status:
+
+        note_hash = next(i[1] for i in db.get_all_notes(m.chat.id) if i[0] == note_name)
+        await reply_text(
+            f"Click on the button to get the note <code>{note_name}</code>",
+            reply_markup=ikb(
+                [
+                    [
+                        (
+                            "Click Me!",
+                            f"https://t.me/{Config.BOT_USERNAME}?start=note_{m.chat.id}_{note_hash}",
+                            "url",
+                        ),
+                    ],
+                ],
+            ),
+        )
+        return
+
+    getnotes = db.get_note(m.chat.id, note_name)
+
+    msgtype = getnotes["msgtype"]
+    if not msgtype:
+        await reply_text("<b>Error:</b> Cannot find a type for this note!!")
+        return
+
+    try:
+        # support for random notes texts
+        splitter = "%%%"
+        note_reply = getnotes["note_value"].split(splitter)
+        note_reply = choice(note_reply)
+    except KeyError:
+        note_reply = ""
+
+    parse_words = [
+        "first",
+        "last",
+        "fullname",
+        "id",
+        "username",
+        "mention",
+        "chatname",
+    ]
+    text = await escape_mentions_using_curly_brackets(m, note_reply, parse_words)
+    teks, button = await parse_button(text)
+    button = await build_keyboard(button)
+    button = InlineKeyboardMarkup(button) if button else None
+    textt = teks
+
+    try:
+        if msgtype == Types.TEXT:
+            if button:
+                try:
+                    await reply_text(
+                        textt,
+                        # parse_mode="markdown",
+                        reply_markup=button,
+                        disable_web_page_preview=True,
+                        quote=True,
+                    )
+                    return
+                except RPCError as ef:
+                    await reply_text(
+                        "An error has occured! Cannot parse note.",
+                        quote=True,
+                    )
+                    LOGGER.error(ef)
+                    LOGGER.error(format_exc())
+                    return
+            else:
+                await reply_text(
+                    textt,
+                    # parse_mode="markdown",
+                    quote=True,
+                    disable_web_page_preview=True,
+                )
+                return
+        elif msgtype in (
+            Types.STICKER,
+            Types.VIDEO_NOTE,
+            Types.CONTACT,
+            Types.ANIMATED_STICKER,
+        ):
+            await (await send_cmd(c, msgtype))(
+                m.chat.id,
+                getnotes["fileid"],
+                reply_markup=button,
+                reply_to_message_id=reply_msg_id,
+            )
+        elif button:
+            try:
+                await (await send_cmd(c, msgtype))(
+                    m.chat.id,
+                    getnotes["fileid"],
+                    caption=textt,
+                    # parse_mode="markdown",
+                    reply_markup=button,
+                    reply_to_message_id=reply_msg_id,
+                )
+                return
+            except RPCError as ef:
+                await m.reply_text(
+                    textt,
+                    # parse_mode="markdown",
+                    reply_markup=button,
+                    disable_web_page_preview=True,
+                    reply_to_message_id=reply_msg_id,
+                )
+                LOGGER.error(ef)
+                LOGGER.error(format_exc())
+                return
+        else:
+            await (await send_cmd(c, msgtype))(
+                m.chat.id,
+                getnotes["fileid"],
+                caption=textt,
+                # parse_mode="markdown",
+                reply_markup=button,
+                reply_to_message_id=reply_msg_id,
+            )
+        LOGGER.info(
+            f"{m.from_user.id} fetched note {note_name} (type - {getnotes}) in {m.chat.id}",
+        )
+    except Exception as e:
+        await m.reply_text(f"Error in notes: {e}")
+    return
+
+
+async def get_raw_note(c: Gojo, m: Message, note: str):
+    """Get the note in raw format, so it can updated by just copy and pasting."""
+    all_notes = {i[0] for i in db.get_all_notes(m.chat.id)}
+    if m and not m.from_user:
+        return
+
+    if note not in all_notes:
+        await m.reply_text("This note does not exists!")
+        return
+
+    getnotes = db.get_note(m.chat.id, note)
+    msg_id = m.reply_to_message.message_id if m.reply_to_message else m.message_id
+
+    msgtype = getnotes["msgtype"]
+    if not getnotes:
+        await m.reply_text("<b>Error:</b> Cannot find a type for this note!!")
+        return
+
+    if msgtype == Types.TEXT:
+        teks = getnotes["note_value"]
+        await m.reply_text(teks, parse_mode=None, reply_to_message_id=msg_id)
+    elif msgtype in (
+        Types.STICKER,
+        Types.VIDEO_NOTE,
+        Types.CONTACT,
+        Types.ANIMATED_STICKER,
+    ):
+        await (await send_cmd(c, msgtype))(
+            m.chat.id,
+            getnotes["fileid"],
+            reply_to_message_id=msg_id,
+        )
+    else:
+        teks = getnotes["note_value"] or ""
+        await (await send_cmd(c, msgtype))(
+            m.chat.id,
+            getnotes["fileid"],
+            caption=teks,
+            parse_mode=None,
+            reply_to_message_id=msg_id,
+        )
+    LOGGER.info(
+        f"{m.from_user.id} fetched raw note {note} (type - {getnotes}) in {m.chat.id}",
+    )
+    return
+
+
+@Gojo.on_message(filters.regex(r"^#[^\s]+") & filters.group & ~filters.bot)
+async def hash_get(c: Gojo, m: Message):
+    # If not from user, then return
+
+    try:
+        note = (m.text[1:]).lower()
+    except TypeError:
+        return
+
+    all_notes = {i[0] for i in db.get_all_notes(m.chat.id)}
+
+    if note not in all_notes:
+        # don't reply to all messages starting with #
+        return
+
+    priv_notes_status = db_settings.get_privatenotes(m.chat.id)
+    await get_note_func(c, m, note, priv_notes_status)
+    return
+
+
+@Gojo.on_message(command("get") & filters.group & ~filters.bot)
+async def get_note(c: Gojo, m: Message):
+
+    if len(m.text.split()) == 2:
+        priv_notes_status = db_settings.get_privatenotes(m.chat.id)
+        note = ((m.text.split())[1]).lower()
+        all_notes = {i[0] for i in db.get_all_notes(m.chat.id)}
+
+        if note not in all_notes:
+            await m.reply_text("This note does not exists!")
+            return
+
+        await get_note_func(c, m, note, priv_notes_status)
+    elif len(m.text.split()) == 3 and (m.text.split())[2] in ["noformat", "raw"]:
+        note = ((m.text.split())[1]).lower()
+        await get_raw_note(c, m, note)
+    else:
+        await m.reply_text("Give me a note tag!")
+        return
+
+    return
+
+
+@Gojo.on_message(command(["privnotes", "privatenotes"]) & admin_filter & ~filters.bot)
+async def priv_notes(_, m: Message):
+
+    chat_id = m.chat.id
+    if len(m.text.split()) == 2:
+        option = (m.text.split())[1]
+        if option in ("on", "yes"):
+            db_settings.set_privatenotes(chat_id, True)
+            LOGGER.info(f"{m.from_user.id} enabled privatenotes in {m.chat.id}")
+            msg = "Set private notes to On"
+        elif option in ("off", "no"):
+            db_settings.set_privatenotes(chat_id, False)
+            LOGGER.info(f"{m.from_user.id} disabled privatenotes in {m.chat.id}")
+            msg = "Set private notes to Off"
+        else:
+            msg = "Enter correct option"
+        await m.reply_text(msg)
+    elif len(m.text.split()) == 1:
+        curr_pref = db_settings.get_privatenotes(m.chat.id)
+        msg = msg = f"Private Notes: {curr_pref}"
+        LOGGER.info(f"{m.from_user.id} fetched privatenotes preference in {m.chat.id}")
+        await m.reply_text(msg)
+    else:
+        await m.replt_text("Check help on how to use this command!")
+
+    return
+
+
+@Gojo.on_message(command("notes") & filters.group & ~filters.bot)
+async def local_notes(_, m: Message):
+    LOGGER.info(f"{m.from_user.id} listed all notes in {m.chat.id}")
+    getnotes = db.get_all_notes(m.chat.id)
+
+    if not getnotes:
+        await m.reply_text(f"There are no notes in <b>{m.chat.title}</b>.")
+        return
+
+    msg_id = m.reply_to_message.message_id if m.reply_to_message else m.message_id
+
+    curr_pref = db_settings.get_privatenotes(m.chat.id)
+    if curr_pref:
+
+        pm_kb = ikb(
+            [
+                [
+                    (
+                        "All Notes",
+                        f"https://t.me/{Config.BOT_USERNAME}?start=notes_{m.chat.id}",
+                        "url",
+                    ),
+                ],
+            ],
+        )
+        await m.reply_text(
+            "Click on the button below to get notes!",
+            quote=True,
+            reply_markup=pm_kb,
+        )
+        return
+
+    rply = f"Notes in <b>{m.chat.title}</b>:\n"
+    for x in getnotes:
+        rply += f"-> <code>#{x[0]}</code>\n"
+    rply += "\nYou can get a note by #notename or <code>/get notename</code>"
+
+    await m.reply_text(rply, reply_to_message_id=msg_id)
+    return
+
+
+@Gojo.on_message(command("clear") & admin_filter & ~filters.bot)
+async def clear_note(_, m: Message):
+
+    if len(m.text.split()) <= 1:
+        await m.reply_text("What do you want to clear?")
+        return
+
+    note = m.text.split()[1].lower()
+    getnote = db.rm_note(m.chat.id, note)
+    LOGGER.info(f"{m.from_user.id} cleared note ({note}) in {m.chat.id}")
+    if not getnote:
+        await m.reply_text("This note does not exist!")
+        return
+
+    await m.reply_text(f"Note '`{note}`' deleted!")
+    return
+
+
+@Gojo.on_message(command("clearall") & owner_filter & ~filters.bot)
+async def clear_allnote(_, m: Message):
+
+    all_notes = {i[0] for i in db.get_all_notes(m.chat.id)}
+    if not all_notes:
+        await m.reply_text("No notes are there in this chat")
+        return
+
+    await m.reply_text(
+        "Are you sure you want to clear all notes?",
+        reply_markup=ikb(
+            [[("⚠️ Confirm", "clear_notes"), ("❌ Cancel", "close_admin")]],
+        ),
+    )
+    return
+
+
+@Gojo.on_callback_query(filters.regex("^clear_notes$"))
+async def clearallnotes_callback(_, q: CallbackQuery):
+    user_id = q.from_user.id
+    user_status = (await q.message.chat.get_member(user_id)).status
+    if user_status not in {"creator", "administrator"}:
+        await q.answer(
+            "You're not even an admin, don't try this explosive shit!",
+            show_alert=True,
+        )
+        return
+    if user_status != "creator":
+        await q.answer(
+            "You're just an admin, not owner\nStay in your limits!",
+            show_alert=True,
+        )
+        return
+    db.rm_all_notes(q.message.chat.id)
+    LOGGER.info(f"{user_id} removed all notes in {q.message.chat.id}")
+    await q.message.edit_text("Cleared all notes!")
+    return
+
+
+__PLUGIN__ = "notes"
+
+_DISABLE_CMDS_ = ["notes"]
+
+__alt_name__ = ["groupnotes", "snips", "notes"]

Powers/plugins/pin.py

@@ -0,0 +1,245 @@
+from html import escape as escape_html
+
+from pyrogram.errors import ChatAdminRequired, RightForbidden, RPCError
+from pyrogram.filters import regex
+from pyrogram.types import CallbackQuery, Message
+
+from Powers import LOGGER, SUPPORT_GROUP
+from Powers.bot_class import Gojo
+from Powers.database.pins_db import Pins
+from Powers.tr_engine import tlang
+from Powers.utils.custom_filters import admin_filter, command
+from Powers.utils.kbhelpers import ikb
+from Powers.utils.string import build_keyboard, parse_button
+
+
+@Gojo.on_message(command("pin") & admin_filter)
+async def pin_message(_, m: Message):
+    pin_args = m.text.split(None, 1)
+    if m.reply_to_message:
+        try:
+            disable_notification = True
+
+            if len(pin_args) >= 2 and pin_args[1] in ["alert", "notify", "loud"]:
+                disable_notification = False
+
+            await m.reply_to_message.pin(
+                disable_notification=disable_notification,
+            )
+            LOGGER.info(
+                f"{m.from_user.id} pinned msgid-{m.reply_to_message.message_id} in {m.chat.id}",
+            )
+
+            if m.chat.username:
+                # If chat has a username, use this format
+                link_chat_id = m.chat.username
+                message_link = (
+                    f"https://t.me/{link_chat_id}/{m.reply_to_message.message_id}"
+                )
+            elif (str(m.chat.id)).startswith("-100"):
+                # If chat does not have a username, use this
+                link_chat_id = (str(m.chat.id)).replace("-100", "")
+                message_link = (
+                    f"https://t.me/c/{link_chat_id}/{m.reply_to_message.message_id}"
+                )
+            await m.reply_text(
+                tlang(m, "pin.pinned_msg").format(message_link=message_link),
+                disable_web_page_preview=True,
+            )
+
+        except ChatAdminRequired:
+            await m.reply_text(tlang(m, "admin.not_admin"))
+        except RightForbidden:
+            await m.reply_text(tlang(m, "pin.no_rights_pin"))
+        except RPCError as ef:
+            await m.reply_text(
+                (tlang(m, "general.some_error")).format(
+                    SUPPORT_GROUP=SUPPORT_GROUP,
+                    ef=ef,
+                ),
+            )
+            LOGGER.error(ef)
+    else:
+        await m.reply_text("Reply to a message to pin it!")
+
+    return
+
+
+@Gojo.on_message(command("unpin") & admin_filter)
+async def unpin_message(c: Gojo, m: Message):
+    try:
+        if m.reply_to_message:
+            await c.unpin_chat_message(m.chat.id, m.reply_to_message.message_id)
+            LOGGER.info(
+                f"{m.from_user.id} unpinned msgid: {m.reply_to_message.message_id} in {m.chat.id}",
+            )
+            await m.reply_text(tlang(m, "pin.unpinned_last_msg"))
+        else:
+            await c.unpin_chat_message(m.chat.id)
+            await m.reply_text(tlang(m, "Unpinned last pinned message!"))
+    except ChatAdminRequired:
+        await m.reply_text(tlang(m, "admin.not_admin"))
+    except RightForbidden:
+        await m.reply_text(tlang(m, "pin.no_rights_unpin"))
+    except RPCError as ef:
+        await m.reply_text(
+            (tlang(m, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=ef,
+            ),
+        )
+        LOGGER.error(ef)
+
+    return
+
+
+@Gojo.on_message(command("unpinall") & admin_filter)
+async def unpinall_message(_, m: Message):
+    await m.reply_text(
+        "Do you really want to unpin all messages in this chat?",
+        reply_markup=ikb([[("Yes", "unpin_all_in_this_chat"), ("No", "close_admin")]]),
+    )
+    return
+
+
+@Gojo.on_callback_query(regex("^unpin_all_in_this_chat$"))
+async def unpinall_calllback(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 {"creator", "administrator"}:
+        await q.answer(
+            "You're not even an admin, don't try this explosive shit!",
+            show_alert=True,
+        )
+        return
+    if user_status != "creator":
+        await q.answer(
+            "You're just an admin, not owner\nStay in your limits!",
+            show_alert=True,
+        )
+        return
+    try:
+        await c.unpin_all_chat_messages(q.message.chat.id)
+        LOGGER.info(f"{q.from_user.id} unpinned all messages in {q.message.chat.id}")
+        await q.message.edit_text(tlang(q, "pin.unpinned_all_msg"))
+    except ChatAdminRequired:
+        await q.message.edit_text(tlang(q, "admin.notadmin"))
+    except RightForbidden:
+        await q.message.edit_text(tlang(q, "pin.no_rights_unpin"))
+    except RPCError as ef:
+        await q.message.edit_text(
+            (tlang(q, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=ef,
+            ),
+        )
+        LOGGER.error(ef)
+    return
+
+
+@Gojo.on_message(command("antichannelpin") & admin_filter)
+async def anti_channel_pin(_, m: Message):
+    pinsdb = Pins(m.chat.id)
+
+    if len(m.text.split()) == 1:
+        status = pinsdb.get_settings()["antichannelpin"]
+        await m.reply_text(
+            tlang(m, "pin.antichannelpin.current_status").format(
+                status=status,
+            ),
+        )
+        return
+
+    if len(m.text.split()) == 2:
+        if m.command[1] in ("yes", "on", "true"):
+            pinsdb.antichannelpin_on()
+            LOGGER.info(f"{m.from_user.id} enabled antichannelpin in {m.chat.id}")
+            msg = tlang(m, "pin.antichannelpin.turned_on")
+        elif m.command[1] in ("no", "off", "false"):
+            pinsdb.antichannelpin_off()
+            LOGGER.info(f"{m.from_user.id} disabled antichannelpin in {m.chat.id}")
+            msg = tlang(m, "pin.antichannelpin.turned_off")
+        else:
+            await m.reply_text(tlang(m, "general.check_help"))
+            return
+
+    await m.reply_text(msg)
+    return
+
+
+@Gojo.on_message(command("pinned") & admin_filter)
+async def pinned_message(c: Gojo, m: Message):
+    chat_title = m.chat.title
+    chat = await c.get_chat(chat_id=m.chat.id)
+    msg_id = m.reply_to_message.message_id if m.reply_to_message else m.message_id
+
+    if chat.pinned_message:
+        pinned_id = chat.pinned_message.message_id
+        if m.chat.username:
+            link_chat_id = m.chat.username
+            message_link = f"https://t.me/{link_chat_id}/{pinned_id}"
+        elif (str(m.chat.id)).startswith("-100"):
+            link_chat_id = (str(m.chat.id)).replace("-100", "")
+            message_link = f"https://t.me/c/{link_chat_id}/{pinned_id}"
+
+        await m.reply_text(
+            f"The pinned message of {escape_html(chat_title)} is [here]({message_link}).",
+            reply_to_message_id=msg_id,
+            disable_web_page_preview=True,
+        )
+    else:
+        await m.reply_text(f"There is no pinned message in {escape_html(chat_title)}.")
+
+
+@Gojo.on_message(command("cleanlinked") & admin_filter)
+async def clean_linked(_, m: Message):
+    pinsdb = Pins(m.chat.id)
+
+    if len(m.text.split()) == 1:
+        status = pinsdb.get_settings()["cleanlinked"]
+        await m.reply_text(
+            tlang(m, "pin.antichannelpin.current_status").format(
+                status=status,
+            ),
+        )
+        return
+
+    if len(m.text.split()) == 2:
+        if m.command[1] in ("yes", "on", "true"):
+            pinsdb.cleanlinked_on()
+            LOGGER.info(f"{m.from_user.id} enabled CleanLinked in {m.chat.id}")
+            msg = "Turned on CleanLinked! Now all the messages from linked channel will be deleted!"
+        elif m.command[1] in ("no", "off", "false"):
+            pinsdb.cleanlinked_off()
+            LOGGER.info(f"{m.from_user.id} disabled CleanLinked in {m.chat.id}")
+            msg = "Turned off CleanLinked! Messages from linked channel will not be deleted!"
+        else:
+            await m.reply_text(tlang(m, "general.check_help"))
+            return
+
+    await m.reply_text(msg)
+    return
+
+
+@Gojo.on_message(command("permapin") & admin_filter)
+async def perma_pin(_, m: Message):
+    if m.reply_to_message or len(m.text.split()) > 1:
+        LOGGER.info(f"{m.from_user.id} used permampin in {m.chat.id}")
+        if m.reply_to_message:
+            text = m.reply_to_message.text
+        elif len(m.text.split()) > 1:
+            text = m.text.split(None, 1)[1]
+        teks, button = await parse_button(text)
+        button = await build_keyboard(button)
+        button = ikb(button) if button else None
+        z = await m.reply_text(teks, reply_markup=button)
+        await z.pin()
+    else:
+        await m.reply_text("Reply to a message or enter text to pin it.")
+    await m.delete()
+    return
+
+
+__PLUGIN__ = "pins"
+
+__alt_name__ = ["pin", "unpin"]

Powers/plugins/purge.py

@@ -0,0 +1,121 @@
+from asyncio import sleep
+
+from pyrogram.errors import MessageDeleteForbidden, RPCError
+from pyrogram.types import Message
+
+from Powers import SUPPORT_GROUP
+from Powers.bot_class import Gojo
+from Powers.tr_engine import tlang
+from Powers.utils.custom_filters import admin_filter, command
+
+
+@Gojo.on_message(command("purge") & admin_filter)
+async def purge(c: Gojo, m: Message):
+    if m.chat.type != "supergroup":
+        await m.reply_text(tlang(m, "purge.err_basic"))
+        return
+
+    if m.reply_to_message:
+        message_ids = list(range(m.reply_to_message.message_id, m.message_id))
+
+        def divide_chunks(l: list, n: int = 100):
+            for i in range(0, len(l), n):
+                yield l[i : i + n]
+
+        # Dielete messages in chunks of 100 messages
+        m_list = list(divide_chunks(message_ids))
+
+        try:
+            for plist in m_list:
+                await c.delete_messages(
+                    chat_id=m.chat.id,
+                    message_ids=plist,
+                    revoke=True,
+                )
+            await m.delete()
+        except MessageDeleteForbidden:
+            await m.reply_text(tlang(m, "purge.old_msg_err"))
+            return
+        except RPCError as ef:
+            await m.reply_text(
+                (tlang(m, "general.some_error")).format(
+                    SUPPORT_GROUP=SUPPORT_GROUP,
+                    ef=ef,
+                ),
+            )
+
+        count_del_msg = len(message_ids)
+
+        z = await m.reply_text(
+            (tlang(m, "purge.purge_msg_count")).format(
+                msg_count=count_del_msg,
+            ),
+        )
+        await sleep(3)
+        await z.delete()
+        return
+    await m.reply_text("Reply to a message to start purge !")
+    return
+
+
+@Gojo.on_message(command("spurge") & admin_filter)
+async def spurge(c: Gojo, m: Message):
+    if m.chat.type != "supergroup":
+        await m.reply_text(tlang(m, "purge.err_basic"))
+        return
+
+    if m.reply_to_message:
+        message_ids = list(range(m.reply_to_message.message_id, m.message_id))
+
+        def divide_chunks(l: list, n: int = 100):
+            for i in range(0, len(l), n):
+                yield l[i : i + n]
+
+        # Dielete messages in chunks of 100 messages
+        m_list = list(divide_chunks(message_ids))
+
+        try:
+            for plist in m_list:
+                await c.delete_messages(
+                    chat_id=m.chat.id,
+                    message_ids=plist,
+                    revoke=True,
+                )
+            await m.delete()
+        except MessageDeleteForbidden:
+            await m.reply_text(tlang(m, "purge.old_msg_err"))
+            return
+        except RPCError as ef:
+            await m.reply_text(
+                (tlang(m, "general.some_error")).format(
+                    SUPPORT_GROUP=SUPPORT_GROUP,
+                    ef=ef,
+                ),
+            )
+        return
+    await m.reply_text("Reply to a message to start spurge !")
+    return
+
+
+@Gojo.on_message(
+    command("del") & admin_filter,
+    group=9,
+)
+async def del_msg(c: Gojo, m: Message):
+    if m.chat.type != "supergroup":
+        return
+
+    if m.reply_to_message:
+        await m.delete()
+        await c.delete_messages(
+            chat_id=m.chat.id,
+            message_ids=m.reply_to_message.message_id,
+        )
+    else:
+        await m.reply_text(tlang(m, "purge.what_del"))
+    return
+
+
+__PLUGIN__ = "purges"
+
+__alt_name__ = ["purge", "del", "spurge"]

Powers/plugins/report.py

@@ -0,0 +1,202 @@
+from traceback import format_exc
+
+from pyrogram import filters
+from pyrogram.errors import RPCError
+from pyrogram.types import CallbackQuery, Message
+
+from Powers import LOGGER, 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
+
+
+@Gojo.on_message(
+    command("reports") & (filters.private | admin_filter),
+)
+async def report_setting(_, m: Message):
+    args = m.text.split()
+    db = Reporting(m.chat.id)
+
+    if m.chat.type == "private":
+        if len(args) >= 2:
+            option = args[1].lower()
+            if option in ("yes", "on", "true"):
+                db.set_settings(True)
+                LOGGER.info(f"{m.from_user.id} enabled reports for them")
+                await m.reply_text(
+                    "Turned on reporting! You'll be notified whenever anyone reports something in groups you are admin.",
+                )
+
+            elif option in ("no", "off", "false"):
+                db.set_settings(False)
+                LOGGER.info(f"{m.from_user.id} disabled reports for them")
+                await m.reply_text("Turned off reporting! You wont get any reports.")
+        else:
+            await m.reply_text(
+                f"Your current report preference is: `{(db.get_settings())}`",
+            )
+    elif len(args) >= 2:
+        option = args[1].lower()
+        if option in ("yes", "on", "true"):
+            db.set_settings(True)
+            LOGGER.info(f"{m.from_user.id} enabled reports in {m.chat.id}")
+            await m.reply_text(
+                "Turned on reporting! Admins who have turned on reports will be notified when /report "
+                "or @admin is called.",
+                quote=True,
+            )
+
+        elif option in ("no", "off", "false"):
+            db.set_settings(False)
+            LOGGER.info(f"{m.from_user.id} disabled reports in {m.chat.id}")
+            await m.reply_text(
+                "Turned off reporting! No admins will be notified on /report or @admin.",
+                quote=True,
+            )
+    else:
+        await m.reply_text(
+            f"This group's current setting is: `{(db.get_settings())}`",
+        )
+
+
+@Gojo.on_message(command("report") & filters.group)
+async def report_watcher(c: Gojo, m: Message):
+    if m.chat.type != "supergroup":
+        return
+
+    if not m.from_user:
+        return
+
+    me = await c.get_me()
+    db = Reporting(m.chat.id)
+
+    if (m.chat and m.reply_to_message) and (db.get_settings()):
+        reported_msg_id = m.reply_to_message.message_id
+        reported_user = m.reply_to_message.from_user
+        chat_name = m.chat.title or m.chat.username
+        admin_list = await c.get_chat_members(m.chat.id, filter="administrators")
+
+        if reported_user.id == me.id:
+            await m.reply_text("Nice try.")
+            return
+
+        if reported_user.id in SUPPORT_STAFF:
+            await m.reply_text("Uh? You reporting my support team?")
+            return
+
+        if m.chat.username:
+            msg = (
+                f"<b>⚠️ Report: </b>{m.chat.title}\n"
+                f"<b> • Report by:</b> {(await mention_html(m.from_user.first_name, m.from_user.id))} (<code>{m.from_user.id}</code>)\n"
+                f"<b> • Reported user:</b> {(await mention_html(reported_user.first_name, reported_user.id))} (<code>{reported_user.id}</code>)\n"
+            )
+
+        else:
+            msg = f"{(await mention_html(m.from_user.first_name, m.from_user.id))} is calling for admins in '{chat_name}'!\n"
+
+        link_chat_id = str(m.chat.id).replace("-100", "")
+        link = f"https://t.me/c/{link_chat_id}/{reported_msg_id}"  # message link
+
+        reply_markup = ikb(
+            [
+                [("➡ Message", link, "url")],
+                [
+                    (
+                        "⚠ Kick",
+                        f"report_{m.chat.id}=kick={reported_user.id}={reported_msg_id}",
+                    ),
+                    (
+                        "⛔️ Ban",
+                        f"report_{m.chat.id}=ban={reported_user.id}={reported_msg_id}",
+                    ),
+                ],
+                [
+                    (
+                        "❎ Delete Message",
+                        f"report_{m.chat.id}=del={reported_user.id}={reported_msg_id}",
+                    ),
+                ],
+            ],
+        )
+
+        LOGGER.info(
+            f"{m.from_user.id} reported msgid-{m.reply_to_message.message_id} to admins in {m.chat.id}",
+        )
+        await m.reply_text(
+            (
+                f"{(await mention_html(m.from_user.first_name, m.from_user.id))} "
+                "reported the message to the admins."
+            ),
+            quote=True,
+        )
+
+        for admin in admin_list:
+            if (
+                admin.user.is_bot or admin.user.is_deleted
+            ):  # can't message bots or deleted accounts
+                continue
+            if Reporting(admin.user.id).get_settings():
+                try:
+                    await c.send_message(
+                        admin.user.id,
+                        msg,
+                        reply_markup=reply_markup,
+                        disable_web_page_preview=True,
+                    )
+                    try:
+                        await m.reply_to_message.forward(admin.user.id)
+                        if len(m.text.split()) > 1:
+                            await m.forward(admin.user.id)
+                    except Exception:
+                        pass
+                except Exception:
+                    pass
+                except RPCError as ef:
+                    LOGGER.error(ef)
+                    LOGGER.error(format_exc())
+    return ""
+
+
+@Gojo.on_callback_query(filters.regex("^report_"))
+async def report_buttons(c: Gojo, q: CallbackQuery):
+    splitter = (str(q.data).replace("report_", "")).split("=")
+    chat_id = int(splitter[0])
+    action = str(splitter[1])
+    user_id = int(splitter[2])
+    message_id = int(splitter[3])
+    if action == "kick":
+        try:
+            await c.ban_chat_member(chat_id, user_id)
+            await q.answer("✅ Succesfully kicked")
+            await c.unban_chat_member(chat_id, user_id)
+            return
+        except RPCError as err:
+            await q.answer(
+                f"🛑 Failed to Kick\n<b>Error:</b>\n</code>{err}</code>",
+                show_alert=True,
+            )
+    elif action == "ban":
+        try:
+            await c.ban_chat_member(chat_id, user_id)
+            await q.answer("✅ Succesfully Banned")
+            return
+        except RPCError as err:
+            await q.answer(f"🛑 Failed to Ban\n<b>Error:</b>\n`{err}`", show_alert=True)
+    elif action == "del":
+        try:
+            await c.delete_messages(chat_id, message_id)
+            await q.answer("✅ Message Deleted")
+            return
+        except RPCError as err:
+            await q.answer(
+                f"🛑 Failed to delete message!\n<b>Error:</b>\n`{err}`",
+                show_alert=True,
+            )
+    return
+
+
+__PLUGIN__ = "reporting"
+
+__alt_name__ = ["reports", "report"]

Powers/plugins/rules.py

@@ -0,0 +1,153 @@
+from pyrogram import filters
+from pyrogram.types import CallbackQuery, Message
+
+from Powers import LOGGER
+from Powers.bot_class import Gojo
+from Powers.database.rules_db import Rules
+from Powers.tr_engine import tlang
+from Powers.utils.custom_filters import admin_filter, command
+from Powers.utils.kbhelpers import ikb
+from Powers.vars import Config
+
+
+@Gojo.on_message(command("rules") & filters.group)
+async def get_rules(_, m: Message):
+    db = Rules(m.chat.id)
+    msg_id = m.reply_to_message.message_id if m.reply_to_message else m.message_id
+
+    rules = db.get_rules()
+    LOGGER.info(f"{m.from_user.id} fetched rules in {m.chat.id}")
+    if m and not m.from_user:
+        return
+
+    if not rules:
+        await m.reply_text(
+            (tlang(m, "rules.no_rules")),
+            quote=True,
+        )
+        return
+
+    priv_rules_status = db.get_privrules()
+
+    if priv_rules_status:
+        pm_kb = ikb(
+            [
+                [
+                    (
+                        "Rules",
+                        f"https://t.me/{Config.BOT_USERNAME}?start=rules_{m.chat.id}",
+                        "url",
+                    ),
+                ],
+            ],
+        )
+        await m.reply_text(
+            (tlang(m, "rules.pm_me")),
+            quote=True,
+            reply_markup=pm_kb,
+            reply_to_message_id=msg_id,
+        )
+        return
+
+    formated = rules
+
+    await m.reply_text(
+        (tlang(m, "rules.get_rules")).format(
+            chat=f"<b>{m.chat.title}</b>",
+            rules=formated,
+        ),
+        disable_web_page_preview=True,
+        reply_to_message_id=msg_id,
+    )
+    return
+
+
+@Gojo.on_message(command("setrules") & admin_filter)
+async def set_rules(_, m: Message):
+    db = Rules(m.chat.id)
+    if m and not m.from_user:
+        return
+
+    if m.reply_to_message and m.reply_to_message.text:
+        rules = m.reply_to_message.text.markdown
+    elif (not m.reply_to_message) and len(m.text.split()) >= 2:
+        rules = m.text.split(None, 1)[1]
+    else:
+        return await m.reply_text("Provide some text to set as rules !!")
+
+    if len(rules) > 4000:
+        rules = rules[0:3949]  # Split Rules if len > 4000 chars
+        await m.reply_text("Rules are truncated to 3950 characters!")
+
+    db.set_rules(rules)
+    LOGGER.info(f"{m.from_user.id} set rules in {m.chat.id}")
+    await m.reply_text(tlang(m, "rules.set_rules"))
+    return
+
+
+@Gojo.on_message(
+    command(["pmrules", "privaterules"]) & admin_filter,
+)
+async def priv_rules(_, m: Message):
+    db = Rules(m.chat.id)
+    if m and not m.from_user:
+        return
+
+    if len(m.text.split()) == 2:
+        option = (m.text.split())[1]
+        if option in ("on", "yes"):
+            db.set_privrules(True)
+            LOGGER.info(f"{m.from_user.id} enabled privaterules in {m.chat.id}")
+            msg = tlang(m, "rules.priv_rules.turned_on").format(chat_name=m.chat.title)
+        elif option in ("off", "no"):
+            db.set_privrules(False)
+            LOGGER.info(f"{m.from_user.id} disbaled privaterules in {m.chat.id}")
+            msg = tlang(m, "rules.priv_rules.turned_off").format(chat_name=m.chat.title)
+        else:
+            msg = tlang(m, "rules.priv_rules.no_option")
+        await m.reply_text(msg)
+    elif len(m.text.split()) == 1:
+        curr_pref = db.get_privrules()
+        msg = tlang(m, "rules.priv_rules.current_preference").format(
+            current_option=curr_pref,
+        )
+        LOGGER.info(f"{m.from_user.id} fetched privaterules preference in {m.chat.id}")
+        await m.reply_text(msg)
+    else:
+        await m.replt_text(tlang(m, "general.check_help"))
+
+    return
+
+
+@Gojo.on_message(command("clearrules") & admin_filter)
+async def clear_rules(_, m: Message):
+    db = Rules(m.chat.id)
+    if m and not m.from_user:
+        return
+
+    rules = db.get_rules()
+    if not rules:
+        await m.reply_text(tlang(m, "rules.no_rules"))
+        return
+
+    await m.reply_text(
+        (tlang(m, "rules.clear_rules")),
+        reply_markup=ikb(
+            [[("⚠️ Confirm", "clear_rules"), ("❌ Cancel", "close_admin")]],
+        ),
+    )
+    return
+
+
+@Gojo.on_callback_query(filters.regex("^clear_rules$"))
+async def clearrules_callback(_, q: CallbackQuery):
+    Rules(q.message.chat.id).clear_rules()
+    await q.message.edit_text(tlang(q, "rules.cleared"))
+    LOGGER.info(f"{q.from_user.id} cleared rules in {q.message.chat.id}")
+    await q.answer("Rules for the chat have been cleared!", show_alert=True)
+    return
+
+
+__PLUGIN__ = "rules"
+
+__alt_name__ = ["rule"]

Powers/plugins/start.py

@@ -0,0 +1,213 @@
+from pyrogram import filters
+from pyrogram.errors import MessageNotModified, QueryIdInvalid, UserIsBlocked
+from pyrogram.types import CallbackQuery, Message
+
+from Powers import HELP_COMMANDS, LOGGER
+from Powers.bot_class import Gojo
+from Powers.tr_engine import tlang
+from Powers.utils.custom_filters import command
+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.vars import Config
+
+
+@Gojo.on_message(
+    command("donate") & (filters.group | filters.private),
+)
+async def donate(_, m: Message):
+    LOGGER.info(f"{m.from_user.id} fetched donation text in {m.chat.id}")
+    await m.reply_text(tlang(m, "general.donate_owner"))
+    return
+
+
+@Gojo.on_callback_query(filters.regex("^close_admin$"))
+async def close_admin_callback(_, q: CallbackQuery):
+    user_id = q.from_user.id
+    user_status = (await q.message.chat.get_member(user_id)).status
+    if user_status not in {"creator", "administrator"}:
+        await q.answer(
+            "You're not even an admin, don't try this explosive shit!",
+            show_alert=True,
+        )
+        return
+    if user_status != "creator":
+        await q.answer(
+            "You're just an admin, not owner\nStay in your limits!",
+            show_alert=True,
+        )
+        return
+    await q.message.edit_text("Closed!")
+    await q.answer("Closed menu!", show_alert=True)
+    return
+
+
+@Gojo.on_message(
+    command("start") & (filters.group | filters.private),
+)
+async def start(c: Gojo, m: Message):
+    if m.chat.type == "private":
+        if len(m.text.split()) > 1:
+            help_option = (m.text.split(None, 1)[1]).lower()
+
+            if help_option.startswith("note") and (
+                help_option not in ("note", "notes")
+            ):
+                await get_private_note(c, m, help_option)
+                return
+            if help_option.startswith("rules"):
+                LOGGER.info(f"{m.from_user.id} fetched privaterules in {m.chat.id}")
+                await get_private_rules(c, m, help_option)
+                return
+
+            help_msg, help_kb = await get_help_msg(m, help_option)
+
+            if not help_msg:
+                return
+
+            await m.reply_text(
+                help_msg,
+                parse_mode="markdown",
+                reply_markup=ikb(help_kb),
+                quote=True,
+                disable_web_page_preview=True,
+            )
+            return
+        try:
+            await m.reply_text(
+                (tlang(m, "start.private")),
+                reply_markup=(await gen_start_kb(m)),
+                quote=True,
+                disable_web_page_preview=True,
+            )
+        except UserIsBlocked:
+            LOGGER.warning(f"Bot blocked by {m.from_user.id}")
+    else:
+        await m.reply_text(
+            (tlang(m, "start.group")),
+            quote=True,
+        )
+    return
+
+
+@Gojo.on_callback_query(filters.regex("^start_back$"))
+async def start_back(_, q: CallbackQuery):
+    try:
+        await q.message.edit_text(
+            (tlang(q, "start.private")),
+            reply_markup=(await gen_start_kb(q.message)),
+            disable_web_page_preview=True,
+        )
+    except MessageNotModified:
+        pass
+    await q.answer()
+    return
+
+
+@Gojo.on_callback_query(filters.regex("^commands$"))
+async def commands_menu(_, q: CallbackQuery):
+    keyboard = ikb(
+        [
+            *(await gen_cmds_kb(q)),
+            [(f"« {(tlang(q, 'general.back_btn'))}", "start_back")],
+        ],
+    )
+    try:
+        await q.message.edit_text(
+            (tlang(q, "general.commands_available")),
+            reply_markup=keyboard,
+        )
+    except MessageNotModified:
+        pass
+    except QueryIdInvalid:
+        await q.message.reply_text(
+            (tlang(q, "general.commands_available")),
+            reply_markup=keyboard,
+        )
+    await q.answer()
+    return
+
+
+@Gojo.on_message(command("help"))
+async def help_menu(_, m: Message):
+    if len(m.text.split()) >= 2:
+        help_option = (m.text.split(None, 1)[1]).lower()
+        help_msg, help_kb = await get_help_msg(m, help_option)
+
+        if not help_msg:
+            LOGGER.error(f"No help_msg found for help_option - {help_option}!!")
+            return
+
+        LOGGER.info(
+            f"{m.from_user.id} fetched help for '{help_option}' text in {m.chat.id}",
+        )
+        if m.chat.type == "private":
+            await m.reply_text(
+                help_msg,
+                parse_mode="markdown",
+                reply_markup=ikb(help_kb),
+                quote=True,
+                disable_web_page_preview=True,
+            )
+        else:
+            await m.reply_text(
+                (tlang(m, "start.public_help").format(help_option=help_option)),
+                reply_markup=ikb(
+                    [
+                        [
+                            (
+                                "Help",
+                                f"t.me/{Config.BOT_USERNAME}?start={help_option}",
+                                "url",
+                            ),
+                        ],
+                    ],
+                ),
+            )
+    else:
+        if m.chat.type == "private":
+            keyboard = ikb(
+                [
+                    *(await gen_cmds_kb(m)),
+                    [(f"« {(tlang(m, 'general.back_btn'))}", "start_back")],
+                ],
+            )
+            msg = tlang(m, "general.commands_available")
+        else:
+            keyboard = ikb(
+                [[("Help", f"t.me/{Config.BOT_USERNAME}?start=help", "url")]],
+            )
+            msg = tlang(m, "start.pm_for_help")
+
+        await m.reply_text(
+            msg,
+            reply_markup=keyboard,
+        )
+
+    return
+
+
+@Gojo.on_callback_query(filters.regex("^get_mod."))
+async def get_module_info(_, q: CallbackQuery):
+    module = q.data.split(".", 1)[1]
+
+    help_msg = f"**{(tlang(q, str(module)))}:**\n\n" + tlang(
+        q,
+        HELP_COMMANDS[module]["help_msg"],
+    )
+
+    help_kb = HELP_COMMANDS[module]["buttons"] + [
+        [("« " + (tlang(q, "general.back_btn")), "commands")],
+    ]
+    await q.message.edit_text(
+        help_msg,
+        parse_mode="markdown",
+        reply_markup=ikb(help_kb),
+    )
+    await q.answer()
+    return

Powers/plugins/stats.py

@@ -0,0 +1,68 @@
+from pyrogram.types import Message
+
+from Powers.bot_class import Gojo
+from Powers.database.antispam_db import GBan
+from Powers.database.approve_db import Approve
+from Powers.database.blacklist_db import Blacklist
+from Powers.database.chats_db import Chats
+from Powers.database.disable_db import Disabling
+from Powers.database.filters_db import Filters
+from Powers.database.greetings_db import Greetings
+from Powers.database.notes_db import Notes, NotesSettings
+from Powers.database.pins_db import Pins
+from Powers.database.rules_db import Rules
+from Powers.database.users_db import Users
+from Powers.database.warns_db import Warns, WarnSettings
+from Powers.utils.custom_filters import command
+
+
+@Gojo.on_message(command("stats", dev_cmd=True))
+async def get_stats(_, m: Message):
+    # initialise
+    bldb = Blacklist
+    gbandb = GBan()
+    notesdb = Notes()
+    rulesdb = Rules
+    grtdb = Greetings
+    userdb = Users
+    dsbl = Disabling
+    appdb = Approve
+    chatdb = Chats
+    fldb = Filters()
+    pinsdb = Pins
+    notesettings_db = NotesSettings()
+    warns_db = Warns
+    warns_settings_db = WarnSettings
+
+    replymsg = await m.reply_text("<b><i>Fetching Stats...</i></b>", quote=True)
+    rply = (
+        f"<b>Users:</b> <code>{(userdb.count_users())}</code> in <code>{(chatdb.count_chats())}</code> chats\n"
+        f"<b>Anti Channel Pin:</b> <code>{(pinsdb.count_chats('antichannelpin'))}</code> enabled chats\n"
+        f"<b>Clean Linked:</b> <code>{(pinsdb.count_chats('cleanlinked'))}</code> enabled chats\n"
+        f"<b>Filters:</b> <code>{(fldb.count_filters_all())}</code> in <code>{(fldb.count_filters_chats())}</code> chats\n"
+        f"    <b>Aliases:</b> <code>{(fldb.count_filter_aliases())}</code>\n"
+        f"<b>Blacklists:</b> <code>{(bldb.count_blacklists_all())}</code> in <code>{(bldb.count_blackists_chats())}</code> chats\n"
+        f"    <b>Action Specific:</b>\n"
+        f"        <b>None:</b> <code>{(bldb.count_action_bl_all('none'))}</code> chats\n"
+        f"        <b>Kick</b> <code>{(bldb.count_action_bl_all('kick'))}</code> chats\n"
+        f"        <b>Warn:</b> <code>{(bldb.count_action_bl_all('warn'))}</code> chats\n"
+        f"        <b>Ban</b> <code>{(bldb.count_action_bl_all('ban'))}</code> chats\n"
+        f"<b>Rules:</b> Set in <code>{(rulesdb.count_chats_with_rules())}</code> chats\n"
+        f"    <b>Private Rules:</b> <code>{(rulesdb.count_privrules_chats())}</code> chats\n"
+        f"<b>Warns:</b> <code>{(warns_db.count_warns_total())}</code> in <code>{(warns_db.count_all_chats_using_warns())}</code> chats\n"
+        f"    <b>Users Warned:</b> <code>{(warns_db.count_warned_users())}</code> users\n"
+        f"    <b>Action Specific:</b>\n"
+        f"        <b>Kick</b>: <code>{(warns_settings_db.count_action_chats('kick'))}</code>\n"
+        f"        <b>Mute</b>: <code>{(warns_settings_db.count_action_chats('mute'))}</code>\n"
+        f"        <b>Ban</b>: <code>{warns_settings_db.count_action_chats('ban')}</code>\n"
+        f"<b>Notes:</b> <code>{(notesdb.count_all_notes())}</code> in <code>{(notesdb.count_notes_chats())}</code> chats\n"
+        f"    <b>Private Notes:</b> <code>{(notesettings_db.count_chats())}</code> chats\n"
+        f"<b>GBanned Users:</b> <code>{(gbandb.count_gbans())}</code>\n"
+        f"<b>Welcoming Users in:</b> <code>{(grtdb.count_chats('welcome'))}</code> chats"
+        f"<b>Approved People</b>: <code>{(appdb.count_all_approved())}</code> in <code>{(appdb.count_approved_chats())}</code> chats\n"
+        f"<b>Disabling:</b> <code>{(dsbl.count_disabled_all())}</code> items in <code>{(dsbl.count_disabling_chats())}</code> chats.\n"
+        "<b>Action:</b>\n"
+        f"     <b>Del:</b> Applied in <code>{(dsbl.count_action_dis_all('del'))}</code> chats.\n"
+    )
+    await replymsg.edit_text(rply, parse_mode="html")
+    return

Powers/plugins/utils.py

@@ -0,0 +1,393 @@
+from html import escape
+from io import BytesIO
+from os import remove
+
+from gpytranslate import Translator
+from pyrogram import filters
+from pyrogram.errors import MessageTooLong, PeerIdInvalid, RPCError
+from pyrogram.types import Message
+from tswift import Song
+from wikipedia import summary
+from wikipedia.exceptions import DisambiguationError, PageError
+
+from Powers import (
+    DEV_USERS,
+    LOGGER,
+    OWNER_ID,
+    SUDO_USERS,
+    SUPPORT_GROUP,
+    SUPPORT_STAFF,
+    WHITELIST_USERS,
+)
+from Powers.bot_class import Gojo
+from Powers.database.antispam_db import GBan
+from Powers.database.users_db import Users
+from Powers.tr_engine import tlang
+from Powers.utils.clean_file import remove_markdown_and_html
+from Powers.utils.custom_filters import command
+from Powers.utils.extract_user import extract_user
+from Powers.utils.http_helper import HTTPx, http
+from Powers.utils.kbhelpers import ikb
+from Powers.utils.parser import mention_html
+from Powers.vars import Config
+
+gban_db = GBan()
+
+
+@Gojo.on_message(command("wiki"))
+async def wiki(_, m: Message):
+    LOGGER.info(f"{m.from_user.id} used wiki cmd in {m.chat.id}")
+
+    if len(m.text.split()) <= 1:
+        return await m.reply_text(tlang(m, "general.check_help"))
+
+    search = m.text.split(None, 1)[1]
+    try:
+        res = summary(search)
+    except DisambiguationError as de:
+        return await m.reply_text(
+            f"Disambiguated pages found! Adjust your query accordingly.\n<i>{de}</i>",
+            parse_mode="html",
+        )
+    except PageError as pe:
+        return await m.reply_text(f"<code>{pe}</code>", parse_mode="html")
+    if res:
+        result = f"<b>{search}</b>\n\n"
+        result += f"<i>{res}</i>\n"
+        result += f"""<a href="https://en.wikipedia.org/wiki/{search.replace(" ", "%20")}">Read more...</a>"""
+        try:
+            return await m.reply_text(
+                result,
+                parse_mode="html",
+                disable_web_page_preview=True,
+            )
+        except MessageTooLong:
+            with BytesIO(str.encode(await remove_markdown_and_html(result))) as f:
+                f.name = "result.txt"
+                return await m.reply_document(
+                    document=f,
+                    quote=True,
+                    parse_mode="html",
+                )
+    await m.stop_propagation()
+
+
+@Gojo.on_message(command("gdpr"))
+async def gdpr_remove(_, m: Message):
+    if m.from_user.id in 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!",
+        )
+        return
+
+    Users(m.from_user.id).delete_user()
+    await m.reply_text(
+        "Your personal data has been deleted.\n"
+        "Note that this will not unban you from any chats, as that is telegram data, not Gojo data."
+        " Flooding, warns, and gbans are also preserved, as of "
+        "[this](https://ico.org.uk/for-organisations/guide-to-the-general-data-protection-regulation-gdpr/individual-rights/right-to-erasure/),"
+        " which clearly states that the right to erasure does not apply 'for the performance of a task carried out in the public interest', "
+        "as is the case for the aforementioned pieces of data.",
+        disable_web_page_preview=True,
+    )
+    await m.stop_propagation()
+
+
+@Gojo.on_message(
+    command("lyrics") & (filters.group | filters.private),
+)
+async def get_lyrics(_, m: Message):
+    if len(m.text.split()) <= 1:
+        await m.reply_text(tlang(m, "general.check_help"))
+        return
+
+    query = m.text.split(None, 1)[1]
+    LOGGER.info(f"{m.from_user.id} used lyrics cmd in {m.chat.id}")
+    song = ""
+    if not query:
+        await m.edit_text(tlang(m, "utils.song.no_song_given"))
+        return
+
+    em = await m.reply_text(
+        (tlang(m, "utils.song.searching").format(song_name=query)),
+    )
+    song = Song.find_song(query)
+    if song:
+        if song.lyrics:
+            reply = song.format()
+        else:
+            reply = tlang(m, "utils.song.no_lyrics_found")
+    else:
+        reply = tlang(m, "utils.song.song_not_found")
+    try:
+        await em.edit_text(reply)
+    except MessageTooLong:
+        with BytesIO(str.encode(await remove_markdown_and_html(reply))) as f:
+            f.name = "lyrics.txt"
+            await m.reply_document(
+                document=f,
+            )
+        await em.delete()
+    return
+
+
+@Gojo.on_message(
+    command("id") & (filters.group | filters.private),
+)
+async def id_info(c: Gojo, m: Message):
+    LOGGER.info(f"{m.from_user.id} used id cmd in {m.chat.id}")
+
+    if m.chat.type == "supergroup" and not m.reply_to_message:
+        await m.reply_text((tlang(m, "utils.id.group_id")).format(group_id=m.chat.id))
+        return
+
+    if m.chat.type == "private" and not m.reply_to_message:
+        await m.reply_text((tlang(m, "utils.id.my_id")).format(my_id=m.chat.id))
+        return
+
+    user_id, _, _ = await extract_user(c, m)
+    if user_id:
+        if m.reply_to_message and m.reply_to_message.forward_from:
+            user1 = m.reply_to_message.from_user
+            user2 = m.reply_to_message.forward_from
+            await m.reply_text(
+                (tlang(m, "utils.id.id_main")).format(
+                    orig_sender=(await mention_html(user2.first_name, user2.id)),
+                    orig_id=f"<code>{user2.id}</code>",
+                    fwd_sender=(await mention_html(user1.first_name, user1.id)),
+                    fwd_id=f"<code>{user1.id}</code>",
+                ),
+                parse_mode="HTML",
+            )
+        else:
+            try:
+                user = await c.get_users(user_id)
+            except PeerIdInvalid:
+                await m.reply_text(tlang(m, "utils.no_user_db"))
+                return
+
+            await m.reply_text(
+                f"{(await mention_html(user.first_name, user.id))}'s ID is <code>{user.id}</code>.",
+                parse_mode="HTML",
+            )
+    elif m.chat.type == "private":
+        await m.reply_text(
+            (tlang(m, "utils.id.my_id")).format(
+                my_id=f"<code>{m.chat.id}</code>",
+            ),
+        )
+    else:
+        await m.reply_text(
+            (tlang(m, "utils.id.group_id")).format(
+                group_id=f"<code>{m.chat.id}</code>",
+            ),
+        )
+    return
+
+
+@Gojo.on_message(
+    command("gifid") & (filters.group | filters.private),
+)
+async def get_gifid(_, m: Message):
+    if m.reply_to_message and m.reply_to_message.animation:
+        LOGGER.info(f"{m.from_user.id} used gifid cmd in {m.chat.id}")
+        await m.reply_text(
+            f"Gif ID:\n<code>{m.reply_to_message.animation.file_id}</code>",
+            parse_mode="html",
+        )
+    else:
+        await m.reply_text(tlang(m, "utils.gif_id.reply_gif"))
+    return
+
+
+@Gojo.on_message(
+    command("github") & (filters.group | filters.private),
+)
+async def github(_, m: Message):
+    if len(m.text.split()) == 2:
+        username = m.text.split(None, 1)[1]
+        LOGGER.info(f"{m.from_user.id} used github cmd in {m.chat.id}")
+    else:
+        await m.reply_text(
+            f"Usage: <code>{Config.PREFIX_HANDLER}github username</code>",
+        )
+        return
+
+    URL = f"https://api.github.com/users/{username}"
+    r = await HTTPx.get(URL)
+    if r.status_code == 404:
+        await m.reply_text(f"<code>{username}</code> not found", quote=True)
+        return
+
+    r_json = r.json()
+    url = r_json.get("html_url", None)
+    name = r_json.get("name", None)
+    company = r_json.get("company", None)
+    followers = r_json.get("followers", 0)
+    following = r_json.get("following", 0)
+    public_repos = r_json.get("public_repos", 0)
+    bio = r_json.get("bio", None)
+    created_at = r_json.get("created_at", "Not Found")
+
+    REPLY = (
+        f"<b>GitHub Info for @{username}:</b>"
+        f"\n<b>Name:</b> <code>{name}</code>\n"
+        f"<b>Bio:</b> <code>{bio}</code>\n"
+        f"<b>URL:</b> {url}\n"
+        f"<b>Public Repos:</b> {public_repos}\n"
+        f"<b>Followers:</b> {followers}\n"
+        f"<b>Following:</b> {following}\n"
+        f"<b>Company:</b> <code>{company}</code>\n"
+        f"<b>Created at:</b> <code>{created_at}</code>"
+    )
+
+    await m.reply_text(REPLY, quote=True, disable_web_page_preview=True)
+    return
+
+
+@Gojo.on_message(
+    command("info") & (filters.group | filters.private),
+)
+async def my_info(c: Gojo, m: Message):
+    try:
+        user_id, name, user_name = await extract_user(c, m)
+    except PeerIdInvalid:
+        await m.reply_text(tlang(m, "utils.user_info.peer_id_error"))
+        return
+    except ValueError as ef:
+        if "Peer id invalid" in str(ef):
+            await m.reply_text(tlang(m, "utils.user_info.id_not_found"))
+        return
+    try:
+        user = Users.get_user_info(int(user_id))
+        name = user["name"]
+        user_name = user["username"]
+        user_id = user["_id"]
+    except KeyError:
+        LOGGER.warning(f"Calling api to fetch info about user {user_id}")
+        user = await c.get_users(user_id)
+        name = (
+            escape(user["first_name"] + " " + user["last_name"])
+            if user["last_name"]
+            else user["first_name"]
+        )
+        user_name = user["username"]
+        user_id = user["id"]
+    except PeerIdInvalid:
+        await m.reply_text(tlang(m, "utils.no_user_db"))
+        return
+    except (RPCError, Exception) as ef:
+        await m.reply_text(
+            (tlang(m, "general.some_error")).format(
+                SUPPORT_GROUP=SUPPORT_GROUP,
+                ef=ef,
+            ),
+        )
+        return
+
+    gbanned, reason_gban = gban_db.get_gban(user_id)
+    LOGGER.info(f"{m.from_user.id} used info cmd for {user_id} in {m.chat.id}")
+
+    text = (tlang(m, "utils.user_info.info_text.main")).format(
+        user_id=user_id,
+        user_name=name,
+    )
+
+    if user_name:
+        text += (tlang(m, "utils.user_info.info_text.username")).format(
+            username=user_name,
+        )
+
+    text += (tlang(m, "utils.user_info.info_text.perma_link")).format(
+        perma_link=(await mention_html("Click Here", user_id)),
+    )
+
+    if gbanned:
+        text += f"\nThis user is Globally banned beacuse: {reason_gban}\n"
+
+    if user_id == OWNER_ID:
+        text += tlang(m, "utils.user_info.support_user.owner")
+    elif user_id in DEV_USERS:
+        text += tlang(m, "utils.user_info.support_user.dev")
+    elif user_id in SUDO_USERS:
+        text += tlang(m, "utils.user_info.support_user.sudo")
+    elif user_id in WHITELIST_USERS:
+        text += tlang(m, "utils.user_info.support_user.whitelist")
+
+    await m.reply_text(text, parse_mode="html", disable_web_page_preview=True)
+    return
+
+
+@Gojo.on_message(command("paste"))
+async def paste_it(_, m: Message):
+    replymsg = await m.reply_text((tlang(m, "utils.paste.pasting")), quote=True)
+    try:
+        if m.reply_to_message:
+            if m.reply_to_message.document:
+                dl_loc = await m.reply_to_message.download()
+                with open(dl_loc) as f:
+                    txt = f.read()
+                remove(dl_loc)
+            else:
+                txt = m.reply_to_message.text
+        else:
+            txt = m.text.split(None, 1)[1]
+        ur = "https://hastebin.com/documents"
+        r = await http.post(ur, json={"content": txt})
+        url = f"https://hastebin.com/{r.json().get('key')}"
+        await replymsg.edit_text(
+            (tlang(m, "utils.paste.pasted_nekobin")),
+            reply_markup=ikb([[((tlang(m, "utils.paste.nekobin_btn")), url, "url")]]),
+        )
+        LOGGER.info(f"{m.from_user.id} used paste cmd in {m.chat.id}")
+    except Exception as e:
+        await replymsg.edit_text(f"Error: {e}")
+        return
+    return
+
+
+@Gojo.on_message(command("tr"))
+async def translate(_, m: Message):
+    trl = Translator()
+    if m.reply_to_message and (m.reply_to_message.text or m.reply_to_message.caption):
+        if len(m.text.split()) == 1:
+            target_lang = "en"
+        else:
+            target_lang = m.text.split()[1]
+        if m.reply_to_message.text:
+            text = m.reply_to_message.text
+        else:
+            text = m.reply_to_message.caption
+    else:
+        if len(m.text.split()) <= 2:
+            await m.reply_text(
+                "Provide lang code.\n[Available options](https://telegra.ph/Lang-Codes-11-08).\n<b>Usage:</b> <code>/tr en</code>",
+            )
+            return
+        target_lang = m.text.split(None, 2)[1]
+        text = m.text.split(None, 2)[2]
+    detectlang = await trl.detect(text)
+    try:
+        tekstr = await trl(text, targetlang=target_lang)
+    except ValueError as err:
+        await m.reply_text(f"Error: <code>{str(err)}</code>")
+        return
+    LOGGER.info(f"{m.from_user.id} used translate cmd in {m.chat.id}")
+    return await m.reply_text(
+        f"<b>Translated:</b> from {detectlang} to {target_lang} \n<code>``{tekstr.text}``</code>",
+    )
+
+
+__PLUGIN__ = "utils"
+_DISABLE_CMDS_ = [
+    "paste",
+    "wiki",
+    "id",
+    "gifid",
+    "lyrics",
+    "tr",
+    "github",
+    "git",
+    "info",
+]
+__alt_name__ = ["util", "misc", "tools"]

Powers/plugins/warns.py

@@ -0,0 +1,370 @@
+from time import time
+
+from pyrogram import filters
+from pyrogram.errors import RPCError
+from pyrogram.types import (
+    CallbackQuery,
+    ChatPermissions,
+    InlineKeyboardButton,
+    InlineKeyboardMarkup,
+    Message,
+)
+
+from Powers import LOGGER, SUPPORT_STAFF
+from Powers.bot_class import Gojo
+from Powers.database.rules_db import Rules
+from Powers.database.users_db import Users
+from Powers.database.warns_db import Warns, WarnSettings
+from Powers.tr_engine import tlang
+from Powers.utils.caching import ADMIN_CACHE, admin_cache_reload
+from Powers.utils.custom_filters import admin_filter, command, restrict_filter
+from Powers.utils.extract_user import extract_user
+from Powers.utils.parser import mention_html
+from Powers.vars import Config
+
+
+@Gojo.on_message(
+    command(["warn", "swarn", "dwarn"]) & restrict_filter,
+)
+async def warn(c: Gojo, m: Message):
+    if m.reply_to_message:
+        r_id = m.reply_to_message.message_id
+        if len(m.text.split()) >= 2:
+            reason = m.text.split(None, 1)[1]
+        else:
+            reason = None
+    elif not m.reply_to_message:
+        r_id = m.message_id
+        if len(m.text.split()) >= 3:
+            reason = m.text.split(None, 2)[2]
+        else:
+            reason = None
+    else:
+        reason = None
+
+    if not len(m.command) > 1 and not m.reply_to_message:
+        await m.reply_text("I can't warn nothing! Tell me user whom I should warn")
+        return
+
+    user_id, user_first_name, _ = await extract_user(c, m)
+
+    if user_id == Config.BOT_ID:
+        await m.reply_text("Huh, why would I warn myself?")
+        return
+
+    if user_id in SUPPORT_STAFF:
+        await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
+        LOGGER.info(
+            f"{m.from_user.id} trying to warn {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        return
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = {i[0] for i in (await admin_cache_reload(m, "warn_user"))}
+
+    if user_id in admins_group:
+        await m.reply_text("This user is admin in this chat, I can't warn them!")
+        return
+
+    warn_db = Warns(m.chat.id)
+    warn_settings_db = WarnSettings(m.chat.id)
+
+    _, num = warn_db.warn_user(user_id, reason)
+    warn_settings = warn_settings_db.get_warnings_settings()
+    if num >= warn_settings["warn_limit"]:
+        if warn_settings["warn_mode"] == "kick":
+            await m.chat.ban_member(user_id, until_date=int(time() + 45))
+            action = "kicked"
+        elif warn_settings["warn_mode"] == "ban":
+            await m.chat.ban_member(user_id)
+            action = "banned"
+        elif warn_settings["warn_mode"] == "mute":
+            await m.chat.restrict_member(user_id, ChatPermissions())
+            action = "muted"
+        await m.reply_text(
+            (
+                f"Warnings {num}/{warn_settings['warn_limit']}!"
+                f"\n<b>Reason for last warn</b>:\n{reason}"
+                if reason
+                else "\n"
+                f"{(await mention_html(user_first_name, user_id))} has been <b>{action}!</b>"
+            ),
+            reply_to_message_id=r_id,
+        )
+        await m.stop_propagation()
+
+    rules = Rules(m.chat.id).get_rules()
+    if rules:
+        kb = InlineKeyboardButton(
+            "Rules 📋",
+            url=f"https://t.me/{Config.BOT_USERNAME}?start=rules_{m.chat.id}",
+        )
+    else:
+        kb = InlineKeyboardButton(
+            "Kick ⚠️",
+            callback_data=f"warn.kick.{user_id}",
+        )
+
+    if m.text.split()[0] == "/swarn":
+        await m.delete()
+        await m.stop_propagation()
+    if m.text.split()[0] == "/dwarn":
+        if not m.reply_to_message:
+            await m.reply_text("Reply to a message to delete it and ban the user!")
+            await m.stop_propagation()
+        await m.reply_to_message.delete()
+    txt = f"{(await mention_html(user_first_name, user_id))} has {num}/{warn_settings['warn_limit']} warnings!"
+    txt += f"\n<b>Reason for last warn</b>:\n{reason}" if reason else ""
+    await m.reply_text(
+        txt,
+        reply_markup=InlineKeyboardMarkup(
+            [
+                [
+                    InlineKeyboardButton(
+                        "Remove Warn ❌",
+                        callback_data=f"warn.remove.{user_id}",
+                    ),
+                ]
+                + [kb],
+            ],
+        ),
+        reply_to_message_id=r_id,
+    )
+    await m.stop_propagation()
+
+
+@Gojo.on_message(command("resetwarns") & restrict_filter)
+async def reset_warn(c: Gojo, m: Message):
+
+    if not len(m.command) > 1 and not m.reply_to_message:
+        await m.reply_text("I can't warn nothing! Tell me user whom I should warn")
+        return
+
+    user_id, user_first_name, _ = await extract_user(c, m)
+
+    if user_id == Config.BOT_ID:
+        await m.reply_text("Huh, why would I warn myself?")
+        return
+
+    if user_id in SUPPORT_STAFF:
+        await m.reply_text(
+            "They are support users, cannot be restriced, how am I then supposed to unrestrict them?",
+        )
+        LOGGER.info(
+            f"{m.from_user.id} trying to resetwarn {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        return
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = {i[0] for i in (await admin_cache_reload(m, "reset_warns"))}
+
+    if user_id in admins_group:
+        await m.reply_text("This user is admin in this chat, I can't warn them!")
+        return
+
+    warn_db = Warns(m.chat.id)
+    warn_db.reset_warns(user_id)
+    await m.reply_text(
+        f"Warnings have been reset for {(await mention_html(user_first_name, user_id))}",
+    )
+    return
+
+
+@Gojo.on_message(command("warns") & filters.group)
+async def list_warns(c: Gojo, m: Message):
+
+    user_id, user_first_name, _ = await extract_user(c, m)
+
+    if user_id == Config.BOT_ID:
+        await m.reply_text("Huh, why would I warn myself?")
+        return
+
+    if user_id in SUPPORT_STAFF:
+        await m.reply_text("This user has no warns!")
+        LOGGER.info(
+            f"{m.from_user.id} trying to check warns of {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        return
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = {i[0] for i in (await admin_cache_reload(m, "warns"))}
+
+    if user_id in admins_group:
+        await m.reply_text(
+            "This user is admin in this chat, they don't have any warns!",
+        )
+        return
+
+    warn_db = Warns(m.chat.id)
+    warn_settings_db = WarnSettings(m.chat.id)
+    warns, num_warns = warn_db.get_warns(user_id)
+    warn_settings = warn_settings_db.get_warnings_settings()
+    if not warns:
+        await m.reply_text("This user has no warns!")
+        return
+    msg = f"{(await mention_html(user_first_name,user_id))} has <b>{num_warns}/{warn_settings['warn_limit']}</b> warns!\n\n<b>Reasons:</b>\n"
+    msg += "\n".join([("- No reason" if i is None else f" - {i}") for i in warns])
+    await m.reply_text(msg)
+    return
+
+
+@Gojo.on_message(
+    command(["rmwarn", "removewarn"]) & restrict_filter,
+)
+async def remove_warn(c: Gojo, m: Message):
+
+    if not len(m.command) > 1 and not m.reply_to_message:
+        await m.reply_text(
+            "I can't remove warns of nothing! Tell me user whose warn should be removed!",
+        )
+        return
+
+    user_id, user_first_name, _ = await extract_user(c, m)
+
+    if user_id == Config.BOT_ID:
+        await m.reply_text("Huh, why would I warn myself?")
+        return
+
+    if user_id in SUPPORT_STAFF:
+        await m.reply_text("This user has no warns!")
+        LOGGER.info(
+            f"{m.from_user.id} trying to remove warns of {user_id} (SUPPORT_STAFF) in {m.chat.id}",
+        )
+        return
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = {i[0] for i in (await admin_cache_reload(m, "rmwarn"))}
+
+    if user_id in admins_group:
+        await m.reply_text(
+            "This user is admin in this chat, they don't have any warns!",
+        )
+        return
+
+    warn_db = Warns(m.chat.id)
+    warns, _ = warn_db.get_warns(user_id)
+    if not warns:
+        await m.reply_text("This user has no warnings!")
+        return
+
+    _, num_warns = warn_db.remove_warn(user_id)
+    await m.reply_text(
+        (
+            f"{(await mention_html(user_first_name,user_id))} now has <b>{num_warns}</b> warnings!\n"
+            "Their last warn was removed."
+        ),
+    )
+    return
+
+
+@Gojo.on_callback_query(filters.regex("^warn."))
+async def remove_last_warn_btn(c: Gojo, q: CallbackQuery):
+
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[q.message.chat.id]}
+    except KeyError:
+        admins_group = {i[0] for i in (await admin_cache_reload(q, "warn_btn"))}
+
+    if q.from_user.id not in admins_group:
+        await q.answer("You are not allowed to use this!", show_alert=True)
+        return
+
+    args = q.data.split(".")
+    action = args[1]
+    user_id = int(args[2])
+    chat_id = int(q.message.chat.id)
+    user = Users.get_user_info(int(user_id))
+    user_first_name = user["name"]
+
+    if action == "remove":
+        warn_db = Warns(q.message.chat.id)
+        _, num_warns = warn_db.remove_warn(user_id)
+        await q.message.edit_text(
+            (
+                f"Admin {(await mention_html(q.from_user.first_name, q.from_user.id))} "
+                "removed last warn for "
+                f"{(await mention_html(user_first_name, user_id))}\n"
+                f"<b>Current Warnings:</b> {num_warns}"
+            ),
+        )
+    if action == "kick":
+        try:
+            await c.kick_chat_member(chat_id, user_id, until_date=int(time() + 45))
+            await q.message.edit_text(
+                (
+                    f"Admin {(await mention_html(q.from_user.first_name, q.from_user.id))} "
+                    "kicked user "
+                    f"{(await mention_html(user_first_name, user_id))} for last warning!"
+                ),
+            )
+        except RPCError as err:
+            await q.message.edit_text(
+                f"🛑 Failed to Kick\n<b>Error:</b>\n</code>{err}</code>",
+            )
+
+    await q.answer()
+    return
+
+
+@Gojo.on_message(command(["warnings", "warnsettings"]) & admin_filter)
+async def get_settings(_, m: Message):
+    warn_settings_db = WarnSettings(m.chat.id)
+    settings = warn_settings_db.get_warnings_settings()
+    await m.reply_text(
+        (
+            "This group has these following settings:\n"
+            f"<b>Warn Limit:</b> <code>{settings['warn_limit']}</code>\n"
+            f"<b>Warn Mode:</b> <code>{settings['warn_mode']}</code>"
+        ),
+    )
+    return
+
+
+@Gojo.on_message(command("warnmode") & admin_filter)
+async def warnmode(_, m: Message):
+    warn_settings_db = WarnSettings(m.chat.id)
+    if len(m.text.split()) > 1:
+        wm = (m.text.split(None, 1)[1]).lower()
+        if wm not in ("kick", "ban", "mute"):
+            await m.reply_text(
+                (
+                    "Please choose a valid warn mode!"
+                    "Valid options are: <code>ban</code>,<code>kick</code>,<code>mute</code>"
+                ),
+            )
+            return
+        warnmode_var = warn_settings_db.set_warnmode(wm)
+        await m.reply_text(f"Warn Mode has been set to: {warnmode_var}")
+        return
+    warnmode_var = warn_settings_db.get_warnmode()
+    await m.reply_text(f"This chats current Warn Mode is: {warnmode_var}")
+    return
+
+
+@Gojo.on_message(command("warnlimit") & admin_filter)
+async def warnlimit(_, m: Message):
+    warn_settings_db = WarnSettings(m.chat.id)
+    if len(m.text.split()) > 1:
+        wl = int(m.text.split(None, 1)[1])
+        if not isinstance(wl, int):
+            await m.reply_text("Warn Limit can only be a number!")
+            return
+        warnlimit_var = warn_settings_db.set_warnlimit(wl)
+        await m.reply_text(f"Warn Limit has been set to: {warnlimit_var}")
+        return
+    warnlimit_var = warn_settings_db.get_warnlimit()
+    await m.reply_text(f"This chats current Warn Limit is: {warnlimit_var}")
+    return
+
+
+__PLUGIN__ = "warnings"
+
+__alt_name__ = ["warn", "warning", "warns"]

Powers/plugins/watchers.py

@@ -0,0 +1,229 @@
+from re import escape as re_escape
+from time import time
+from traceback import format_exc
+
+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.bot_class import Gojo
+from Powers.database.antispam_db import ANTISPAM_BANNED, GBan
+from Powers.database.approve_db import Approve
+from Powers.database.blacklist_db import Blacklist
+from Powers.database.group_blacklist import BLACKLIST_CHATS
+from Powers.database.pins_db import Pins
+from Powers.database.warns_db import Warns, WarnSettings
+from Powers.tr_engine import tlang
+from Powers.utils.caching import ADMIN_CACHE, admin_cache_reload
+from Powers.utils.parser import mention_html
+from Powers.utils.regex_utils import regex_searcher
+
+# Initialise
+gban_db = GBan()
+
+
+@Gojo.on_message(filters.linked_channel)
+async def antichanpin_cleanlinked(c: Gojo, m: Message):
+    try:
+        msg_id = m.message_id
+        pins_db = Pins(m.chat.id)
+        curr = pins_db.get_settings()
+        if curr["antichannelpin"]:
+            await c.unpin_chat_message(chat_id=m.chat.id, message_id=msg_id)
+            LOGGER.info(f"AntiChannelPin: msgid-{m.message_id} unpinned in {m.chat.id}")
+        if curr["cleanlinked"]:
+            await c.delete_messages(m.chat.id, msg_id)
+            LOGGER.info(f"CleanLinked: msgid-{m.message_id} cleaned in {m.chat.id}")
+    except ChatAdminRequired:
+        await m.reply_text(
+            "Disabled antichannelpin as I don't have enough admin rights!",
+        )
+        pins_db.antichannelpin_off()
+        LOGGER.warning(f"Disabled antichannelpin in {m.chat.id} as i'm not an admin.")
+    except Exception as ef:
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+
+    return
+
+
+@Gojo.on_message(filters.text & filters.group, group=5)
+async def bl_watcher(_, m: Message):
+    if m and not m.from_user:
+        return
+
+    bl_db = Blacklist(m.chat.id)
+
+    async def perform_action_blacklist(m: Message, action: str, trigger: str):
+        if action == "kick":
+            await m.chat.kick_member(m.from_user.id, int(time() + 45))
+            await m.reply_text(
+                tlang(m, "blacklist.bl_watcher.action_kick").format(
+                    user=m.from_user.username or f"<b>{m.from_user.first_name}</b>",
+                ),
+            )
+
+        elif action == "ban":
+            (
+                await m.chat.kick_member(
+                    m.from_user.id,
+                )
+            )
+            await m.reply_text(
+                tlang(m, "blacklist.bl_watcher.action_ban").format(
+                    user=m.from_user.username or f"<b>{m.from_user.first_name}</b>",
+                ),
+            )
+
+        elif action == "mute":
+            await m.chat.restrict_member(
+                m.from_user.id,
+                ChatPermissions(),
+            )
+
+            await m.reply_text(
+                tlang(m, "blacklist.bl_watcher.action_mute").format(
+                    user=m.from_user.username or f"<b>{m.from_user.first_name}</b>",
+                ),
+            )
+
+        elif action == "warn":
+            warns_settings_db = WarnSettings(m.chat.id)
+            warns_db = Warns(m.chat.id)
+            warn_settings = warns_settings_db.get_warnings_settings()
+            warn_reason = bl_db.get_reason()
+            _, num = warns_db.warn_user(m.from_user.id, warn_reason)
+            if num >= warn_settings["warn_limit"]:
+                if warn_settings["warn_mode"] == "kick":
+                    await m.chat.ban_member(
+                        m.from_user.id,
+                        until_date=int(time() + 45),
+                    )
+                    action = "kicked"
+                elif warn_settings["warn_mode"] == "ban":
+                    await m.chat.ban_member(m.from_user.id)
+                    action = "banned"
+                elif warn_settings["warn_mode"] == "mute":
+                    await m.chat.restrict_member(m.from_user.id, ChatPermissions())
+                    action = "muted"
+                await m.reply_text(
+                    (
+                        f"Warnings {num}/{warn_settings['warn_limit']}\n"
+                        f"{(await mention_html(m.from_user.first_name, m.from_user.id))} has been <b>{action}!</b>"
+                    ),
+                )
+                return
+            await m.reply_text(
+                (
+                    f"{(await mention_html(m.from_user.first_name, m.from_user.id))} warned {num}/{warn_settings['warn_limit']}\n"
+                    # f"Last warn was for:\n<i>{warn_reason}</i>"
+                    f"Last warn was for:\n<i>{warn_reason.format(trigger)}</i>"
+                ),
+            )
+        return
+
+    if m.from_user.id in SUPPORT_STAFF:
+        # Don't work on Support Staff!
+        return
+
+    # If no blacklists, then return
+    chat_blacklists = bl_db.get_blacklists()
+    if not chat_blacklists:
+        return
+
+    # Get admins from admin_cache, reduces api calls
+    try:
+        admin_ids = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admin_ids = await admin_cache_reload(m, "blacklist_watcher")
+
+    if m.from_user.id in admin_ids:
+        return
+
+    # Get approved user from cache/database
+    app_users = Approve(m.chat.id).list_approved()
+    if m.from_user.id in {i[0] for i in app_users}:
+        return
+
+    # Get action for blacklist
+    action = bl_db.get_action()
+    for trigger in chat_blacklists:
+        pattern = r"( |^|[^\w])" + re_escape(trigger) + r"( |$|[^\w])"
+        match = await regex_searcher(pattern, m.text.lower())
+        if not match:
+            continue
+        if match:
+            try:
+                await perform_action_blacklist(m, action, trigger)
+                LOGGER.info(
+                    f"{m.from_user.id} {action}ed for using blacklisted word {trigger} in {m.chat.id}",
+                )
+                await m.delete()
+            except RPCError as ef:
+                LOGGER.error(ef)
+                LOGGER.error(format_exc())
+            break
+    return
+
+
+@Gojo.on_message(filters.user(list(ANTISPAM_BANNED)) & filters.group)
+async def gban_watcher(c: Gojo, m: Message):
+    from Powers import SUPPORT_GROUP
+
+    if m and not m.from_user:
+        return
+
+    try:
+        _banned = gban_db.check_gban(m.from_user.id)
+    except Exception as ef:
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+        return
+
+    if _banned:
+        try:
+            await m.chat.ban_member(m.from_user.id)
+            await m.delete(m.message_id)  # Delete users message!
+            await m.reply_text(
+                (tlang(m, "antispam.watcher_banned")).format(
+                    user_gbanned=(
+                        await mention_html(m.from_user.first_name, m.from_user.id)
+                    ),
+                    SUPPORT_GROUP=SUPPORT_GROUP,
+                ),
+            )
+            LOGGER.info(f"Banned user {m.from_user.id} in {m.chat.id} due to antispam")
+            return
+        except (ChatAdminRequired, UserAdminInvalid):
+            # Bot not admin in group and hence cannot ban users!
+            # TO-DO - Improve Error Detection
+            LOGGER.info(
+                f"User ({m.from_user.id}) is admin in group {m.chat.title} ({m.chat.id})",
+            )
+        except RPCError as ef:
+            await c.send_message(
+                MESSAGE_DUMP,
+                tlang(m, "antispam.gban.gban_error_log").format(
+                    chat_id=m.chat.id,
+                    ef=ef,
+                ),
+            )
+    return
+
+
+@Gojo.on_message(filters.chat(BLACKLIST_CHATS))
+async def bl_chats_watcher(c: Gojo, m: Message):
+    from Powers import SUPPORT_GROUP
+
+    await c.send_message(
+        m.chat.id,
+        (
+            "This is a blacklisted group!\n"
+            f"For Support, Join @{SUPPORT_GROUP}\n"
+            "Now, I'm outta here!"
+        ),
+    )
+    await c.leave_chat(m.chat.id)
+    LOGGER.info(f"Joined and Left blacklisted chat {m.chat.id}")
+    return