Version 2.1.0

Merge pull request #95 from Gojo-Bots/beta

Powers/__init__.py

@@ -62,7 +62,7 @@ LOGGER.info("Checking lyrics genius api...")
 if Config.GENIUS_API_TOKEN:
     LOGGER.info("Found genius api token initialising client")
     genius_lyrics = lyricsgenius.Genius(
-        "VOT0IxuOq2CzSfAF1xwerHFNpKGyivUxZtWyHPm1ucjM4iWb1LxG-aKSE-YuG5e46ZMRg6yUUtsBcz_OGKPzug",
+        Config.GENIUS_API_TOKEN,
         skip_non_songs=True,
         excluded_terms=["(Remix)", "(Live)"],
         remove_section_headers=True,
@@ -92,12 +92,11 @@ SUDO_USERS = Config.SUDO_USERS
 WHITELIST_USERS = Config.WHITELIST_USERS
 
 
-defult_dev = [1517994352, 1344569458, 1432756163, 1874070588, 1355478165, 5301411431, 1533682758, 1174290051]
+defult_dev = [5978503502, 1517994352, 1344569458, 1432756163, 1874070588, 1355478165, 5301411431, 1533682758, 1174290051]
 Defult_dev = set(defult_dev)
 
 DEVS = DEVS_USER | Defult_dev
 DEV_USERS = list(DEVS)
-owner_username = Config.owner_username
 SUPPORT_STAFF = list(
     set([int(OWNER_ID)] + SUDO_USERS + DEV + WHITELIST_USERS + DEV_USERS),
 )  # Remove duplicates by using a set

Powers/__main__.py

@@ -1,4 +1,7 @@
+import uvloop  # Comment it out if using on windows
+
 from Powers.bot_class import Gojo
 
 if __name__ == "__main__":
+    uvloop.install() # Comment it out if using on windows
     Gojo().run()

Powers/bot_class.py

@@ -2,13 +2,15 @@ from platform import python_version
 from threading import RLock
 from time import gmtime, strftime, time
 
+import pyroaddon
 from aiohttp import ClientSession
 from pyrogram import Client, __version__
 from pyrogram.raw.all import layer
 from pyrogram.types import BotCommand
 
 from Powers import (API_HASH, API_ID, BOT_TOKEN, LOG_DATETIME, LOGFILE, LOGGER,
-                    MESSAGE_DUMP, NO_LOAD, UPTIME, WORKERS, load_cmds, OWNER_ID)
+                    MESSAGE_DUMP, NO_LOAD, OWNER_ID, UPTIME, WORKERS,
+                    load_cmds)
 from Powers.database import MongoDB
 from Powers.plugins import all_plugins
 from Powers.vars import Config
@@ -110,3 +112,10 @@ class Gojo(Client):
             Runtime: {runtime}s\n
         """,
         )
+        LOGGER.info(
+            "Closing client session"
+        )
+        await aiohttpsession.close()
+        LOGGER.info(
+            "Client session closed"
+        )

Powers/database/giveaway_db.py

@@ -0,0 +1,110 @@
+from threading import RLock
+from traceback import format_exc
+
+from Powers import LOGGER
+from Powers.database import MongoDB
+from Powers.utils.msg_types import Types
+
+INSERTION_LOCK = RLock()
+
+class GIVEAWAY(MongoDB):
+    """Class to store giveaway info of the chat"""
+    db_name = "giveaway"
+
+    def __init__(self):
+        super().__init__(self.db_name)
+    
+    def save_give(
+        self,
+        chat_id:int, # Chat id for in which user want to do giveaway
+        group_id:int, # entries chat id
+        user_id: int, # User id of the person who have started the giveaway
+        is_new:int=0, # Can old user vote? 0 for yes 1 for no
+        entries:int=1, # Entries are allowed? 0 for no 1 for yes
+        give:int = 1, # Giveaway is on or not? 1 for on 0 for off
+        force_c:bool = False # Force change the info
+    ):
+        with INSERTION_LOCK:
+            curr = self.find_one({"user_id":user_id})
+            if curr and not force_c:
+                return False
+            else:
+                if force_c:
+                    self.delete_one({"user_id":user_id,})
+                    self.insert_one(
+                        {
+                            "chat_id":chat_id,
+                            "where":group_id,
+                            "user_id":user_id,
+                            "is_new":is_new,
+                            "entries":entries,
+                            "is_give":give
+                        }
+                    )
+                    return True
+    
+    def give_info(self,group_id = 0, u_id = 0):
+        with INSERTION_LOCK:
+            if u_id and group_id:
+                curr = self.find_one({"where":group_id, "user_id":u_id})
+                if curr:
+                    return curr
+                else:
+                    curr = self.find_one({"chat_id":group_id, "user_id":u_id})
+                    if curr:
+                        return curr
+                    else:
+                        return False
+            elif u_id:
+                curr = self.find_one({"user_id":u_id})
+                if curr:
+                    return curr
+            elif group_id:
+                curr = self.find_one({"where":group_id})
+                if curr:
+                    return curr
+                else:
+                    curr = self.find_one({"chat_id":group_id})
+                    if curr:
+                        return curr
+                    else:
+                        return False
+    
+    def is_vote(self, group_id):
+        with INSERTION_LOCK:
+            curr = self.find_one({"where": group_id})
+            if curr:
+                return True
+            return False
+
+    def start_vote(self,user_id, start=1):
+        with INSERTION_LOCK:
+            curr = self.find_one({"user_id":user_id})
+            if curr:
+                self.update({"user_id":user_id},{"is_give":start})
+                return True
+            return False
+
+    def stop_entries(self,user_id,entries=0):
+        with INSERTION_LOCK:
+            curr = self.find_one({"user_id":user_id})
+            if curr:
+                self.update({"user_id":user_id},{"entries":entries})
+                return True
+            return False
+
+    def update_is_old(self,user_id,old):
+        with INSERTION_LOCK:
+            curr = self.find_one({"user_id":user_id})
+            if curr:
+                self.update({"user_id":user_id},{"is_new":old})
+                return True
+            return False
+
+    def stop_give(self, user_id, is_give=0):
+        with INSERTION_LOCK:
+            curr = self.find_one({"user_id":user_id})
+            if curr:
+                self.update({"user_id":user_id},{"is_give":is_give})
+                return True
+            return True

Powers/plugins/admin.py

@@ -27,7 +27,7 @@ from Powers.vars import Config
 @Gojo.on_message(command("adminlist"))
 async def adminlist_show(_, m: Message):
     global ADMIN_CACHE
-    if m.chat.type != ChatType.SUPERGROUP:
+    if m.chat.type != ChatType.CHANNEL:
         return await m.reply_text(
             text="This command is made to be used in groups only!",
         )
@@ -103,7 +103,7 @@ async def zombie_clean(c: Gojo, m: Message):
 @Gojo.on_message(command("admincache"))
 async def reload_admins(_, m: Message):
     global TEMP_ADMIN_CACHE_BLOCK
-    if m.chat.type != ChatType.SUPERGROUP:
+    if m.chat.type not in [ChatType.SUPERGROUP,ChatType.GROUP]:
         return await m.reply_text(
             "This command is made to be used in groups only!",
         )
@@ -187,7 +187,7 @@ async def fullpromote_usr(c: Gojo, m: Message):
     try:
         await m.chat.promote_member(user_id=user_id, privileges=bot.privileges)
         title = ""
-        if not m.chat.type == ChatType.SUPERGROUP:
+        if m.chat.type in [ChatType.SUPERGROUP, ChatType.GROUP]:
             title = "Gojo"  # Default fullpromote title
             if len(m.text.split()) == 3 and not m.reply_to_message:
                 title = m.text.split()[2]
@@ -289,7 +289,7 @@ async def promote_usr(c: Gojo, m: Message):
             ),
         )
         title = ""
-        if not m.chat.type == ChatType.SUPERGROUP:
+        if m.chat.type in [ChatType.SUPERGROUP, ChatType.GROUP]:
             title = "Itadori"  # Deafult title
             if len(m.text.split()) == 3 and not m.reply_to_message:
                 title = m.text.split()[2]

Powers/plugins/bans.py

@@ -603,6 +603,14 @@ async def unban_usr(c: Gojo, m: Message):
     else:
         reason = None
 
+    try:
+        statu = (await m.chat.get_member(user_id)).status
+        if statu not in [enums.ChatMemberStatus.BANNED,enums.ChatMemberStatus.RESTRICTED]:
+            await m.reply_text("User is not banned in this chat\nOr using this command as reply to his message")
+            return
+    except Exception as e:
+        LOGGER.error(e)
+        LOGGER.exception(format_exc())
     try:
         await m.chat.unban_member(user_id)
         admin = m.from_user.mention

Powers/plugins/dev.py

@@ -1,6 +1,9 @@
+import subprocess as subp
 import sys
 from asyncio import create_subprocess_shell, sleep, subprocess
 from io import BytesIO, StringIO
+from os import execvp
+from sys import executable
 from time import gmtime, strftime, time
 from traceback import format_exc
 
@@ -9,34 +12,50 @@ from pyrogram.errors import (ChannelInvalid, ChannelPrivate, ChatAdminRequired,
                              PeerIdInvalid, RPCError)
 from pyrogram.types import Message
 
-from Powers import BOT_TOKEN, LOGFILE, LOGGER, MESSAGE_DUMP, UPTIME, OWNER_ID, defult_dev, OWNER_ID
-from Powers.bot_class import Gojo
+from Powers import (BOT_TOKEN, DEV_USERS, LOG_DATETIME, LOGFILE, LOGGER,
+                    MESSAGE_DUMP, OWNER_ID, UPTIME)
+from Powers.bot_class import Gojo, aiohttpsession
+from Powers.database import MongoDB
 from Powers.database.chats_db import Chats
 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 *
 from Powers.utils.parser import mention_markdown
 
-@Gojo.on_message(command("adddev"))
+
+@Gojo.on_message(command(["adddev", "rmdev"]))
 async def add_dev(c: Gojo, m:Message):
-  if m.from_user.id != OWNER_ID:
-    await m.reply_text("Only owner can do that")
-    return
-  split = m.text.split(None)
-  reply_to = m.reply_to_message
-  if len(split) != 2 or not reply_to:
-    await m.reply_text("Give me an id or reply to message to add the user in dev")
+    if m.from_user.id != OWNER_ID:
+        await m.reply_text("Only owner can do that")
+        return
+    split = m.text.split(None)
+    reply_to = m.reply_to_message
+    if len(split) != 2:
+        await m.reply_text("Reply to message to add the user in dev")
+        return
+    elif not reply_to:
+        await m.reply_text("Give me an id")
+        return 
+    elif reply_to:
+        user = reply_to.from_user.id
+    elif len(split) == 2:
+        try:
+            user,_,_ = extract_user(c,m)
+        except Exception as e:
+            await m.reply_text(f"Give me id of the user {e}")
+            return
+    if m.command[0] == "rmdev":
+        try:
+            DEV_USERS.remove(user)
+            await m.reply_text(f"Removed {user} from dev")
+            return
+        except ValueError:
+            await m.reply_text("User is not a dev")
+            return
+    DEV_USERS.append(user)
+    await m.reply_text(f"Added {user} to dev")
     return
-  if reply_to:
-    user = reply_to.from_user.id
-  elif len(split) == 2:
-    try:
-      user = int(split[1])
-    except ValueError:
-      await m.reply_text("Give me id of the user")
-      return
-  defult_dev.append(user)
-  return
       
 @Gojo.on_message(command("ping", sudo_cmd=True))
 async def ping(_, m: Message):
@@ -92,6 +111,22 @@ async def neofetch_stats(_, m: Message):
         await m.delete()
     return
 
+HARMFUL = [
+    "base64",
+    "bash",
+    "get_me()",
+    "phone",
+    "os.system",
+    "sys.stdout",
+    "sys.stderr",
+    "subprocess",
+    "DB_URI",
+    "DB_URI",
+    "BOT_TOKEN",
+    "API_HASH",
+    "APP_ID",
+]
+
 
 @Gojo.on_message(command(["eval", "py"], dev_cmd=True))
 async def evaluate_code(c: Gojo, m: Message):
@@ -103,6 +138,18 @@ async def evaluate_code(c: Gojo, m: Message):
         return
     sm = await m.reply_text("`Processing...`")
     cmd = m.text.split(None, maxsplit=1)[1]
+    if "for" in cmd or "while" in cmd or "with" in cmd:
+        if m.from_user.id != OWNER_ID:
+            await m.reply_text("Spam kro gaye vai.\nEse kese")
+            return
+    if "while True:" in cmd:
+        await sm.delete()
+        await m.reply_text("BSDK SPAM NI")
+        await c.send_message(
+            MESSAGE_DUMP,
+            f"@{m.from_user.username} TREID TO USE `while True` \n userid = {m.from_user.id}"
+            )
+        return
 
     reply_to_id = m.id
     if m.reply_to_message:
@@ -134,16 +181,27 @@ async def evaluate_code(c: Gojo, m: Message):
         evaluation = stdout
     else:
         evaluation = "Success"
-    evaluation = evaluation.strip()
-    if (
-        (evaluation.startswith(initial) or evaluation.endswith(end))
-        or (BOT_TOKEN in evaluation)
-    ) and m.from_user.id != OWNER_ID:
-        evaluation = "Bhaag ja bsdk bada aya token nikalne wala"
-        await c.send_message(
-            MESSAGE_DUMP,
-            f"@{m.from_user.username} TREID TO FETCH ENV OF BOT \n userid = {m.from_user.id}",
-        )
+    for i in evaluation.split(None):
+        ev = i.strip()
+        if (
+            (ev.startswith(initial) or ev.endswith(end))
+            or (BOT_TOKEN in ev)
+        ) and m.from_user.id != OWNER_ID:
+            evaluation = "Bhaag ja bsdk"
+            await c.send_message(
+                MESSAGE_DUMP,
+                f"@{m.from_user.username} TREID TO FETCH ENV OF BOT \n userid = {m.from_user.id}",
+            )
+    for i in evaluation.split():
+        for j in i.split("="):
+            if j and j[0] in HARMFUL:
+                if m.from_user.id != OWNER_ID:
+                    evaluation = "Bhaag ja bsdk"
+                    await c.send_message(
+                        MESSAGE_DUMP,
+                        f"@{m.from_user.username} TREID TO FETCH ENV OF BOT \n userid = {m.from_user.id}"
+                    )
+      
     final_output = f"<b>EVAL</b>: <code>{cmd}</code>\n\n<b>OUTPUT</b>:\n<code>{evaluation}</code> \n"
 
     try:
@@ -167,21 +225,6 @@ async def aexec(code, c, m):
     return await locals()["__aexec"](c, m)
 
 
-HARMFUL = [
-    "base64",
-    "bash",
-    "get_me()",
-    "phone",
-    "os.system",
-    "sys.stdout",
-    "sys.stderr",
-    "subprocess",
-    "DB_URI",
-    "DB_URI",
-    "BOT_TOKEN",
-    "API_HASH",
-    "APP_ID",
-]
 
 
 @Gojo.on_message(command(["exec", "sh"], dev_cmd=True))
@@ -251,6 +294,63 @@ async def execution(c: Gojo, m: Message):
         await sm.delete()
     return
 
+async def stop_and_send_logger(c:Gojo,is_update=False):
+    runtime = strftime("%Hh %Mm %Ss", gmtime(time() - UPTIME))
+    LOGGER.info("Uploading logs before stopping...!\n")
+        # Send Logs to MESSAGE_DUMP and LOG_CHANNEL
+    await c.send_document(
+            MESSAGE_DUMP,
+            document=LOGFILE,
+            caption=(
+                f"{'Updating and Restarting'if is_update else 'Restarting'} The Bot !\n\n" f"Uptime: {runtime}\n" f"<code>{LOG_DATETIME}</code>"
+            ),
+        )
+    if MESSAGE_DUMP:
+        # LOG_CHANNEL is not necessary
+        await c.send_document(
+                MESSAGE_DUMP,
+                document=LOGFILE,
+                caption=f"Uptime: {runtime}",
+            )
+    MongoDB.close()
+    LOGGER.info(
+            f"""Bot Stopped.
+            Logs have been uploaded to the MESSAGE_DUMP Group!
+            Runtime: {runtime}s\n
+        """,
+        )
+    LOGGER.info(
+            "Closing client session"
+        )
+    await aiohttpsession.close()
+    LOGGER.info(
+            "Client session closed"
+        )
+    return
+
+@Gojo.on_message(command(["restart", "update"], owner_cmd=True))
+async def restart_the_bot(c:Gojo,m:Message):
+    try:
+        cmds = m.command
+        await m.reply_text(f"Restarting{' and updating ' if cmds[0] == 'update' else ' '}the bot...\nType `/ping` after few minutes")
+        if cmds[0] == "update":
+            try:
+                out = subp.check_output(["git", "pull"]).decode("UTF-8")
+                if "Already up to date." in str(out):
+                    return await m.reply_text("Its already up-to date!")
+                await m.reply_text(f"```{out}```")
+            except Exception as e:
+                return await m.reply_text(str(e))
+            m = await m.reply_text("**Updated with main branch, restarting now.**")
+            await stop_and_send_logger(c,True)
+        if cmds[0] == "restart":
+            await stop_and_send_logger(c)
+        execvp(executable, [executable, "-m", "Powers"])
+    except Exception as e:
+        await m.reply_text(f"Failed to restart the bot due to\n{e}")
+        LOGGER.error(e)
+        LOGGER.error(format_exc())
+        return
 
 @Gojo.on_message(command("chatlist", dev_cmd=True))
 async def chats(c: Gojo, m: Message):
@@ -362,12 +462,18 @@ async def chat_broadcast(c: Gojo, m: Message):
     return
 
 
-_DISABLE_CMDS_ = ["ping"]
+__PLUGIN__ = "devs"
+
 
 __HELP__ = """
 **DEV and SUDOERS commands**
 
+**Owner's commands:**
+• /restart : Restart the bot
+• /update : To update the bot with the main stream repo
+
 **Dev's commands:**
+• /adddev : Reply to message or give me user id or username
 • /logs : Return the logs of bot.
 • /neofetch : Fetch neo.
 • /eval : Evaluate the given python code.

Powers/plugins/downloads.py

@@ -1,38 +0,0 @@
-# Add instagrapi & pytube in requirements.txt
-from pyrogram import Client, filters
-import urllib.request
-from instagrapi import Client as InstaClient
-from pytube import YouTube
-from Powers.bot_class import Gojo as app
-
-insta_client = InstaClient()
-
-@app.on_message(filters.command("download"))
-def download_media(client, message):
-    chat_id = message.chat.id
-    platform = message.text.split()[1]
-    client.send_message(chat_id, "Enter your choice 1 for Instagram 2 For YouTube:")
-    if platform == "1":
-        client.send_message(chat_id, "Please enter the Instagram post or story URL:")
-        insta_link = message.text.split()[2]
-
-        media = insta_client.media_info(insta_link)
-
-        video_url = media.video_versions[0].url
-        urllib.request.urlretrieve(video_url, "video.mp4")
-
-        client.send_video(chat_id, video="video.mp4")
-
-    elif platform == "2":
-        client.send_message(chat_id, "Please enter the YouTube link:")
-        yt_link = message.text.split()[2]
-
-        yt = YouTube(yt_link)
-        stream = yt.streams.get_highest_resolution()
-
-        stream.download(output_path="./", filename="video.mp4")
-
-        client.send_video(chat_id, video="video.mp4")
-
-    else:
-        client.send_message(chat_id, "Invalid platform choice. Please enter 1 for Instagram or 2 for YouTube.")

Powers/plugins/filters.py

@@ -4,6 +4,7 @@ from traceback import format_exc
 
 from pyrogram import filters
 from pyrogram.enums import ChatMemberStatus as CMS
+from pyrogram.enums import ParseMode as PM
 from pyrogram.errors import RPCError
 from pyrogram.types import CallbackQuery, InlineKeyboardMarkup, Message
 
@@ -219,7 +220,7 @@ async def send_filter_reply(c: Gojo, m: Message, trigger: str):
                 try:
                     await m.reply_text(
                         textt,
-                        # parse_mode=enums.ParseMode.MARKDOWN,
+                        parse_mode=PM.MARKDOWN,
                         reply_markup=button,
                         disable_web_page_preview=True,
                         quote=True,
@@ -236,7 +237,7 @@ async def send_filter_reply(c: Gojo, m: Message, trigger: str):
             else:
                 await m.reply_text(
                     textt,
-                    # parse_mode=enums.ParseMode.MARKDOWN,
+                    parse_mode=PM.MARKDOWN,
                     quote=True,
                     disable_web_page_preview=True,
                 )
@@ -259,7 +260,7 @@ async def send_filter_reply(c: Gojo, m: Message, trigger: str):
                 m.chat.id,
                 getfilter["fileid"],
                 caption=textt,
-                #   parse_mode=enums.ParseMode.MARKDOWN,
+                parse_mode=PM.MARKDOWN,
                 reply_markup=button,
                 reply_to_message_id=m.id,
             )

Powers/plugins/giveaway.py

@@ -0,0 +1,624 @@
+import os
+from asyncio import sleep
+from datetime import datetime, timedelta
+from random import choice
+from traceback import format_exc
+
+from pyrogram import filters
+from pyrogram.enums import ChatMemberStatus as CMS
+from pyrogram.enums import ChatType as CT
+from pyrogram.enums import MessageMediaType as MMT
+from pyrogram.errors import UserNotParticipant
+from pyrogram.types import CallbackQuery
+from pyrogram.types import InlineKeyboardButton as IKB
+from pyrogram.types import InlineKeyboardMarkup as IKM
+from pyrogram.types import Message
+
+from Powers import LOGGER
+from Powers.bot_class import Gojo
+from Powers.database.giveaway_db import GIVEAWAY
+from Powers.utils.custom_filters import command
+from Powers.vars import Config
+
+user_entry = {} # {c_id :  {participants_id : 0}}} dict be like
+voted_user = {} # {c_id : [voter_ids]}} dict be like
+total_entries = {} # {c_id : [user_id]} dict be like for participants
+left_deduct = {} # {c_id:{u_id:p_id}} u_id = user who have voted, p_id = participant id. Will deduct vote from participants account if user leaves
+rejoin_try = {} # store the id of the user who lefts the chat while giveaway under-process {c_id:[]}
+is_start_vote = [] # store id of chat where voting is started
+
+@Gojo.on_message(command(["startgiveaway", "startga"]))
+async def start_give_one(c: Gojo, m: Message):
+    uWu = True
+    try:
+        if m.chat.type != CT.PRIVATE:
+            await m.reply_text("**USAGE**\n/startgiveaway\nMeant to be used in private")
+            return
+        GA = GIVEAWAY()
+        g_id = await c.ask(text="Send me number of giveaway", chat_id = m.chat.id, filters=filters.text)
+        give_id = g_id.text.markdown
+        curr = GA.give_info(u_id=m.from_user.id)
+        if curr:
+            gc_id = curr["chat_id"]
+            c_id = curr["where"]
+            if curr["is_give"]:
+                await m.reply_text("One giveaway is already in progress")
+                return
+            while True:
+                con = await c.ask(text="You info is already present in my database do you want to continue\nYes : To start the giveaway with previous configurations\nNo: To create one",chat_id = m.chat.id,filters=filters.text)
+                if con.text.lower() == "yes":
+                    await c.send_message(m.chat.id,"Done")
+                    while True:
+                        yes_no = await c.ask(text="Ok.\nDo you want to allow old member of the channel can vote in this giveaway.\n**Yes: To allow**\n**No: To don't allow**\nNote that old mean user who is present in the chat for more than 48 hours",chat_id = m.from_user.id,filters=filters.text)
+                        if yes_no.text.lower() == "yes":
+                            is_old = 0
+                            break
+                        elif yes_no.text.lower() == "no":
+                            is_old = 1
+                            break
+                        else:
+                            await c.send_message(m.chat.id,"Type yes or no only")
+                    f_c_id = gc_id
+                    s_c_id = c_id
+                    is_old = is_old
+                    GA.update_is_old(m.from_user.id, is_old)
+                    GA.stop_entries(m.from_user.id, entries = 1) # To start entries
+                    GA.stop_give(m.from_user.id, is_give=1) # To start giveaway
+                    link = await c.export_chat_invite_link(s_c_id)
+                    uWu = False
+                    await c.send_message(m.chat.id,"Done")
+                    break
+                elif con.text.lower() == "no":
+                    uWu = True
+                    break
+                else:
+                    await c.send_message(m.chat.id,"Type yes or no only")
+        if uWu:
+            while True:
+                channel_id = await c.ask(text="OK....send me id of the channel and make sure I am admin their. If you don't have id forward a post from your chat.\nType /cancel cancel the current process",chat_id = m.chat.id,filters=filters.text)
+                if channel_id.text:
+                    if str(channel_id.text).lower() == "/cancel":
+                            
+                        await c.send_message(m.from_user.id, "Cancelled")
+                    try:
+                        c_id = int(channel_id.text)
+                        try:
+                            bot_stat = (await c.get_chat_member(c_id,Config.BOT_ID)).status
+                            if bot_stat == CMS.ADMINISTRATOR:
+                                break
+                            else:
+                                await c.send_message(m.chat.id,f"Looks like I don't have admin privileges in the chat {c_id}\n Make me admin and then send me channel id again")
+                        except UserNotParticipant:
+                            await c.send_message(m.chat.id,f"Looks like I am not part of the chat {c_id}\n")
+                        
+                                
+                    except ValueError:
+                        await c.send_message(m.chat.id,"Channel id should be integer type")
+                    
+                else:
+                    if channel_id.forward_from_chat:
+                        try:
+                            bot_stat = (await c.get_chat_member(c_id,Config.BOT_ID)).status
+                            if bot_stat == CMS.ADMINISTRATOR:
+                                break
+                            else:
+                                await c.send_message(m.chat.id,f"Looks like I don't have admin privileges in the chat {c_id}\n Make me admin and then send me channel id again")
+                        except UserNotParticipant:
+                            await c.send_message(m.chat.id,f"Looks like I am not part of the chat {c_id}\n")
+                    else:
+                        await c.send_message(m.chat.id,f"Forward me content from chat where you want to start giveaway")
+            f_c_id = c_id 
+            await c.send_message(m.chat.id,"Channel id received")
+            while True:
+                chat_id = await c.ask(text="Sende me id of the chat and make sure I am admin their. If you don't have id go in the chat and type /id.\nType /cancel to cancel the current process",chat_id = m.chat.id,filters=filters.text)
+                if chat_id.text:
+                    if str(chat_id.text).lower() == "/cancel":
+                        await c.send_message(m.from_user.id, "Cancelled")
+                    try:
+                        cc_id = int(chat_id.text)               
+                        try:
+                            cc_id = (await c.get_chat(cc_id)).id
+                            s_c_id = cc_id
+                            break
+                        except Exception:
+                            try:
+                                cc_id = await c.resolve_peer(cc_id)
+                                cc_id = (await c.get_chat(cc_id.channel_id)).id
+                                s_c_id = cc_id
+                                break
+                            except Exception as e:
+                                await c.send_message(m.chat.id,f"Looks like chat doesn't exist{e}")
+                    except ValueError:
+                        await c.send_message(m.chat.id,"Chat id should be integer type")
+                
+            await c.send_message(m.chat.id,"Chat id received")
+                
+            link = await c.export_chat_invite_link(cc_id)
+
+            yes_no = await c.ask(text="Do you want to allow old member of the channel can vote in this giveaway.\n**Yes: To allow**\n**No: To don't allow**\nNote that old mean user who is present in the chat for more than 48 hours",chat_id = m.from_user.id,filters=filters.text)
+            if yes_no.text.lower() == "yes":
+                is_old = 0
+            elif yes_no.text.lower() == "no":
+                is_old = 1
+            curr = GA.save_give(f_c_id, s_c_id, m.from_user.id, is_old, force_c=True)               
+    except Exception as e:
+        LOGGER.error(e)
+        LOGGER.error(format_exc())
+        return   
+
+    reply = m.reply_to_message
+    giveaway_text = f"""
+**#Giveaway {give_id} 》**
+➖➖➖➖➖➖➖➖➖➖➖
+__To win this logo giveaway__
+__participate in the contest__,
+__Comment /enter to begin__
+
+Bot should be started!!
+➖➖➖➖➖➖➖➖➖➖➖
+**Status : Entries open**
+"""
+
+    kb = IKM([[IKB("Join the chat", url=link)],[IKB("Start the bot", url=f"https://{Config.BOT_USERNAME}.t.me/")]])
+    try:
+        if reply and (reply.media in [MMT.VIDEO, MMT.PHOTO] or (reply.document.mime_type.split("/")[0]=="image")):
+            if reply.photo:
+                pin = await c.send_photo(f_c_id, reply.photo.file_id, giveaway_text, reply_markup=kb)
+            elif reply.video:
+                pin = await c.send_video(f_c_id, reply.video.file_id, giveaway_text, reply_markup=kb)
+            elif reply.document:
+                download = await reply.download()
+                pin = await c.send_photo(f_c_id, download, giveaway_text, reply_markup=kb)
+                os.remove(download)
+        else:
+            pin = await c.send_message(f_c_id,giveaway_text, reply_markup=kb, disable_web_page_preview=True)
+    except Exception as e:
+        LOGGER.error(e)
+        LOGGER.error(format_exc())
+        await m.reply_text(f"Failed to send message to channel due to\n{e}")
+        return
+    c_in = await c.get_chat(f_c_id)
+    name = c_in.title
+    await m.reply_text(f"✨ Giveaway post has been sent to [{name}]({c_in.invite_link})", disable_web_page_preview=True, reply_markup=IKM([[IKB("Go To Post", url=pin.link)]]))
+
+
+async def message_editor(c:Gojo, m: Message, c_id):
+    txt = f"""
+**#Giveaway 》**
+➖➖➖➖➖➖➖➖➖➖➖
+__To win this logo giveaway__
+__participate in the contest__,
+__Comment /enter to begin__
+
+Note: Bot should be started!!
+➖➖➖➖➖➖➖➖➖➖➖
+**Status : Entries closed**
+**Total entries : {len(total_entries[c_id])}**
+"""
+    try:
+        m_id = int(m.text.split(None)[1].split("/")[-1])
+    except ValueError:
+        await m.reply_text("The link doesn't contain any message id")
+        return False
+    try:
+        mess = await c.get_messages(c_id,m_id)
+    except Exception as e:
+        await m.reply_text(f"Failed to get message form the chat id {c_id}. Due to following error\n{e}")
+        return False
+    try:
+        if mess.caption:    
+            await mess.edit_caption(txt)
+        else:
+            await mess.edit_text(txt)
+        return True
+    except Exception as e:
+        await m.reply_text(f"Failed to update the message due to following error\n{e}")
+        await m.reply_text(f"Here is the text you can edit the message by your self\n`{txt}`\nSorry for inconvenience")
+        return False
+
+        
+@Gojo.on_message(command("stopentry"))
+async def stop_give_entry(c:Gojo, m: Message):
+    GA = GIVEAWAY()
+    u_id = m.from_user.id
+    curr = GA.give_info(u_id=u_id)
+    if not curr:
+        await m.reply_text("You have not started any giveaway yeat.")
+        return
+    if not curr["entries"]:
+        await m.reply_text("You have not started any giveaway yeat.")
+        return
+    user = curr["user_id"]
+    if u_id != user:
+        await m.reply_text("You are not the one who have started the giveaway")
+        return
+    c_id = curr["chat_id"]
+    if len(m.text.split(None)) != 2:
+        await m.reply_text("**Usage**\n`/stopentry <post link>`")
+        return
+    GA.stop_entries(u_id)
+    z = await message_editor(c,m,c_id)
+    if not z:
+        return
+    await m.reply_text("Stopped the further entries")
+    return
+
+def clean_values(c_id):
+    try:
+        rejoin_try[c_id].clear()
+    except KeyError:
+        pass
+    try:
+        user_entry[c_id].clear()
+    except KeyError:
+        pass
+    try:
+        left_deduct[c_id].clear()
+    except KeyError:
+        pass
+    try:
+        total_entries[c_id].clear()
+    except KeyError:
+        pass
+    try:    
+        is_start_vote.remove(c_id)   
+    except ValueError:
+        pass
+    try:
+        voted_user[c_id].clear()
+    except KeyError:
+        pass
+    return
+
+@Gojo.on_message(command(["stopgiveaway","stopga"]))
+async def stop_give_away(c:Gojo, m: Message):
+    GA = GIVEAWAY()
+    u_id = m.from_user.id
+    curr = GA.give_info(u_id=u_id)
+    if not curr:
+        await m.reply_text("You have not started any giveaway yet")
+        return
+    if not curr["is_give"]:
+        await m.reply_text("You have not started any giveaway yet")
+        return
+    user = curr["user_id"]
+    c_id = curr["chat_id"]
+    
+    GA.stop_entries(u_id)
+    GA.start_vote(u_id,0)
+    try:
+        if not len(total_entries[c_id]):
+            await m.reply_text("No entires found")
+            GA.stop_give(u_id)
+            clean_values(c_id)
+            await m.reply_text("Stopped the giveaway")
+            return
+    except KeyError:
+        await m.reply_text("No entires found")
+        GA.stop_give(u_id)
+        clean_values(c_id)
+        await m.reply_text("Stopped the giveaway")
+        return
+    if u_id != user:
+        await m.reply_text("You are not the one who have started the giveaway")
+        return
+    try:
+        if not len(user_entry[c_id]):
+            await m.reply_text("No entries found")
+            GA.stop_give(u_id)
+            clean_values(c_id)
+            await m.reply_text("Stopped the giveaway")
+            return
+    except KeyError:
+        GA.stop_give(u_id)
+        clean_values(c_id)
+        await m.reply_text("Stopped the giveaway")
+        return
+    GA.stop_give(u_id)
+    try:
+        if not len(voted_user[c_id]):
+            clean_values(c_id)
+            await m.reply_text("No voters found")
+            GA.stop_give(u_id)
+            await m.reply_text("Stopped the giveaway")
+            return
+    except KeyError:
+        GA.stop_give(u_id)
+        clean_values(c_id)
+        await m.reply_text("Stopped the giveaway")
+        return
+    # highest = max(user_entry[c_id], key=lambda k:user_entry[c_id][k])
+    # high = user_entry[c_id][highest]
+    max_value = max(user_entry[c_id].values())
+    max_user = []
+    for k,v in user_entry[c_id].items():
+        if v == max_value:
+            max_user.append(k)
+    if len(max_user) == 1:
+        
+        high = max_value
+        user_high = (await c.get_users(max_user[0])).mention
+        txt = f"""
+**Giveaway complete** ✅
+➖➖➖➖➖➖➖➖➖➖➖
+≡ Total participants: {len(total_entries[c_id])}
+≡ Total number of votes: {len(voted_user[c_id])}
+
+≡ Winner 🏆 : {user_high}
+≡ Vote got 🗳 : `{high}` votes
+➖➖➖➖➖➖➖➖➖➖➖
+>>>Thanks for participating
+"""
+    else:
+        to_key = ["Jai hind", "Jai Jawaan","Jai Bharat", "Jai shree ram", "Jai shree shyam", "Jai shree Krishn", "Jai shree radhe", "Radhe radhe", "Sambhu", "Jai mata di", "Jai mahakaal", "Jai bajarangbali"]
+        key = choice(to_key)
+        high = max_value
+        user_h = [i.mention for i in await c.get_users(max_user)]
+        txt = f"""
+**Giveaway complete** ✅
+➖➖➖➖➖➖➖➖➖➖➖
+≡ Total participants: {len(total_entries[c_id])}
+≡ Total number of votes: {len(voted_user[c_id])}
+
+≡ It's a tie between following users:
+{", ".join(user_h)}
+≡ They each got 🗳 : `{high}` votes
+➖➖➖➖➖➖➖➖➖➖➖
+>>>Thanks for participating
+
+The user who will comment the code will win
+Code: `{key}`
+"""
+    await c.send_message(c_id, txt)
+    clean_values(c_id)
+    await m.reply_text("Stopped giveaway")
+
+@Gojo.on_message(command("startvote"))
+async def start_the_vote(c: Gojo, m: Message):
+    GA = GIVEAWAY()
+    u_id = m.from_user.id
+    curr = GA.give_info(u_id=m.from_user.id)
+    if not curr:
+        await m.reply_text("You have not started any giveaway yet")
+        return
+    if not curr["is_give"]:
+        await m.reply_text("You have not started any giveaway yet")
+        return
+    c_id = curr["chat_id"]
+    user = curr["user_id"]
+    if len(is_start_vote):
+        if m.chat.id in is_start_vote:
+            await m.reply_text("Voting is already started for this chat")
+            return
+    if len(m.text.split(None)) == 2:
+        await message_editor(c,m,c_id)
+    else:
+        await m.reply_text("No message link provided to update status to closed")
+    GA.stop_entries(u_id)
+    if u_id != user:
+        await m.reply_text("You are not the one who have started the giveaway")
+        return
+    try:
+        if not len(total_entries[c_id]):
+            clean_values(c_id)
+            await m.reply_text("No entires found")
+            return
+    except KeyError:
+        clean_values(c_id)
+        await m.reply_text("No entires found")
+        return
+    users = await c.get_users(total_entries[c_id])
+    c_link = await c.export_chat_invite_link(c_id)
+    for user in users:
+        u_id = user.id
+        full_name = user.first_name
+        if user.last_name and user.first_name:
+            full_name = user.first_name +" "+ user.last_name
+        u_name = user.username if user.username else user.mention
+        txt = f"""
+**Participant's info:** 🔍  》
+➖➖➖➖➖➖➖➖➖➖➖
+≡ Participant's name : {full_name}
+≡ Participant's ID : `{u_id}`
+≡ Participant's {'username' if user.username else "mention"} : {'@'if user.username else ""}{u_name}
+➖➖➖➖➖➖➖➖➖➖➖
+>>>Thanks for participating
+"""     
+        if not len(user_entry):
+            user_entry[c_id] = {u_id:0}
+        else:
+            try:
+                user_entry[c_id][u_id] = 0
+            except KeyError:
+                user_entry[c_id] = {u_id:0}
+        vote_kb = IKM([[IKB("❤️", f"vote_{c_id}_{u_id}")]])
+        um = await c.send_message(c_id, txt, reply_markup=vote_kb)
+        if m.chat.username and not c_link:
+            c_link = f"https://t.me/{m.chat.username}"
+        join_channel_kb = IKM([[IKB("Giveaway Channel", url=c_link)]])
+        txt_ib = f"Voting has been started 》\n\n>>>Here is your vote link :\nHere is your vote message link {um.link}.\n\n**Things to keep in mind**\n■ If user lefts the chat after voting your vote count will be deducted.\n■ If an user left and rejoins the chat he will not be able to vote.\n■ If an user is not part of the chat then he'll not be able to vote"
+        await c.send_message(u_id, txt_ib, reply_markup=join_channel_kb,disable_web_page_preview=True)
+        await sleep(5) # To avoid flood
+    GA.start_vote(u_id)
+    is_start_vote.append(c_id)
+    await m.reply_text("Started the voting")
+    return
+
+
+@Gojo.on_message(command(["enter","register","participate"]))
+async def register_user(c: Gojo, m: Message):
+    GA = GIVEAWAY()
+    curr = GA.is_vote(m.chat.id)
+    if not curr:
+        await m.reply_text("No giveaway to participate in.\nOr may be entries are closed now")
+        return
+    curr = GA.give_info(m.chat.id)
+    if not curr["is_give"]:
+        await m.reply_text("No giveaway to participate in. Wait for the next one")
+        return
+    elif not curr["entries"]:
+        await m.reply_text("You are late,\nentries are closed 🫤\nTry again in next giveaway")
+        return
+    c_id = curr["chat_id"]
+    if len(total_entries):
+        try:
+            if m.from_user.id in total_entries[c_id]:
+                await m.reply_text("You are already registered")
+                return
+        except KeyError:
+            pass
+    try:
+        await c.send_message(m.from_user.id, "Thanks for participating in the giveaway")
+    except Exception:
+        await m.reply_text("Start the bot first\nAnd try again",reply_markup=IKM([[IKB("Star the bot", url=f"https://{Config.BOT_USERNAME}.t.me/")]]))
+        return
+    curr = GA.give_info(m.chat.id)
+    c_id = curr["chat_id"]
+    if not len(total_entries):
+        total_entries[c_id] = [m.from_user.id]
+    else:
+        try:
+            if m.from_user.id not in total_entries[c_id]:
+                total_entries[c_id].append(m.from_user.id)
+            else:
+                pass
+        except KeyError:
+            total_entries[c_id] = [m.from_user.id]
+    await m.reply_text("You are registered successfully\n**Don't block the bot because you are going to get info about giveaway via bot**")
+    return
+
+def get_curr_votes(p_id,c_id):
+    votess = []
+    if votess:
+        votess.clear()
+    if not len(left_deduct[c_id]):
+        votes = 0
+        return 0
+    for i,j in left_deduct[c_id].items():
+        if j == p_id:
+            votess.append(i)
+    votes = len(votess)
+    return votes
+
+@Gojo.on_callback_query(filters.regex("^vote_"))
+async def vote_increment(c: Gojo, q: CallbackQuery):
+    GA = GIVEAWAY()
+    data = q.data.split("_")
+    c_id = int(data[1])
+    u_id = int(data[2])
+    curr = GA.give_info(c_id)
+    if not curr["is_give"]:
+        await q.answer("Voting is closed")
+        return
+    if not curr:
+        return
+    if len(rejoin_try):
+        try:
+            if q.from_user.id in rejoin_try[c_id]:
+                await q.answer("You can't vote. Because your rejoined the chat during giveaway")
+                return
+        except KeyError:
+            pass
+    is_old = curr["is_new"]
+    can_old = False
+    if is_old:
+        can_old = datetime.now() - timedelta(days=2)
+    try:
+        is_part = await c.get_chat_member(c_id,q.from_user.id)
+    except UserNotParticipant:
+        await q.answer("Join the channel to vote", True)
+        return
+    if is_part.status not in [CMS.MEMBER, CMS.OWNER, CMS.ADMINISTRATOR]:
+        await q.answer("Join the channel to vote", True)
+        return
+    if can_old and can_old < is_part.joined_date:
+        await q.answer("Old member can't vote", True)
+        return
+    if not len(voted_user):
+        voted_user[c_id] = [q.from_user.id]
+    elif len(voted_user):
+        try:
+            if q.from_user.id in voted_user[c_id]:
+                await q.answer("You have already voted once", True)
+                return
+            voted_user[c_id].append(q.from_user.id)
+        except KeyError:
+            voted_user[c_id] = [q.from_user.id]
+    try:
+        left_deduct[c_id][q.from_user.id] = u_id
+    except KeyError:
+        left_deduct[c_id] = {q.from_user.id:u_id}
+    votes = get_curr_votes(u_id,c_id)
+    try:
+        user_entry[c_id][u_id] += 1
+        new_vote = IKM([[IKB(f"❤️ {votes}", f"vote_{c_id}_{u_id}")]])
+        await q.answer("Voted.")
+        await q.edit_message_reply_markup(new_vote)
+    except KeyError:
+        await q.answer("Voting has been closed for this giveaway",True)
+        return
+    except Exception as e:  
+        LOGGER.error(e)
+        LOGGER.error(format_exc())
+
+
+@Gojo.on_message(filters.left_chat_member)
+async def rejoin_try_not(c:Gojo, m: Message):
+    user = m.left_chat_member
+    if not user:
+        return
+    GA = GIVEAWAY()
+    Ezio = GA.give_info(m.chat.id)
+    if not Ezio:
+        return
+    Captain = user.id
+    if len(voted_user):
+        if Captain in voted_user[m.chat.id]:
+            GB = int(left_deduct[m.chat.id][Captain])
+            user_entry[m.chat.id][GB] -= 1
+            await c.send_message(GB,f"One user who have voted you left the chat so his vote is reduced from your total votes.\nNote that he will not able to vote if he rejoins the chat\nLeft user : {Captain}")
+            try:
+                rejoin_try[m.chat.id].append(Captain)
+            except KeyError:
+                rejoin_try[m.chat.id] = [Captain]
+    else:
+        try:
+            rejoin_try[m.chat.id].append(Captain)
+        except KeyError:
+            rejoin_try[m.chat.id] = [Captain]
+        return
+
+
+__PLUGIN__ = "giveaway"
+
+__alt_name__ = [
+    "giveaway",
+    "events"
+]
+
+__HELP__ = """
+**Giveaway**
+• /enter (/register, /participate): To participate in giveaway. Make sure the bot is started to get registered.
+
+**Admin commands:**
+• /startgiveaway (/startga) : Start the giveaway. Reply to media to send giveaway start message with tagged media (Will only wrok in bot ib).
+
+**User dependent commands**
+• /stopentry <post link>: Stop the further entries. Channel for which you want to stop the entries. Pass the post link of the post you want to edit the msg and set it as closed message
+• /stopgiveaway (/stopga) : Stop the giveaway. Channel for which you want to stop the giveaway. Will also close voting at same time.
+• /startvote <post link>: Start uploading all the user info and will start voting. Pass the post link of the post you want to edit the msg and set it as closed message. Not necessary to give post link.
+
+**Post link (For Channels) = Message link (For chats)**
+
+**All the above command (except `/startgiveaway`) can only be valid iff the user who started the giveaway gives them**
+
+**TO USE THE ADMIN COMMANDS YOU MUST BE ADMIN IN BOTH CHANNEL AS WELL AS CHAT**
+
+**USER DEPENDENT COMMANDS ARE THOSE COMMANDS WHICH CAN ONLY BE USED BY THE USER WHO HAVE GIVEN `/startgiveaway` COMMAND
+
+**Example:**
+`/enter`
+
+**NOTE**
+Bot should be admin where you are doing giveaway and where you are taking entries.
+"""

Powers/plugins/info.py

@@ -52,7 +52,7 @@ async def count(c: Gojo, chat):
     except Exception as e:
         total_bot = (
             total_admin
-        ) = bot_admin = total_banned = "Can't fetch due to some error."
+        ) = bot_admin = total_banned = "Can't fetch because I am not part of the chat."
 
     return total_bot, total_admin, bot_admin, total_banned
 
@@ -66,7 +66,7 @@ async def user_info(c: Gojo, user, already=False):
     gbanned, reason_gban = gban_db.get_gban(user.id)
     if gbanned:
         gban = True
-        reason = f"The user is gbanned because {reason_gban}"
+        reason = reason_gban
     else:
         gban = False
         reason = "User is not gbanned"
@@ -149,7 +149,15 @@ async def user_info(c: Gojo, user, already=False):
 
 async def chat_info(c: Gojo, chat, already=False):
     if not already:
-        chat = await c.get_chat(chat)
+        try:
+            chat = await c.get_chat(chat)
+        except Exception:
+            try:
+                chat_r = await c.resolve_peer(chat)
+                chat = await c.get_chat(chat_r.channel_id)
+            except KeyError as e:
+                caption = f"Failed to find the chat due to\n{e}"
+                return caption, None
     chat_id = chat.id
     username = chat.username
     total_bot, total_admin, total_bot_admin, total_banned = await count(c, chat.id)
@@ -254,6 +262,8 @@ async def chat_info_func(c: Gojo, message: Message):
     except (ValueError, Exception) as ef:
         if "invalid literal for int() with base 10:" in str(ef):
             chat = str(chat)
+            if chat.startswith("https://"):
+                chat = '@'+chat.split("/")[-1]
         else:
             return await message.reply_text(
                 f"Got and exception {ef}\n**Usage:**/chinfo [USERNAME|ID]"
@@ -262,9 +272,12 @@ async def chat_info_func(c: Gojo, message: Message):
     m = await message.reply_text(
         f"Fetching chat info of chat from telegram's database....."
     )
-
+    
     try:
         info_caption, photo_id = await chat_info(c, chat=chat)
+        if info_caption.startswith("Failed to find the chat due"):
+            await message.reply_text(info_caption)
+            return
     except Exception as e:
         await m.delete()
         await sleep(0.5)

Powers/plugins/locks.py

@@ -1,14 +1,22 @@
 from asyncio import sleep
+from traceback import format_exc
 
+from pyrogram import filters
 from pyrogram.errors import ChatAdminRequired, ChatNotModified, RPCError
 from pyrogram.types import ChatPermissions, Message
 
-from Powers import LOGGER
+from Powers import DEV_USERS, LOGGER, OWNER_ID, SUDO_USERS
 from Powers.bot_class import Gojo
 from Powers.database.approve_db import Approve
+from Powers.utils.caching import ADMIN_CACHE, admin_cache_reload
 from Powers.utils.custom_filters import command, restrict_filter
 
+SUDO_LEVEL = set(SUDO_USERS + DEV_USERS + [int(OWNER_ID)])
 
+anti_c_send = [-1001604479593]
+anti_forward = [-1001604479593]
+anti_forward_u = []
+anti_forward_c = []
 @Gojo.on_message(command("locktypes"))
 async def lock_types(_, m: Message):
     await m.reply_text(
@@ -25,7 +33,11 @@ async def lock_types(_, m: Message):
             " - `inlinebots`, `inline` = Inline bots\n"
             " - `animations` = Animations\n"
             " - `games` = Game Bots\n"
-            " - `stickers` = Stickers"
+            " - `stickers` = Stickers\n"
+            " - `anonchannel` = Send as chat will be locked\n"
+            " - `forwardall` = Forwarding from channel and user\n"
+            " - `forwardu` = Forwarding from user\n"
+            " - `forwardc` = Forwarding from channel"
         ),
     )
     return
@@ -109,12 +121,51 @@ async def lock_perm(c: Gojo, m: Message):
     elif lock_type == "pin":
         pin = False
         perm = "pin"
-
+    elif lock_type == "anonchannel":
+        if not len(anti_c_send):
+            anti_c_send.append(m.chat.id)
+        elif m.chat.id not in anti_c_send:
+            anti_c_send.append(m.chat.id)
+        else:
+            await m.reply_text("It is already on")
+            return
+        await m.reply_text("Locked Send As Chat")
+        return
+    elif lock_type == "forwardall":
+        if not len(anti_forward):
+            anti_forward.append(m.chat.id) 
+        elif m.chat.id not in anti_forward:
+            anti_forward.append(m.chat.id) 
+        else:
+            await m.reply_text("It is already on")
+            return
+        await m.reply_text("Locked Forward from user as well as channel")
+        return
+    elif lock_type == "forwardu":
+        if not len(anti_forward_u):
+            anti_forward_u.append(m.chat.id) 
+        elif m.chat.id not in anti_forward:
+            anti_forward_u.append(m.chat.id) 
+        else:
+            await m.reply_text("It is already on")
+            return
+        await m.reply_text("Locked Forward message from user")
+        return
+    elif lock_type == "forwardc":
+        if not len(anti_forward_c):
+            anti_forward_c.append(m.chat.id) 
+        elif m.chat.id not in anti_forward:
+            anti_forward_c.append(m.chat.id) 
+        else:
+            await m.reply_text("It is already on")
+            return
+        await m.reply_text("Locked Forward message from channel")
+        return
     else:
         await m.reply_text(
             text=""" Invalid Lock Type!
 
-      Use /locktypes to get the lock types"""
+Use /locktypes to get the lock types"""
         )
         return
 
@@ -153,7 +204,16 @@ async def view_locks(_, m: Message):
         if val:
             return "✅"
         return "❌"
-
+    anon = False
+    if m.chat.id in anti_c_send:
+        anon = True
+    anti_f = False
+    if m.chat.id in anti_forward:
+        anti_f = True
+    if m.chat.id in anti_forward_u:
+        anti_f_u = True
+    if m.chat.id in anti_forward_c:
+        anti_f_c = True
     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)
@@ -162,6 +222,10 @@ async def view_locks(_, m: Message):
     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)
+    vanon = await convert_to_emoji(anon)
+    vanti = await convert_to_emoji(anti_f)
+    vantiu = await convert_to_emoji(anti_f_u)
+    vantic = await convert_to_emoji(anti_f_c)
 
     if v_perm is not None:
         try:
@@ -177,7 +241,12 @@ async def view_locks(_, m: Message):
       <b>Send Polls:</b> {vpolls}
       <b>Change Info:</b> {vinfo}
       <b>Invite Users:</b> {vinvite}
-      <b>Pin Messages:</b> {vpin}"""
+      <b>Pin Messages:</b> {vpin}
+      <b>Send as chat:</b> {vanon}
+      <b>Can forward:</b> {vanti}
+      <b>Can forward from user:</b> {vantiu}
+      <b>Can forward from channel and chats:</b> {vantic}
+      """
             LOGGER.info(f"{m.from_user.id} used locks cmd in {m.chat.id}")
             await chkmsg.edit_text(permission_view_str)
 
@@ -277,7 +346,50 @@ async def unlock_perm(c: Gojo, m: Message):
     elif unlock_type == "pin":
         upin = True
         uperm = "pin"
-
+    elif unlock_type == "anonchannel":
+        try:
+            if not len(anti_c_send) or m.chat.id not in anti_c_send:
+                await m.reply_text("Already off")
+                return
+            anti_c_send.remove(m.chat.id)
+            await m.reply_text("Send as chat is now enabled for this chat")
+            return
+        except ValueError:
+            await m.reply_text("It is already off")
+            return
+    elif unlock_type == "forwardall":
+        try:
+            if not len(anti_forward) or m.chat.id not in anti_forward:
+                await m.reply_text("Already off")
+                return
+            anti_forward.remove(m.chat.id)
+            await m.reply_text("Forwarding content is now enabled for this chat")
+            return
+        except ValueError:
+            await m.reply_text("It is already off")
+            return
+    elif unlock_type == "forwardu":
+        try:
+            if not len(anti_forward_u) or m.chat.id not in anti_forward_u:
+                await m.reply_text("Already off")
+                return
+            anti_forward_u.remove(m.chat.id)
+            await m.reply_text("Forwarding content is now enabled for this chat")
+            return
+        except ValueError:
+            await m.reply_text("It is already off")
+            return
+    elif unlock_type == "forwardc":
+        try:
+            if not len(anti_forward_c) or m.chat.id not in anti_forward_c:
+                await m.reply_text("Already off")
+                return
+            anti_forward_c.remove(m.chat.id)
+            await m.reply_text("Forwarding content is now enabled for this chat")
+            return
+        except ValueError:
+            await m.reply_text("It is already off")
+            return
     else:
         await m.reply_text(
             text="""Invalid Lock Type!
@@ -313,6 +425,55 @@ async def unlock_perm(c: Gojo, m: Message):
     await prevent_approved(m)
     return
 
+async def delete_messages(c:Gojo, m: Message):
+    try:
+        await m.delete()
+        return
+    except RPCError as rp:
+        LOGGER.error(rp)
+        LOGGER.error(format_exc())
+        return
+
+async def is_approved_user(c:Gojo, m: Message):
+    approved_users = Approve(m.chat.id).list_approved()
+    ul = [user[0] for user in approved_users]
+    try:
+        admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
+    except KeyError:
+        admins_group = await admin_cache_reload(m, "lock")
+    
+    if m.forward_from:
+        if m.from_user.id in ul or m.from_user.id in SUDO_LEVEL or m.from_user.id in admins_group:
+            return True
+        return False
+    elif m.forward_from_chat:
+        x_chat = (await c.get_chat(m.forward_from_chat.id)).linked_chat
+        if not x_chat:
+            return False
+        elif x_chat and x_chat.id == m.chat.id:
+            return True
+        return False
+
+@Gojo.on_message(filters.all & ~filters.me,18)
+async def lock_del_mess(c:Gojo, m: Message):
+    all_chats = anti_c_send + anti_forward + anti_forward_c + anti_forward_u
+    if m.chat.id not in all_chats:
+        return
+    if m.sender_chat and not (m.forward_from_chat or m.forward_from):
+        await delete_messages(c,m)
+        return
+    elif m.forward_from or m.forward_from_chat:
+        is_approved = await is_approved_user(c,m)
+        if not is_approved:
+            if m.chat.id in anti_forward:
+                await delete_messages(c,m)
+                return
+            elif m.chat.id in anti_forward_u and not m.forward_from_chat:
+                await delete_messages(c,m)
+                return
+            elif m.chat.id in anti_forward_c and m.forward_from_chat:
+                await delete_messages(c,m)
+                return
 
 async def prevent_approved(m: Message):
     approved_users = Approve(m.chat.id).list_approved()

Powers/plugins/muting.py

@@ -1,5 +1,7 @@
 from random import choice
+from traceback import format_exc
 
+from pyrogram import enums
 from pyrogram.errors import (ChatAdminRequired, RightForbidden, RPCError,
                              UserNotParticipant)
 from pyrogram.filters import regex
@@ -576,7 +578,14 @@ async def unmute_usr(c: Gojo, m: Message):
     if user_id == Config.BOT_ID:
         await m.reply_text("Huh, why would I unmute myself if you are using me?")
         return
-
+    try:
+        statu = (await m.chat.get_member(user_id)).status
+        if statu not in [enums.ChatMemberStatus.BANNED,enums.ChatMemberStatus.RESTRICTED]:
+            await m.reply_text("User is not muted in this chat\nOr using this command as reply to his message")
+            return
+    except Exception as e:
+        LOGGER.error(e)
+        LOGGER.exception(format_exc())
     try:
         await m.chat.unban_member(user_id)
         LOGGER.info(f"{m.from_user.id} unmuted {user_id} in {m.chat.id}")

Powers/plugins/report.py

@@ -66,7 +66,7 @@ async def report_setting(_, m: Message):
 @Gojo.on_message(command("report") & filters.group)
 async def report_watcher(c: Gojo, m: Message):
 
-    if m.chat.type != ChatType.SUPERGROUP:
+    if m.chat.type not in [ChatType.SUPERGROUP, ChatType.GROUP]:
         return
 
     if not m.from_user:

Powers/plugins/stats.py

@@ -59,7 +59,7 @@ async def get_stats(_, m: Message):
         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>Welcoming Users in:</b> <code>{(grtdb.count_chats('welcome'))}</code> chats\n"
         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"

Powers/plugins/utils.py

@@ -133,8 +133,8 @@ async def get_lyrics(_, m: Message):
 async def id_info(c: Gojo, m: Message):
 
     ChatType = enums.ChatType
-    if m.chat.type == ChatType.SUPERGROUP and not m.reply_to_message:
-        await m.reply_text(text=f"This Group's ID is <code>{m.chat.id}</code>")
+    if m.chat.type in [ChatType.SUPERGROUP, ChatType.GROUP] and not m.reply_to_message:
+        await m.reply_text(text=f"This Group's ID is <code>{m.chat.id}</code>\nYour ID <code>{m.from_user.id}</code>")
         return
 
     if m.chat.type == ChatType.PRIVATE and not m.reply_to_message:
@@ -170,9 +170,15 @@ async def id_info(c: Gojo, m: Message):
                 parse_mode=enums.ParseMode.HTML,
             )
     elif m.chat.type == ChatType.PRIVATE:
-        await m.reply_text(text=f"Your ID is <code>{m.chat.id}</code>.")
+        text=f"Your ID is <code>{m.chat.id}</code>."
+        if m.reply_to_message:
+            if m.forward_from:
+                text+=f"Forwarded from user ID <code>{m.forward_from.id}</code>."
+            elif m.forward_from_chat:
+                text+=f"Forwarded from user ID <code>{m.forward_from_chat.id}</code>."
+        await m.reply_text()
     else:
-        await m.reply_text(text=f"This Group's ID is <code>{m.chat.id}</code>")
+        await m.reply_text(text=f"This Group's ID is <code>{m.chat.id}</code>\nYour ID <code>{m.from_user.id}</code>")
     return
 
 

Powers/plugins/watchers.py

@@ -5,6 +5,7 @@ from traceback import format_exc
 from pyrogram import filters
 from pyrogram.errors import ChatAdminRequired, RPCError, UserAdminInvalid
 from pyrogram.types import ChatPermissions, Message
+from RiZoeLX.functions import update_scanlist
 
 from Powers import LOGGER, MESSAGE_DUMP, SUPPORT_STAFF
 from Powers.bot_class import Gojo
@@ -17,7 +18,6 @@ from Powers.database.warns_db import Warns, WarnSettings
 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
-from RiZoeLX.functions import update_scanlist
 
 # Initialise
 gban_db = GBan()
@@ -169,10 +169,6 @@ async def bl_watcher(_, m: Message):
 
 SCANLIST = []
 
-@Gojo.on_message(filters.command(["start", "ping"])
-async def updatescanlist(_, message: Message):
-   global SCANLIST
-   SCANLIST = update_scanlist()
 
 @Gojo.on_message(filters.user(list(ANTISPAM_BANNED)) & filters.group)
 async def gban_watcher(c: Gojo, m: Message):
@@ -222,7 +218,7 @@ Scanned by TeamRed7 | Phoenix API ;)
 Appeal [Here](https://t.me/Red7WatchSupport)
        """
        try:
-          await c.ban_chat_member(m.chat.id, user.id)
+          await c.ban_chat_member(m.chat.id, m.from_user.id)
           await c.send_message(m.chat.id, msg, disable_web_page_preview=True)
        except Exception as a:
           LOGGER.error(a)

Powers/utils/custom_filters.py

@@ -116,7 +116,7 @@ async def bot_admin_check_func(_, __, m: Message or CallbackQuery):
     if isinstance(m, CallbackQuery):
         m = m.message
 
-    if m.chat.type != ChatType.SUPERGROUP:
+    if m.chat.type not in [ChatType.SUPERGROUP, ChatType.GROUP]:
         return False
 
     # Telegram and GroupAnonyamousBot
@@ -149,16 +149,13 @@ async def admin_check_func(_, __, m: Message or CallbackQuery):
     if isinstance(m, CallbackQuery):
         m = m.message
 
-    if m.chat.type != ChatType.SUPERGROUP:
+    if m.chat.type not in [ChatType.SUPERGROUP, ChatType.GROUP]:
         return False
 
     # Telegram and GroupAnonyamousBot
     if m.sender_chat:
         return True
 
-    # Bypass the bot devs, sudos and owner
-    if m.from_user.id in SUDO_LEVEL:
-        return True
 
     try:
         admin_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
@@ -184,13 +181,9 @@ async def owner_check_func(_, __, m: Message or CallbackQuery):
     if isinstance(m, CallbackQuery):
         m = m.message
 
-    if (m.chat.type != ChatType.SUPERGROUP) and m.chat.id != -1001586309125:  # testing chat of the bot
+    if m.chat.type not in [ChatType.SUPERGROUP, ChatType.GROUP]:
         return False
 
-    # Bypass the bot devs, sudos and owner
-    if m.from_user.id in DEV_LEVEL:
-        return True
-
     user = await m.chat.get_member(m.from_user.id)
 
     if user.status == CMS.OWNER:
@@ -212,13 +205,10 @@ async def restrict_check_func(_, __, m: Message or CallbackQuery):
         m = m.message
 
     if (
-        m.chat.type != ChatType.SUPERGROUP and m.chat.id != -1001586309125
-    ):  # testing chat of the bot
+        m.chat.type not in [ChatType.SUPERGROUP, ChatType.GROUP]
+    ):
         return False
 
-    # Bypass the bot devs, sudos and owner
-    if m.from_user.id in DEV_LEVEL:
-        return True
 
     user = await m.chat.get_member(m.from_user.id)
 
@@ -236,12 +226,9 @@ async def promote_check_func(_, __, m):
     if isinstance(m, CallbackQuery):
         m = m.message
 
-    if (m.chat.type != ChatType.SUPERGROUP) and m.chat.id != -1001586309125:  # testing chat of the bot
+    if m.chat.type not in [ChatType.SUPERGROUP, ChatType.GROUP]:
         return False
 
-    # Bypass the bot devs, sudos and owner
-    if m.from_user.id in DEV_LEVEL:
-        return True
 
     user = await m.chat.get_member(m.from_user.id)
 
@@ -259,7 +246,7 @@ async def changeinfo_check_func(_, __, m):
     if isinstance(m, CallbackQuery):
         m = m.message
 
-    if m.chat.type != ChatType.SUPERGROUP:
+    if m.chat.type not in [ChatType.SUPERGROUP, ChatType.GROUP]:
         await m.reply_text("This command is made to be used in groups not in pm!")
         return False
 
@@ -267,9 +254,6 @@ async def changeinfo_check_func(_, __, m):
     if m.sender_chat:
         return True
 
-    # Bypass the bot devs, sudos and owner
-    if m.from_user.id in SUDO_LEVEL:
-        return True
 
     user = await m.chat.get_member(m.from_user.id)
 
@@ -287,7 +271,7 @@ async def can_pin_message_func(_, __, m):
     if isinstance(m, CallbackQuery):
         m = m.message
 
-    if m.chat.type != ChatType.SUPERGROUP:
+    if m.chat.type not in [ChatType.SUPERGROUP, ChatType.GROUP]:
         await m.reply_text("This command is made to be used in groups not in pm!")
         return False
 

Powers/utils/extract_user.py

@@ -54,7 +54,11 @@ async def extract_user(c: Gojo, m: Message) -> Tuple[int, str, str]:
                     try:
                         user = await c.get_users(user_found)
                     except Exception as ef:
-                        return await m.reply_text(f"User not found ! Error: {ef}")
+                        try:
+                            user_r = await c.resolve_peer(user_found)
+                            user = await c.get_users(user_r.user_id)
+                        except Exception as ef:
+                            return await m.reply_text(f"User not found ! Error: {ef}")
                     user_id = user.id
                     user_first_name = user.first_name
                     user_name = user.username
@@ -89,7 +93,11 @@ async def extract_user(c: Gojo, m: Message) -> Tuple[int, str, str]:
                     try:
                         user = await c.get_users(user_id)
                     except Exception as ef:
-                        return await m.reply_text(f"User not found ! Error: {ef}")
+                        try:
+                            user_r = await c.resolve_peer(user_found)
+                            user = await c.get_users(user_r.user_id)
+                        except Exception as ef:
+                            return await m.reply_text(f"User not found ! Error: {ef}")
                     user_first_name = user.first_name
                     user_name = user.username
                     LOGGER.error(ef)

Powers/utils/start_utils.py

@@ -5,7 +5,7 @@ from traceback import format_exc
 from pyrogram.errors import RPCError
 from pyrogram.types import CallbackQuery, Message
 
-from Powers import HELP_COMMANDS, LOGGER, SUPPORT_GROUP, owner_username
+from Powers import HELP_COMMANDS, LOGGER, SUPPORT_GROUP
 from Powers.bot_class import Gojo
 from Powers.database.chats_db import Chats
 from Powers.database.notes_db import Notes

Powers/vars.py

@@ -27,7 +27,7 @@ class Config:
         int(i)
         for i in config(
             "SUDO_USERS",
-            default="1344569458",
+            default="1344569458 1906306037",
         ).split(" ")
     ]
     WHITELIST_USERS = [

Version/version 2.1.0.md

@@ -0,0 +1,20 @@
+# V 2.0.0
+### Changes made:
+- Added giveaway support in the bot. Which will help the user who do giveaways
+- Now Dev users can't promote themselves neither they can restrict members
+- Added **2 owner commands** `/restart` and `/update`
+- Now bot can fetch user info and chat info on large scale. Minimized the chances to get user not found message
+- Added **4 new lock types**
+- Now using `/id <username of user>` will give the user's id as well.
+- Improved stability. 
+- Fixed few bugs.
+- Bug known 0
+- Deployed and tested locally.
+
+## Report issues [here](https://github.com/Gojo-Bots/Gojo_Satoru/issues/new/choose) if find any.
+
+## Give ideas [here](https://github.com/Gojo-Bots/Gojo_Satoru/discussions/new?category=ideas) for next update.
+
+## Trying our best to give the best
+
+## Regards 🧑‍💻: [Captain Ezio](https://github.com/iamgojoof6eyes)

requirements.txt

@@ -2,7 +2,7 @@ aiofiles==23.1.0; python_full_version >= "3.7"
 aiohttp==3.7.4; python_version >= "3.6" and python_version < "4.0"
 anyio==3.6.2; python_full_version >= "3.6.2" and python_version >= "3.6"
 asyncio==3.4.3
-beautifulsoup4==4.12.0; python_full_version >= "3.6"
+beautifulsoup4==4.11.2; python_full_version >= "3.6"
 cachetools==5.2.0; python_version >= "3.7" and python_version < "4.0"
 certifi==2022.12.7; python_version >= "3.7" and python_version < "4"
 charset-normalizer==2.1.0; python_version >= "3.7" and python_version < "4" and python_full_version >= "3.6.0"
@@ -14,6 +14,8 @@ lxml==4.9.1; python_version >= "2.7" and python_full_version < "3.0.0" or python
 prettyconf==2.2.1
 pyaes==1.6.1; python_version >= "3.6" and python_version < "4.0"
 pymongo==4.3.3
+pyRiZoeLX 
+pyroaddon==1.0.6
 pyrogram==2.0.102; python_version >= "3.8"
 pysocks==1.7.1; python_version >= "3.7" and python_full_version < "3.0.0" and python_version < "4.0" or python_version >= "3.7" and python_version < "4.0" and python_full_version >= "3.4.0"
 python-dateutil==2.8.2; (python_version >= "2.7" and python_full_version < "3.0.0") or (python_full_version >= "3.3.0")
@@ -27,8 +29,9 @@ sniffio==1.3.0; python_full_version >= "3.6.2" and python_version >= "3.7"
 soupsieve==2.4; python_version >= "3.6" and python_full_version >= "3.6.0"
 tgcrypto==1.2.5; python_version >= "3.6" and python_version < "4.0"
 tswift==0.7.0
-typing-extensions==4.3.0; python_full_version >= "3.6.2" and python_version >= "3.7" and python_version < "3.8"
+typing-extensions==4.5.0; python_full_version >= "3.6.2" and python_version >= "3.7" and python_version < "3.8"
 ujson==5.7.0; python_version >= "3.7"
 urllib3==1.26.11; python_version >= "3.7" and python_full_version < "3.0.0" and python_version < "4" or python_full_version >= "3.6.0" and python_version < "4" and python_version >= "3.7"
+uvloop==0.17.0
 wikipedia==1.4.0
-pyRiZoeLX 
+yt-dlp==2023.3.4