Adding flood and minor changes

Powers/database/flood_db.py

@@ -0,0 +1,66 @@
+from threading import RLock
+
+from Powers.database import MongoDB
+from Powers.utils.msg_types import Types
+
+INSERTION_LOCK = RLock()
+
+class Floods(MongoDB):
+    """Class to store flood limit and action of a chat"""
+
+    db_name = "flood"
+
+    def __init__(self):
+        super().__init__(self.db_name)
+
+    def save_flood(
+        self,
+        chat_id: int,
+        limit: int,
+        within: int,
+        action: str,
+    ):
+        with INSERTION_LOCK:
+            curr = self.find_one({"chat_id": chat_id, "limit": limit, "within": within, "action": action})
+            if curr:
+                if not(limit == int(curr['limit']) or within == int(curr['within']) or action == str(curr['action'])):
+                    return self.update(
+                        {
+                            "_id": chat_id,
+                            "limit": limit,
+                            "within": within,
+                            "action": action,
+                        }
+                    )
+            return self.insert_one(
+                {
+                    "chat_id" : chat_id,
+                    "limit": limit,
+                    "within": within,
+                    "action" : action
+                },
+            )
+    
+    def is_chat(self, chat_id: int):
+        with INSERTION_LOCK:
+            curr = self.find_all({"chat_id": chat_id})
+            if curr:
+                action = [str(curr['limit']), str(curr['within']), str(curr['action'])]
+                return action
+            return False
+    
+    def get_action(self, chat_id: int, limit: int, within: int, action: str):
+        with INSERTION_LOCK:
+            curr = self.find_one({"chat_id": chat_id, "limit": limit, "within": within, "action": action})
+            if curr:
+                return curr
+            return "Flood haven't set"
+    
+    def rm_flood(self, chat_id: int, limit: int, within: int, action: str):
+        with INSERTION_LOCK:
+            curr = self.find_one({"chat_id": chat_id, "limit": limit, "within": within, "action": action})
+            if curr:
+                self.delete_one(curr)
+                return True
+            return False
+            

Powers/plugins/bans.py

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

Powers/plugins/flood.py

@@ -0,0 +1,247 @@
+import time
+
+from pyrogram import filters
+from pyrogram.enums import ChatMemberStatus as CMS
+from pyrogram.enums import ChatType as CT
+from pyrogram.errors import RPCError
+from pyrogram.types import (CallbackQuery, InlineKeyboardButton,
+                            InlineKeyboardMarkup, Message)
+
+from Powers import SUPPORT_STAFF
+from Powers.bot_class import Gojo
+from Powers.database.approve_db import Approve
+from Powers.database.flood_db import Floods
+from Powers.utils.custom_filters import admin_filter, command
+from Powers.utils.kbhelpers import ikb
+
+Flood = Floods()
+
+approve = Approve()
+
+on_key = ["on", "start", "disable"]
+off_key = ["off", "end", "enable", "stop"]
+
+close_kb =InlineKeyboardMarkup(
+    [
+        [
+            InlineKeyboardButton(
+                "Close ❌",
+                callback_data="close"
+            )
+        ]
+    ]
+)
+
+action_kb = InlineKeyboardMarkup(
+    [
+        [
+            InlineKeyboardButton(
+                "Mute 🔇",
+                callback_data="mute"
+            ),
+            InlineKeyboardButton(
+                "Ban 🚷",
+                callback_data="ban"
+            ),
+            InlineKeyboardButton(
+                "Kick",
+                callback_data="kick"
+            )
+        ]
+    ]
+)
+
+within_kb = InlineKeyboardMarkup(
+    [
+        [
+            InlineKeyboardButton(
+                "5",
+                callback_data="5"
+            ),
+            InlineKeyboardButton(
+                "10",
+                callback_data="10"
+            ),
+            InlineKeyboardButton(
+                "15",
+                callback_data="15"
+            )
+        ]
+    ]
+)
+
+limit_kb = InlineKeyboardMarkup(
+    [
+        [
+            InlineKeyboardButton(
+                "5",
+                callback_data="l_5"
+            ),
+            InlineKeyboardButton(
+                "10",
+                callback_data="l_10"
+            ),
+            InlineKeyboardButton(
+                "15",
+                callback_data="l_15"
+            )
+        ]
+    ]
+)
+
+@Gojo.on_message(command(['floodaction','actionflood']))
+async def flood_action(c: Gojo, m: Message):
+    if m.chat.type == CT.PRIVATE:
+        await m.reply_text("Use this command in group")
+        return
+    c_id = m.chat.id
+    is_flood = Flood.is_chat(c_id)
+    saction = is_flood[2]
+    if is_flood:
+        await m.reply_text(
+            f"Choose a action given bellow to do when flood happens.\n **CURRENT ACTION** is {saction}",
+            reply_markup=action_kb
+        )
+        return
+    await m.reply_text("Switch on the flood protection first.")
+    return
+
+@Gojo.on_message(command(['setflood', 'flood']) & ~filters.bot & admin_filter)
+async def flood_set(c: Gojo, m: Message):
+    if m.chat.type == CT.PRIVATE:
+        return await m.reply_text("This command is ment to be used in groups.")
+    split = m.text.split(None, 1)
+    c_id = m.chat.id
+    is_flood = Flood.is_chat(c_id)
+    if len(split) == 1:
+        c_id = m.chat.id
+        if is_flood:
+            saction = is_flood[2]
+            slimit = is_flood[0]
+            swithin = is_flood[1]
+            return await m.reply_text(f"Flood is on for this chat\n**Action**:{saction}\n**Messages**:{slimit} within {swithin} sec")
+        return await m.reply_text("Flood protection is off of this chat.")
+    
+    if len(split) == 2:
+        c_id = m.chat.id
+        if split[1].lower() in on_key:
+            Flood.save_flood(m.chat.id, 5, 5, 'mute')
+            await m.reply_text("Flood protection has been started for this group.")
+            return
+        if split[1].lower() in off_key:
+            Flood.rm_flood(m.chat.id, slimit, swithin, saction)
+            await m.reply_text("Flood protection has been stopped for this chat")
+            return
+    await m.reply_text("**Usage:**\n `/setflood on/off`")
+    return
+
+@Gojo.on_callback_query()
+async def callbacks(c: Gojo, q: CallbackQuery):
+    data = q.data
+    if data == "close":
+        await q.message.delete()
+        q.answer("Closed")
+        return
+    c_id = q.message.chat.id
+    is_flood = Flood.is_chat(c_id)
+    saction = is_flood[2]
+    slimit = is_flood[0]
+    swithin = is_flood[1]
+    user = q.from_user.id
+    user_status = (await q.message.chat.get_member(q.from_user.id)).status
+    if user in SUPPORT_STAFF or user_status in [CMS.OWNER, CMS.ADMINISTRATOR]:
+        if data in ["mute", "ban", "kick"]:
+            Flood.save_flood(c_id, slimit, swithin, data)
+            await q.answer("Updated action", show_alert=True)
+            q.edit_message_caption(
+                f"Set the limit of message after the flood protection will be activated\n **CURRENT LIMIT** {slimit} messages",
+                reply_markup=limit_kb
+            )
+            return
+        if data in ["l_5", "l_10", "l_15"]:
+            change = int(data.split("_")[1])
+            Flood.save_flood(c_id, change, swithin, saction)
+            await q.answer("Updated limit", show_alert=True)
+            q.edit_message_caption(
+                f"Set the time with the number of message recived treated as flood\n **CUURENT TIME** {swithin}",
+                reply_markup=within_kb
+            )
+            return
+        if data in ["5", "10", "15"]:
+            change = int(data)
+            Flood.save_flood(c_id, slimit, change, saction)
+            await q.answer("Updated", show_alert=True)
+            q.edit_message_caption(
+                "Flood protection setting has been updated",
+                reply_markup=close_kb
+            )
+            return
+    else:
+        await q.answer(
+            "You don't have enough permission to do this!\nStay in your limits!",
+            show_alert=True,
+            )
+
+@Gojo.on_callback_query(filters.regex("^un_"))
+async def reverse_callbacks(c: Gojo, q: CallbackQuery):
+    data = q.data.split("_")
+    action = data[1]
+    user_id = int(data[2])
+    if action == "ban":
+        user = await q.message.chat.get_member(q.from_user.id)
+        if not user.privileges.can_restrict_members and q.from_user.id in SUPPORT_STAFF:
+            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
+
+    if action == "mute":
+        user = await q.message.chat.get_member(q.from_user.id)
+
+        if not user.privileges.can_restrict_members and user.id in SUPPORT_STAFF:
+            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
+
+@Gojo.on_message(filters.all & ~filters.bot, ~filters.private, 10)
+async def flood_watcher(c: Gojo, m: Message):
+    c_id = m.chat.id
+    u_id = m.from_user.id
+    is_flood = Flood.is_chat(c_id)
+    app_users = Approve(m.chat.id).list_approved()
+    if u_id in {i[0] for i in app_users}:
+        return #return if the user is approved
+    if not is_flood or u_id in SUPPORT_STAFF:
+        return #return if the user is in support_staff
+    user_status = (await m.chat.get_member(m.from_user.id)).status
+    if user_status in [CMS.OWNER, CMS.ADMINISTRATOR]:
+        return #return if the user is owner or admin
+    action = is_flood[2]
+    limit = int(is_flood[0])
+    within = int(is_flood[1])
+    dic = {}
+    for i in str(dic.keys()):
+        if str(c_id) != i:
+            z = {c_id : set()}
+            dic.update(z)
+    dic[c_id].add(u_id)

Powers/plugins/muting.py

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

Powers/plugins/search.py

@@ -0,0 +1,248 @@
+from traceback import format_exc
+
+from pyrogram.types import Message
+from search_engine_parser.core.engines.google import Search as GoogleSearch
+from search_engine_parser.core.engines.myanimelist import Search as AnimeSearch
+from search_engine_parser.core.engines.stackoverflow import \
+    Search as StackSearch
+from search_engine_parser.core.exceptions import (NoResultsFound,
+                                                  NoResultsOrTrafficError)
+
+from Powers import LOGGER, SUPPORT_CHANNEL
+from Powers.bot_class import Gojo
+from Powers.utils.custom_filters import command
+from Powers.utils.kbhelpers import ikb
+
+#have to add youtube
+
+gsearch = GoogleSearch()
+anisearch = AnimeSearch()
+stsearch = StackSearch()
+
+@Gojo.on_message(command('google'))
+async def g_search(c: Gojo, m: Message):
+    split = m.text.split(None, 1)
+    if len(split) == 1:
+        return await m.reply_text("No query given\nDo `/help search` to see how to use it")
+    to_del = await m.reply_text("Searching google...")
+    query = split[1]
+    try:
+        result = await gsearch.async_search(query)
+        keyboard = ikb(
+            [
+                [
+                    (
+                        f"{result[0]['titles']}",
+                        f"{result[0]['links']}",
+                        "url",
+                    ),
+                ],
+                [
+                    (
+                        f"{result[1]['titles']}",
+                        f"{result[1]['links']}",
+                        "url",
+                    ),
+                ],
+                [
+                    (
+                        f"{result[2]['titles']}",
+                        f"{result[2]['links']}",
+                        "url",
+                    ),
+                ],
+                [
+                    (
+                        f"{result[3]['titles']}",
+                        f"{result[3]['links']}",
+                        "url",
+                    ),
+                ],
+                [
+                    (
+                        f"{result[4]['titles']}",
+                        f"{result[4]['links']}",
+                        "url",
+                    ),
+                ],
+            ]
+        )
+
+        txt = f"Here are the results of requested query **{query.upper()}**"
+        await to_del.delete()
+        await m.reply_text(txt, reply_markup=keyboard)
+        return
+    except NoResultsFound:
+        await to_del.delete()
+        await m.reply_text("No result found corresponding to your query")
+        return
+    except NoResultsOrTrafficError:
+        await to_del.delete()
+        await m.reply_text("No result found due to too many traffic")
+        return
+    except Exception as e:
+        await to_del.delete()
+        await m.reply_text(f"Got an error:\nReport it at @{SUPPORT_CHANNEL}")
+        LOGGER.error(e)
+        LOGGER.error(format_exc())
+        return
+
+
+@Gojo.on_message(command('anime'))
+async def anime_search(c: Gojo, m: Message):
+    split = m.text.split(None, 1)
+    if len(split) == 1:
+        return await m.reply_text("No query given\nDo `/help search` to see how to use it")
+    to_del = await m.reply_text("Searching myanimelist...")
+    query = split[1]
+    try:
+        result = await anisearch.async_search(query)
+        keyboard = ikb(
+            [
+                [
+                    (
+                        f"{result[0]['titles']}",
+                        f"{result[0]['links']}",
+                        "url",
+                    ),
+                ],
+                [
+                    (
+                        f"{result[1]['titles']}",
+                        f"{result[1]['links']}",
+                        "url",
+                    ),
+                ],
+                [
+                    (
+                        f"{result[2]['titles']}",
+                        f"{result[2]['links']}",
+                        "url",
+                    ),
+                ],
+                [
+                    (
+                        f"{result[3]['titles']}",
+                        f"{result[3]['links']}",
+                        "url",
+                    ),
+                ],
+                [
+                    (
+                        f"{result[4]['titles']}",
+                        f"{result[4]['links']}",
+                        "url",
+                    ),
+                ],
+            ]
+        )
+
+        txt = f"Here are the results of requested query **{query.upper()}**"
+        await to_del.delete()
+        await m.reply_text(txt, reply_markup=keyboard)
+        return
+    except NoResultsFound:
+        await to_del.delete()
+        await m.reply_text("No result found corresponding to your query")
+        return
+    except NoResultsOrTrafficError:
+        await to_del.delete()
+        await m.reply_text("No result found due to too many traffic")
+        return
+    except Exception as e:
+        await to_del.delete()
+        await m.reply_text(f"Got an error:\nReport it at @{SUPPORT_CHANNEL}")
+        LOGGER.error(e)
+        LOGGER.error(format_exc())
+        return
+
+@Gojo.on_message(command('anime'))
+async def stack_search(c: Gojo, m: Message):
+    split = m.text.split(None, 1)
+    if len(split) == 1:
+        return await m.reply_text("No query given\nDo `/help search` to see how to use it")
+    to_del = await m.reply_text("Searching Stackoverflow...")
+    query = split[1]
+    try:
+        result = await stsearch.async_search(query)
+        keyboard = ikb(
+            [
+                [
+                    (
+                        f"{result[0]['titles']}",
+                        f"{result[0]['links']}",
+                        "url",
+                    ),
+                ],
+                [
+                    (
+                        f"{result[1]['titles']}",
+                        f"{result[1]['links']}",
+                        "url",
+                    ),
+                ],
+                [
+                    (
+                        f"{result[2]['titles']}",
+                        f"{result[2]['links']}",
+                        "url",
+                    ),
+                ],
+                [
+                    (
+                        f"{result[3]['titles']}",
+                        f"{result[3]['links']}",
+                        "url",
+                    ),
+                ],
+                [
+                    (
+                        f"{result[4]['titles']}",
+                        f"{result[4]['links']}",
+                        "url",
+                    ),
+                ],
+            ]
+        )
+
+        txt = f"Here are the results of requested query **{query.upper()}**"
+        await to_del.delete()
+        await m.reply_text(txt, reply_markup=keyboard)
+        return
+    except NoResultsFound:
+        await to_del.delete()
+        await m.reply_text("No result found corresponding to your query")
+        return
+    except NoResultsOrTrafficError:
+        await to_del.delete()
+        await m.reply_text("No result found due to too many traffic")
+        return
+    except Exception as e:
+        await to_del.delete()
+        await m.reply_text(f"Got an error:\nReport it at @{SUPPORT_CHANNEL}")
+        LOGGER.error(e)
+        LOGGER.error(format_exc())
+        return
+
+
+__PLUGIN__ = "search"
+
+
+__alt_name__ = [
+    "google",
+    "anime",
+    "stack",
+]
+
+__HELP__ = """
+**Search**
+
+**Admin only:**
+• /google `<query>` : Search the google for the given query.
+• /anime `<query>`  : Search myanimelist for the given query.
+• /stack `<query>`  : Search stackoverflow for the given query.
+
+
+**Example:**
+`/google pyrogram`: return top 5 reuslts.
+"""

Powers/utils/custom_filters.py

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

Powers/utils/extras.py

@@ -672,4 +672,16 @@ StartPic = [
     "https://te.legra.ph/file/c10f1b32adaf93c1a9fe1.jpg",
     "https://te.legra.ph/file/68c607517cca7d08e8910.jpg",
     "https://te.legra.ph/file/c86855e6d5a5668748ce1.jpg",
+    "https://te.legra.ph/file/e999d233a4a29a7ccc7fa.jpg",
+    "https://te.legra.ph/file/2baf1c80ee22ffe1d73fb.jpg",
+    "https://te.legra.ph/file/29133374260bf9e7786ee.jpg",
+    "https://te.legra.ph/file/0a57ea903409439fadd6a.jpg",
+    "https://te.legra.ph/file/326618accb5f9ab6d2e18.jpg",
+    "https://te.legra.ph/file/2a899cfc97a46bfd2feae.jpg",
+    "https://te.legra.ph/file/f0cd5bcebcd547a507dbf.jpg",
+    "https://te.legra.ph/file/8bcb57e91776e3ed63b60.jpg",
+    "https://te.legra.ph/file/3c569e93c426aa1941ea6.jpg",
+    "https://te.legra.ph/file/1751252a9f0483811e9b9.jpg",
+    "https://te.legra.ph/file/380b862e0248225cc1a45.jpg",
+    "https://te.legra.ph/file/f314f89640ce4b4118e9e.jpg",
 ]

README.md

@@ -60,7 +60,7 @@ The Gojo Satoru is a powerful Group Management bot with awesome plugins and feat
 * Fully open-source
 * Frequently updated
   
-***Can be found on Telegram as __[@iamgojoof6eyes_bot](https://telegram.dog/iamgojoof6eyes_bot)__***
+***Can be found on Telegram as __[@GojoSuperbot](https://telegram.dog/GojoSuperbot)__***
   
 * Feel free to give ideas for next update. Drop your ideas [here](https://github.com/Gojo-Bots/Gojo_Satoru/discussions/new?category=ideas)
 

app.json

@@ -11,7 +11,7 @@
       "Anime"
     ],
     "repository": "https://github.com/Gojo-Bots/Gojo_Satoru",
-    "success_url": "https://t.me/iamgojoof6eyes_bot",
+    "success_url": "https://t.me/GojoSuperbot",
     "env": {
       "BOT_TOKEN": {
         "description": "Your telegram bot token, get from @Botfather in telegram.",