|
|
@@ -0,0 +1,948 @@
|
|
|
+"""
|
|
|
+MIT License
|
|
|
+
|
|
|
+Copyright (c) 2023 SI_NN_ER_LS
|
|
|
+
|
|
|
+Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
+of this software and associated documentation files (the "Software"), to deal
|
|
|
+in the Software without restriction, including without limitation the rights
|
|
|
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
+copies of the Software, and to permit persons to whom the Software is
|
|
|
+furnished to do so, subject to the following conditions:
|
|
|
+
|
|
|
+The above copyright notice and this permission notice shall be included in all
|
|
|
+copies or substantial portions of the Software.
|
|
|
+
|
|
|
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
|
+SOFTWARE.
|
|
|
+"""
|
|
|
+
|
|
|
+import uuid
|
|
|
+import asyncio
|
|
|
+from wbb.utils.dbfeds import *
|
|
|
+from wbb import app, SUDOERS, LOG_GROUP_ID, BOT_ID
|
|
|
+from pyrogram import filters
|
|
|
+from pyrogram.enums import ChatMemberStatus, ChatType, ParseMode
|
|
|
+from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup
|
|
|
+from wbb.utils.functions import extract_user, extract_user_and_reason
|
|
|
+from pyrogram.errors import FloodWait
|
|
|
+from wbb.core.decorators.errors import capture_err
|
|
|
+
|
|
|
+__MODULE__ = "Federation"
|
|
|
+__HELP__ = """
|
|
|
+Everything is fun, until a spammer starts entering your group, and you have to block it. Then you need to start banning more, and more, and it hurts.
|
|
|
+But then you have many groups, and you don't want this spammer to be in one of your groups - how can you deal? Do you have to manually block it, in all your groups?\n
|
|
|
+**No longer!** With Federation, you can make a ban in one chat overlap with all other chats.\n
|
|
|
+You can even designate federation admins, so your trusted admin can ban all the spammers from chats you want to protect.\n\n
|
|
|
+"""
|
|
|
+
|
|
|
+
|
|
|
+SUPPORT_CHAT = "@WBBSupport"
|
|
|
+
|
|
|
+
|
|
|
+@app.on_message(filters.command("newfed"))
|
|
|
+@capture_err
|
|
|
+async def new_fed(client, message):
|
|
|
+ chat = message.chat
|
|
|
+ user = message.from_user
|
|
|
+ if message.chat.type != ChatType.PRIVATE:
|
|
|
+ await message.reply_text(
|
|
|
+ "Federations can only be created by privately messaging me."
|
|
|
+ )
|
|
|
+ return
|
|
|
+ if len(message.command) < 2:
|
|
|
+ await message.reply_text("Please write the name of the federation!")
|
|
|
+ return
|
|
|
+ fednam = message.text.split(None, 1)[1]
|
|
|
+ if not fednam == "":
|
|
|
+ fed_id = str(uuid.uuid4())
|
|
|
+ fed_name = fednam
|
|
|
+ x = await fedsdb.update_one(
|
|
|
+ {"fed_id": str(fed_id)},
|
|
|
+ {
|
|
|
+ "$set": {
|
|
|
+ "fed_name": str(fed_name),
|
|
|
+ "owner_id": int(user.id),
|
|
|
+ "fadmins": [],
|
|
|
+ "owner_mention": user.mention,
|
|
|
+ "banned_users": [],
|
|
|
+ "chat_ids": [],
|
|
|
+ "log_group_id": LOG_GROUP_ID,
|
|
|
+ }
|
|
|
+ },
|
|
|
+ upsert=True,
|
|
|
+ )
|
|
|
+ if not x:
|
|
|
+ await message.reply_text(
|
|
|
+ f"Can't federate! Please contact {SUPPORT_CHAT} if the problem persist."
|
|
|
+ )
|
|
|
+ return
|
|
|
+
|
|
|
+ await message.reply_text(
|
|
|
+ "**You have succeeded in creating a new federation!**"
|
|
|
+ "\nName: `{}`"
|
|
|
+ "\nID: `{}`"
|
|
|
+ "\n\nUse the command below to join the federation:"
|
|
|
+ "\n`/joinfed {}`".format(fed_name, fed_id, fed_id),
|
|
|
+ parse_mode=ParseMode.MARKDOWN,
|
|
|
+ )
|
|
|
+ try:
|
|
|
+ await app.send_message(
|
|
|
+ LOG_GROUP_ID,
|
|
|
+ "New Federation: <b>{}</b>\nID: <pre>{}</pre>".format(fed_name, fed_id),
|
|
|
+ parse_mode=ParseMode.HTML,
|
|
|
+ )
|
|
|
+ except:
|
|
|
+ log.info("Cannot send a message to EVENT_LOGS")
|
|
|
+ else:
|
|
|
+ await message.reply_text("Please write down the name of the federation")
|
|
|
+
|
|
|
+
|
|
|
+@app.on_message(filters.command("delfed"))
|
|
|
+@capture_err
|
|
|
+async def del_fed(client, message):
|
|
|
+ chat = message.chat
|
|
|
+ user = message.from_user
|
|
|
+ if message.chat.type != ChatType.PRIVATE:
|
|
|
+ await message.reply_text(
|
|
|
+ "Federations can only be deleted by privately messaging me."
|
|
|
+ )
|
|
|
+ return
|
|
|
+ args = message.text.split(" ", 1)
|
|
|
+ if len(args) > 1:
|
|
|
+ is_fed_id = args[1].strip()
|
|
|
+ getinfo = await get_fed_info(is_fed_id)
|
|
|
+ if getinfo is False:
|
|
|
+ await message.reply_text("This federation does not exist.")
|
|
|
+ return
|
|
|
+ if getinfo["owner_id"] == user.id or user.id == SUDOERS:
|
|
|
+ fed_id = is_fed_id
|
|
|
+ else:
|
|
|
+ await message.reply_text("Only federation owners can do this!")
|
|
|
+ return
|
|
|
+ else:
|
|
|
+ await message.reply_text("What should I delete?")
|
|
|
+ return
|
|
|
+ is_owner = await is_user_fed_owner(fed_id, user.id)
|
|
|
+ if is_owner is False:
|
|
|
+ await message.reply_text("Only federation owners can do this!")
|
|
|
+ return
|
|
|
+ await message.reply_text(
|
|
|
+ "You sure you want to delete your federation? This cannot be reverted, you will lose your entire ban list, and '{}' will be permanently lost.".format(
|
|
|
+ getinfo["fed_name"]
|
|
|
+ ),
|
|
|
+ reply_markup=InlineKeyboardMarkup(
|
|
|
+ [
|
|
|
+ [
|
|
|
+ InlineKeyboardButton(
|
|
|
+ "⚠️ Delete Federation ⚠️",
|
|
|
+ callback_data=f"rmfed_{fed_id}",
|
|
|
+ )
|
|
|
+ ],
|
|
|
+ [InlineKeyboardButton("Cancel", callback_data="rmfed_cancel")],
|
|
|
+ ]
|
|
|
+ ),
|
|
|
+ )
|
|
|
+
|
|
|
+
|
|
|
+@app.on_message(filters.command("fedtransfer"))
|
|
|
+@capture_err
|
|
|
+async def fedtransfer(client, message):
|
|
|
+ chat = message.chat
|
|
|
+ user = message.from_user
|
|
|
+ if message.chat.type != ChatType.PRIVATE:
|
|
|
+ await message.reply_text(
|
|
|
+ "Federations can only be transferred by privately messaging me."
|
|
|
+ )
|
|
|
+ return
|
|
|
+ is_feds = await get_feds_by_owner(int(user.id))
|
|
|
+ if not is_feds:
|
|
|
+ return await message.reply_text("**You haven't created any federations.**")
|
|
|
+ if len(message.command) < 2:
|
|
|
+ return await message.reply_text(
|
|
|
+ "**You needed to specify a user or reply to their message!**"
|
|
|
+ )
|
|
|
+ user_id, fed_id = await extract_user_and_reason(message)
|
|
|
+ if not user_id:
|
|
|
+ return await message.reply_text("I can't find that user.")
|
|
|
+ if not fed_id:
|
|
|
+ return await message.reply(
|
|
|
+ "you need to provide a Fed Id.\n\nUsage:\n/fedtransfer @usename Fed_Id."
|
|
|
+ )
|
|
|
+ is_owner = await is_user_fed_owner(fed_id, user.id)
|
|
|
+ if is_owner is False:
|
|
|
+ await message.reply_text("Only federation owners can do this!")
|
|
|
+ return
|
|
|
+ await message.reply_text(
|
|
|
+ "**You sure you want to transfer your federation? This cannot be reverted.**",
|
|
|
+ reply_markup=InlineKeyboardMarkup(
|
|
|
+ [
|
|
|
+ [
|
|
|
+ InlineKeyboardButton(
|
|
|
+ "⚠️ Transfer Federation ⚠️",
|
|
|
+ callback_data=f"trfed_{user_id}|{fed_id}",
|
|
|
+ )
|
|
|
+ ],
|
|
|
+ [InlineKeyboardButton("Cancel", callback_data="trfed_cancel")],
|
|
|
+ ]
|
|
|
+ ),
|
|
|
+ )
|
|
|
+
|
|
|
+
|
|
|
+@app.on_message(filters.command("myfeds"))
|
|
|
+@capture_err
|
|
|
+async def myfeds(client, message):
|
|
|
+ user = message.from_user
|
|
|
+ is_feds = await get_feds_by_owner(int(user.id))
|
|
|
+
|
|
|
+ if is_feds:
|
|
|
+ response_text = "\n\n".join(
|
|
|
+ [
|
|
|
+ f"{i + 1}.\n**Fed Name:** {fed['fed_name']}\n**Fed Id:** `{fed['fed_id']}`"
|
|
|
+ for i, fed in enumerate(is_feds)
|
|
|
+ ]
|
|
|
+ )
|
|
|
+ await message.reply_text(
|
|
|
+ f"**Here are the federations you have created:**\n\n{response_text}"
|
|
|
+ )
|
|
|
+ else:
|
|
|
+ await message.reply_text("**You haven't created any federations.**")
|
|
|
+
|
|
|
+
|
|
|
+@app.on_message(filters.command("renamefed"))
|
|
|
+@capture_err
|
|
|
+async def rename_fed(client, message):
|
|
|
+ user = message.from_user
|
|
|
+ msg = message
|
|
|
+ args = msg.text.split(None, 2)
|
|
|
+
|
|
|
+ if len(args) < 3:
|
|
|
+ return await msg.reply_text("usage: /renamefed <fed_id> <newname>")
|
|
|
+
|
|
|
+ fed_id, newname = args[1], args[2]
|
|
|
+ verify_fed = await get_fed_info(fed_id)
|
|
|
+
|
|
|
+ if not verify_fed:
|
|
|
+ return await msg.reply_text("This fed does not exist in my database!")
|
|
|
+
|
|
|
+ if await is_user_fed_owner(fed_id, user.id):
|
|
|
+ fedsdb.update_one(
|
|
|
+ {"fed_id": str(fed_id)},
|
|
|
+ {"$set": {"fed_name": str(newname), "owner_id": int(user.id)}},
|
|
|
+ upsert=True,
|
|
|
+ )
|
|
|
+ await msg.reply_text(f"Successfully renamed your fed name to {newname}!")
|
|
|
+ else:
|
|
|
+ await msg.reply_text("Only federation owner can do this!")
|
|
|
+
|
|
|
+
|
|
|
+@app.on_message(filters.command(["setfedlog", "unsetfedlog"]))
|
|
|
+@capture_err
|
|
|
+async def fed_log(client, message):
|
|
|
+ chat = message.chat
|
|
|
+ user = message.from_user
|
|
|
+ if message.chat.type == ChatType.PRIVATE:
|
|
|
+ await message.reply_text(
|
|
|
+ "Send this command on the chat which you need to set as fed log channel."
|
|
|
+ )
|
|
|
+ return
|
|
|
+ member = await app.get_chat_member(chat.id, user.id)
|
|
|
+ if (
|
|
|
+ member.status == ChatMemberStatus.OWNER
|
|
|
+ or member.status == ChatMemberStatus.ADMINISTRATOR
|
|
|
+ ):
|
|
|
+ if len(message.command) < 2:
|
|
|
+ return await message.reply_text(
|
|
|
+ "Please provide the Id of the federation with the command!"
|
|
|
+ )
|
|
|
+ fed_id = message.text.split(" ", 1)[1].strip()
|
|
|
+ info = await get_fed_info(fed_id)
|
|
|
+ if info is False:
|
|
|
+ await message.reply_text("This federation does not exist.")
|
|
|
+ return
|
|
|
+ if await is_user_fed_owner(fed_id, user.id):
|
|
|
+ if "/unsetfedlog" in message.text:
|
|
|
+ log_group_id = LOG_GROUP_ID
|
|
|
+ else:
|
|
|
+ log_group_id = chat.id
|
|
|
+ loged = await set_log_chat(fed_id, log_group_id)
|
|
|
+ if "/unsetfedlog" in message.text:
|
|
|
+ return await message.reply_text("log channel removed successfully.")
|
|
|
+ else:
|
|
|
+ await message.reply_text("log channel set successfully.")
|
|
|
+ else:
|
|
|
+ await message.reply_text(
|
|
|
+ "You need to be the chat owner or admin to use this command."
|
|
|
+ )
|
|
|
+
|
|
|
+
|
|
|
+@app.on_message(filters.command("chatfed"))
|
|
|
+@capture_err
|
|
|
+async def fed_chat(client, message):
|
|
|
+ chat = message.chat
|
|
|
+ user = message.from_user
|
|
|
+ fed_id = await get_fed_id(chat.id)
|
|
|
+
|
|
|
+ member = await app.get_chat_member(chat.id, user.id)
|
|
|
+ if (
|
|
|
+ member.status == ChatMemberStatus.OWNER
|
|
|
+ or member.status == ChatMemberStatus.ADMINISTRATOR
|
|
|
+ ):
|
|
|
+ pass
|
|
|
+ else:
|
|
|
+ await message.reply_text("You must be an admin to execute this command")
|
|
|
+ return
|
|
|
+
|
|
|
+ if not fed_id:
|
|
|
+ await message.reply_text("This group is not in any federation!")
|
|
|
+ return
|
|
|
+ info = await get_fed_info(fed_id)
|
|
|
+
|
|
|
+ text = "This group is part of the following federation:"
|
|
|
+ text += "\n{} (ID: <code>{}</code>)".format(info["fed_name"], fed_id)
|
|
|
+
|
|
|
+ await message.reply_text(text, parse_mode=ParseMode.HTML)
|
|
|
+
|
|
|
+
|
|
|
+@app.on_message(filters.command("joinfed"))
|
|
|
+@capture_err
|
|
|
+async def join_fed(client, message):
|
|
|
+ chat = message.chat
|
|
|
+ user = message.from_user
|
|
|
+ if message.chat.type == ChatType.PRIVATE:
|
|
|
+ await message.reply_text(
|
|
|
+ "This command is specific to groups, not our pm!",
|
|
|
+ )
|
|
|
+ return
|
|
|
+
|
|
|
+ member = await app.get_chat_member(chat.id, user.id)
|
|
|
+ fed_id = await get_fed_id(int(chat.id))
|
|
|
+
|
|
|
+ if user.id in SUDOERS:
|
|
|
+ pass
|
|
|
+ else:
|
|
|
+ if member.status == ChatMemberStatus.OWNER:
|
|
|
+ pass
|
|
|
+ else:
|
|
|
+ await message.reply_text("Only group creators can use this command!")
|
|
|
+ return
|
|
|
+ if fed_id:
|
|
|
+ await message.reply_text("You cannot join two federations from one chat")
|
|
|
+ return
|
|
|
+ args = message.text.split(" ", 1)
|
|
|
+ if len(args) > 1:
|
|
|
+ fed_id = args[1].strip()
|
|
|
+ getfed = await search_fed_by_id(fed_id)
|
|
|
+ if getfed is False:
|
|
|
+ await message.reply_text("Please enter a valid federation ID")
|
|
|
+ return
|
|
|
+
|
|
|
+ x = await chat_join_fed(fed_id, chat.title, chat.id)
|
|
|
+ if not x:
|
|
|
+ await message.reply_text(
|
|
|
+ f"Failed to join federation! Please contact {SUPPORT_CHAT} if this problem persists!"
|
|
|
+ )
|
|
|
+ return
|
|
|
+
|
|
|
+ get_fedlog = getfed["log_group_id"]
|
|
|
+ if get_fedlog:
|
|
|
+ await app.send_message(
|
|
|
+ get_fedlog,
|
|
|
+ "Chat **{}** has joined the federation **{}**".format(
|
|
|
+ chat.title, getfed["fed_name"]
|
|
|
+ ),
|
|
|
+ parse_mode=ParseMode.MARKDOWN,
|
|
|
+ )
|
|
|
+
|
|
|
+ await message.reply_text(
|
|
|
+ "This group has joined the federation: {}!".format(getfed["fed_name"])
|
|
|
+ )
|
|
|
+ else:
|
|
|
+ await message.reply_text(
|
|
|
+ "You need to specify which federation you're asking about by giving me a FedID!"
|
|
|
+ )
|
|
|
+
|
|
|
+
|
|
|
+@app.on_message(filters.command("leavefed"))
|
|
|
+@capture_err
|
|
|
+async def leave_fed(client, message):
|
|
|
+ chat = message.chat
|
|
|
+ user = message.from_user
|
|
|
+
|
|
|
+ if message.chat.type == ChatType.PRIVATE:
|
|
|
+ await message.reply_text(
|
|
|
+ "This command is specific to groups, not our pm!",
|
|
|
+ )
|
|
|
+ return
|
|
|
+
|
|
|
+ fed_id = await get_fed_id(int(chat.id))
|
|
|
+ fed_info = await get_fed_info(fed_id)
|
|
|
+
|
|
|
+ member = await app.get_chat_member(chat.id, user.id)
|
|
|
+ if member.status == ChatMemberStatus.OWNER or user.id in SUDOERS:
|
|
|
+ if await chat_leave_fed(int(chat.id)) is True:
|
|
|
+ get_fedlog = fed_info["log_group_id"]
|
|
|
+ if get_fedlog:
|
|
|
+ await app.send_message(
|
|
|
+ get_fedlog,
|
|
|
+ "Chat **{}** has left the federation **{}**".format(
|
|
|
+ chat.title, fed_info["fed_name"]
|
|
|
+ ),
|
|
|
+ parse_mode=ParseMode.MARKDOWN,
|
|
|
+ )
|
|
|
+ await message.reply_text(
|
|
|
+ "This group has left the federation {}!".format(fed_info["fed_name"]),
|
|
|
+ )
|
|
|
+ else:
|
|
|
+ await message.reply_text(
|
|
|
+ "How can you leave a federation that you never joined?!"
|
|
|
+ )
|
|
|
+ else:
|
|
|
+ await message.reply_text("Only group creators can use this command!")
|
|
|
+
|
|
|
+
|
|
|
+@app.on_message(filters.command("fedchats"))
|
|
|
+@capture_err
|
|
|
+async def fed_chat(client, message):
|
|
|
+ chat = message.chat
|
|
|
+ user = message.from_user
|
|
|
+ if message.chat.type != ChatType.PRIVATE:
|
|
|
+ await message.reply_text(
|
|
|
+ "Fedchats can only be checked by privately messaging me."
|
|
|
+ )
|
|
|
+ return
|
|
|
+ if len(message.command) < 2:
|
|
|
+ await message.reply_text(
|
|
|
+ "Please write the Id of the federation!\n\nUsage:\n/fedchats fed_id"
|
|
|
+ )
|
|
|
+ return
|
|
|
+ args = message.text.split(" ", 1)
|
|
|
+ if len(args) > 1:
|
|
|
+ fed_id = args[1].strip()
|
|
|
+ info = await get_fed_info(fed_id)
|
|
|
+ if info is False:
|
|
|
+ await message.reply_text("This federation does not exist.")
|
|
|
+ return
|
|
|
+ fed_owner = info["owner_id"]
|
|
|
+ fed_admins = info["fadmins"]
|
|
|
+ all_admins = [fed_owner] + fed_admins + [int(BOT_ID)]
|
|
|
+ if user.id in all_admins or user.id in SUDOERS:
|
|
|
+ pass
|
|
|
+ else:
|
|
|
+ return await message.reply_text(
|
|
|
+ "You need to be a Fed Admin to use this command"
|
|
|
+ )
|
|
|
+
|
|
|
+ chat_ids, chat_names = await chat_id_and_names_in_fed(fed_id)
|
|
|
+ if not chat_ids:
|
|
|
+ return await message.reply_text("There are no chats in this federation!")
|
|
|
+ text = "\n".join(
|
|
|
+ [
|
|
|
+ f"${chat_name} [`{chat_id}`]"
|
|
|
+ for chat_id, chat_name in zip(chat_ids, chat_names)
|
|
|
+ ]
|
|
|
+ )
|
|
|
+ await message.reply_text(
|
|
|
+ f"**Here are the list of chats connected to this federation:**\n\n{text}"
|
|
|
+ )
|
|
|
+
|
|
|
+
|
|
|
+@app.on_message(filters.command("fpromote"))
|
|
|
+@capture_err
|
|
|
+async def fpromote(client, message):
|
|
|
+ chat = message.chat
|
|
|
+ user = message.from_user
|
|
|
+ msg = message
|
|
|
+
|
|
|
+ if message.chat.type == ChatType.PRIVATE:
|
|
|
+ await message.reply_text(
|
|
|
+ "This command is specific to groups, not our pm!",
|
|
|
+ )
|
|
|
+ return
|
|
|
+
|
|
|
+ fed_id = await get_fed_id(chat.id)
|
|
|
+ if not fed_id:
|
|
|
+ return await message.reply_text(
|
|
|
+ "You need to add a federation to this chat first!"
|
|
|
+ )
|
|
|
+
|
|
|
+ if await is_user_fed_owner(fed_id, user.id) or user.id in SUDOERS:
|
|
|
+ user_id = await extract_user(msg)
|
|
|
+
|
|
|
+ if user_id is None:
|
|
|
+ await message.reply_text("Failed to extract user from the message.")
|
|
|
+ return
|
|
|
+ check_user = await check_banned_user(fed_id, user_id)
|
|
|
+ if check_user:
|
|
|
+ user = await app.get_users(user_id)
|
|
|
+ reason = check_user["reason"]
|
|
|
+ date = check_user["date"]
|
|
|
+ return await message.reply_text(
|
|
|
+ f"**User {user.mention} was Fed Banned.\nyou can unban the user and promote.\n\nReason: {reason}.\nDate: {date}.**"
|
|
|
+ )
|
|
|
+
|
|
|
+ getuser = await search_user_in_fed(fed_id, user_id)
|
|
|
+ info = await get_fed_info(fed_id)
|
|
|
+ get_owner = info["owner_id"]
|
|
|
+
|
|
|
+ if user_id == get_owner:
|
|
|
+ await message.reply_text(
|
|
|
+ "You do know that the user is the federation owner, right? RIGHT?"
|
|
|
+ )
|
|
|
+ return
|
|
|
+
|
|
|
+ if getuser:
|
|
|
+ await message.reply_text(
|
|
|
+ "I cannot promote users who are already federation admins! Can remove them if you want!"
|
|
|
+ )
|
|
|
+ return
|
|
|
+
|
|
|
+ if user_id == BOT_ID:
|
|
|
+ await message.reply_text(
|
|
|
+ "I already am a federation admin in all federations!"
|
|
|
+ )
|
|
|
+ return
|
|
|
+ res = await user_join_fed(str(fed_id), user_id)
|
|
|
+ if res:
|
|
|
+ await message.reply_text("Successfully Promoted!")
|
|
|
+ else:
|
|
|
+ await message.reply_text("Failed to promote!")
|
|
|
+ else:
|
|
|
+ await message.reply_text("Only federation owners can do this!")
|
|
|
+
|
|
|
+
|
|
|
+@app.on_message(filters.command("fdemote"))
|
|
|
+@capture_err
|
|
|
+async def fdemote(client, message):
|
|
|
+ chat = message.chat
|
|
|
+ user = message.from_user
|
|
|
+ msg = message
|
|
|
+
|
|
|
+ if message.chat.type == ChatType.PRIVATE:
|
|
|
+ await message.reply_text(
|
|
|
+ "This command is specific to groups, not our pm!",
|
|
|
+ )
|
|
|
+ return
|
|
|
+
|
|
|
+ fed_id = await get_fed_id(chat.id)
|
|
|
+ if not fed_id:
|
|
|
+ return await message.reply_text(
|
|
|
+ "You need to add a federation to this chat first!"
|
|
|
+ )
|
|
|
+
|
|
|
+ if await is_user_fed_owner(fed_id, user.id) or user.id in SUDOERS:
|
|
|
+ user_id = await extract_user(msg)
|
|
|
+
|
|
|
+ if user_id is None:
|
|
|
+ await message.reply_text("Failed to extract user from the message.")
|
|
|
+ return
|
|
|
+
|
|
|
+ if user_id == BOT_ID:
|
|
|
+ update.effective_message.reply_text(
|
|
|
+ "The thing you are trying to demote me from will fail to work without me! Just saying."
|
|
|
+ )
|
|
|
+ return
|
|
|
+
|
|
|
+ if await search_user_in_fed(fed_id, user_id) is False:
|
|
|
+ await message.reply_text(
|
|
|
+ "I cannot demote people who are not federation admins!"
|
|
|
+ )
|
|
|
+ return
|
|
|
+
|
|
|
+ res = await user_demote_fed(fed_id, user_id)
|
|
|
+ if res is True:
|
|
|
+ await message.reply_text("Demoted from a Fed Admin!")
|
|
|
+ else:
|
|
|
+ await message.reply_text("Demotion failed!")
|
|
|
+ else:
|
|
|
+ await message.reply_text("Only federation owners can do this!")
|
|
|
+ return
|
|
|
+
|
|
|
+
|
|
|
+@app.on_message(filters.command(["fban", "sfban"]))
|
|
|
+@capture_err
|
|
|
+async def fban_user(client, message):
|
|
|
+ chat = message.chat
|
|
|
+ from_user = message.from_user
|
|
|
+ if message.chat.type == ChatType.PRIVATE:
|
|
|
+ await message.reply_text("This command is specific to groups, not our pm!.")
|
|
|
+ return
|
|
|
+ fed_id = await get_fed_id(chat.id)
|
|
|
+ if not fed_id:
|
|
|
+ return await message.reply_text("**This chat is not a part of any federation.")
|
|
|
+ info = await get_fed_info(fed_id)
|
|
|
+ fed_owner = info["owner_id"]
|
|
|
+ fed_admins = info["fadmins"]
|
|
|
+ all_admins = [fed_owner] + fed_admins + [int(BOT_ID)]
|
|
|
+ if from_user.id in all_admins or from_user.id in SUDOERS:
|
|
|
+ pass
|
|
|
+ else:
|
|
|
+ return await message.reply_text(
|
|
|
+ "You need to be a Fed Admin to use this command"
|
|
|
+ )
|
|
|
+ if len(message.command) < 2:
|
|
|
+ return await message.reply_text(
|
|
|
+ "**You needed to specify a user or reply to their message!**"
|
|
|
+ )
|
|
|
+ user_id, reason = await extract_user_and_reason(message)
|
|
|
+ user = await app.get_users(user_id)
|
|
|
+ if not user_id:
|
|
|
+ return await message.reply_text("I can't find that user.")
|
|
|
+ if user_id in all_admins or user_id in SUDOERS:
|
|
|
+ return await message.reply_text("I can't ban that user.")
|
|
|
+ check_user = await check_banned_user(fed_id, user_id)
|
|
|
+ if check_user:
|
|
|
+ reason = check_user["reason"]
|
|
|
+ date = check_user["date"]
|
|
|
+ return await message.reply_text(
|
|
|
+ f"**User {user.mention} was already Fed Banned.\n\nReason: {reason}.\nDate: {date}.**"
|
|
|
+ )
|
|
|
+ if not reason:
|
|
|
+ return await message.reply("No reason provided.")
|
|
|
+
|
|
|
+ served_chats, _ = await chat_id_and_names_in_fed(fed_id)
|
|
|
+ m = await message.reply_text(
|
|
|
+ f"**Fed Banning {user.mention}!**"
|
|
|
+ + f" **This Action Should Take About {len(served_chats)} Seconds.**"
|
|
|
+ )
|
|
|
+ await add_fban_user(fed_id, user_id, reason)
|
|
|
+ number_of_chats = 0
|
|
|
+ for served_chat in served_chats:
|
|
|
+ try:
|
|
|
+ chat_member = await app.get_chat_member(served_chat, user.id)
|
|
|
+ if chat_member.status == ChatMemberStatus.MEMBER:
|
|
|
+ await app.ban_chat_member(served_chat, user.id)
|
|
|
+ if served_chat != chat.id:
|
|
|
+ if not message.text.startswith("/s"):
|
|
|
+ await app.send_message(
|
|
|
+ served_chat, f"**Fed Banned {user.mention} !**"
|
|
|
+ )
|
|
|
+ number_of_chats += 1
|
|
|
+ await asyncio.sleep(1)
|
|
|
+ except FloodWait as e:
|
|
|
+ await asyncio.sleep(int(e.value))
|
|
|
+ except Exception:
|
|
|
+ pass
|
|
|
+ try:
|
|
|
+ await app.send_message(
|
|
|
+ user.id,
|
|
|
+ f"Hello, You have been fed banned by {from_user.mention},"
|
|
|
+ + " You can appeal for this ban by talking to him.",
|
|
|
+ )
|
|
|
+ except Exception:
|
|
|
+ pass
|
|
|
+ await m.edit(f"Fed Banned {user.mention} !")
|
|
|
+ ban_text = f"""
|
|
|
+__**New Federation Ban**__
|
|
|
+**Origin:** {message.chat.title} [`{message.chat.id}`]
|
|
|
+**Admin:** {from_user.mention}
|
|
|
+**Banned User:** {user.mention}
|
|
|
+**Banned User ID:** `{user_id}`
|
|
|
+**Reason:** __{reason}__
|
|
|
+**Chats:** `{number_of_chats}`"""
|
|
|
+ try:
|
|
|
+ m2 = await app.send_message(
|
|
|
+ info["log_group_id"],
|
|
|
+ text=ban_text,
|
|
|
+ disable_web_page_preview=True,
|
|
|
+ )
|
|
|
+ await m.edit(
|
|
|
+ f"Fed Banned {user.mention} !\nAction Log: {m2.link}",
|
|
|
+ disable_web_page_preview=True,
|
|
|
+ )
|
|
|
+ except Exception:
|
|
|
+ await message.reply_text(
|
|
|
+ "User Fbanned, But This Fban Action Wasn't Logged, Add Me In LOG_GROUP"
|
|
|
+ )
|
|
|
+
|
|
|
+
|
|
|
+@app.on_message(filters.command(["unfban", "sunfban"]))
|
|
|
+@capture_err
|
|
|
+async def funban_user(client, message):
|
|
|
+ chat = message.chat
|
|
|
+ from_user = message.from_user
|
|
|
+ if message.chat.type == ChatType.PRIVATE:
|
|
|
+ await message.reply_text("This command is specific to groups, not our pm!.")
|
|
|
+ return
|
|
|
+ fed_id = await get_fed_id(chat.id)
|
|
|
+ if not fed_id:
|
|
|
+ return await message.reply_text("**This chat is not a part of any federation.")
|
|
|
+ info = await get_fed_info(fed_id)
|
|
|
+ fed_owner = info["owner_id"]
|
|
|
+ fed_admins = info["fadmins"]
|
|
|
+ all_admins = [fed_owner] + fed_admins + [int(BOT_ID)]
|
|
|
+ if from_user.id in all_admins or from_user.id in SUDOERS:
|
|
|
+ pass
|
|
|
+ else:
|
|
|
+ return await message.reply_text(
|
|
|
+ "You need to be a Fed Admin to use this command"
|
|
|
+ )
|
|
|
+ if len(message.command) < 2:
|
|
|
+ return await message.reply_text(
|
|
|
+ "**You needed to specify a user or reply to their message!**"
|
|
|
+ )
|
|
|
+ user_id, reason = await extract_user_and_reason(message)
|
|
|
+ user = await app.get_users(user_id)
|
|
|
+ if not user_id:
|
|
|
+ return await message.reply_text("I can't find that user.")
|
|
|
+ if user_id in all_admins or user_id in SUDOERS:
|
|
|
+ return await message.reply_text("**How can an admin ever be banned!.**")
|
|
|
+ check_user = await check_banned_user(fed_id, user_id)
|
|
|
+ if not check_user:
|
|
|
+ return await message.reply_text(
|
|
|
+ "**I can't unban a user who was never fedbanned.**"
|
|
|
+ )
|
|
|
+ if not reason:
|
|
|
+ return await message.reply("No reason provided.")
|
|
|
+
|
|
|
+ served_chats, _ = await chat_id_and_names_in_fed(fed_id)
|
|
|
+ m = await message.reply_text(
|
|
|
+ f"**Fed UnBanning {user.mention}!**"
|
|
|
+ + f" **This Action Should Take About {len(served_chats)} Seconds.**"
|
|
|
+ )
|
|
|
+ await remove_fban_user(fed_id, user_id)
|
|
|
+ number_of_chats = 0
|
|
|
+ for served_chat in served_chats:
|
|
|
+ try:
|
|
|
+ chat_member = await app.get_chat_member(served_chat, user.id)
|
|
|
+ if chat_member.status == ChatMemberStatus.BANNED:
|
|
|
+ await app.unban_chat_member(served_chat, user.id)
|
|
|
+ if served_chat != chat.id:
|
|
|
+ if not message.text.startswith("/s"):
|
|
|
+ await app.send_message(
|
|
|
+ served_chat, f"**Fed UnBanned {user.mention} !**"
|
|
|
+ )
|
|
|
+ number_of_chats += 1
|
|
|
+ await asyncio.sleep(1)
|
|
|
+ except FloodWait as e:
|
|
|
+ await asyncio.sleep(int(e.value))
|
|
|
+ except Exception:
|
|
|
+ pass
|
|
|
+ try:
|
|
|
+ await app.send_message(
|
|
|
+ user.id,
|
|
|
+ f"Hello, You have been fed unbanned by {from_user.mention},"
|
|
|
+ + " You can thank him for his action.",
|
|
|
+ )
|
|
|
+ except Exception:
|
|
|
+ pass
|
|
|
+ await m.edit(f"Fed UnBanned {user.mention} !")
|
|
|
+ ban_text = f"""
|
|
|
+__**New Federation UnBan**__
|
|
|
+**Origin:** {message.chat.title} [`{message.chat.id}`]
|
|
|
+**Admin:** {from_user.mention}
|
|
|
+**UnBanned User:** {user.mention}
|
|
|
+**UnBanned User ID:** `{user_id}`
|
|
|
+**Reason:** __{reason}__
|
|
|
+**Chats:** `{number_of_chats}`"""
|
|
|
+ try:
|
|
|
+ m2 = await app.send_message(
|
|
|
+ info["log_group_id"],
|
|
|
+ text=ban_text,
|
|
|
+ disable_web_page_preview=True,
|
|
|
+ )
|
|
|
+ await m.edit(
|
|
|
+ f"Fed UnBanned {user.mention} !\nAction Log: {m2.link}",
|
|
|
+ disable_web_page_preview=True,
|
|
|
+ )
|
|
|
+ except Exception:
|
|
|
+ await message.reply_text(
|
|
|
+ "User FUnbanned, But This Fban Action Wasn't Logged, Add Me In LOG_GROUP"
|
|
|
+ )
|
|
|
+
|
|
|
+
|
|
|
+@app.on_message(filters.command("fedstat"))
|
|
|
+async def fedstat(client, message):
|
|
|
+ user = message.from_user
|
|
|
+ if message.chat.type != ChatType.PRIVATE:
|
|
|
+ await message.reply_text(
|
|
|
+ "Federation Ban status can only be checked by privately messaging me."
|
|
|
+ )
|
|
|
+ return
|
|
|
+ if len(message.command) < 2:
|
|
|
+ await message.reply_text("Please provide me the user name and Fed Id!")
|
|
|
+ return
|
|
|
+ user_id, fed_id = await extract_user_and_reason(message)
|
|
|
+ if not user_id:
|
|
|
+ user_id = message.from_user.id
|
|
|
+ fed_id = message.text.split(" ", 1)[1].strip()
|
|
|
+ if not fed_id:
|
|
|
+ return await message.reply_text(
|
|
|
+ "provide me a Fed Id along with the command to search for."
|
|
|
+ )
|
|
|
+ info = await get_fed_info(fed_id)
|
|
|
+ if not info:
|
|
|
+ await message.reply_text("Please enter a valid fed id")
|
|
|
+ else:
|
|
|
+ check_user = await check_banned_user(fed_id, user_id)
|
|
|
+ if check_user:
|
|
|
+ user = await app.get_users(user_id)
|
|
|
+ reason = check_user["reason"]
|
|
|
+ date = check_user["date"]
|
|
|
+ return await message.reply_text(
|
|
|
+ f"**User {user.mention} was Fed Banned for:\n\nReason: {reason}.\nDate: {date}.**"
|
|
|
+ )
|
|
|
+ else:
|
|
|
+ await message.reply_text(
|
|
|
+ f"**User {user.mention} is not Fed Banned in this federation.**"
|
|
|
+ )
|
|
|
+
|
|
|
+
|
|
|
+@app.on_message(filters.command("fbroadcast"))
|
|
|
+@capture_err
|
|
|
+async def fbroadcast_message(client, message):
|
|
|
+ chat = message.chat
|
|
|
+ from_user = message.from_user
|
|
|
+ reply_message = message.reply_to_message
|
|
|
+ if message.chat.type == ChatType.PRIVATE:
|
|
|
+ await message.reply_text("This command is specific to groups, not our pm!.")
|
|
|
+ return
|
|
|
+ fed_id = await get_fed_id(chat.id)
|
|
|
+ if not fed_id:
|
|
|
+ return await message.reply_text("**This chat is not a part of any federation.")
|
|
|
+ info = await get_fed_info(fed_id)
|
|
|
+ fed_owner = info["owner_id"]
|
|
|
+ fed_admins = info["fadmins"]
|
|
|
+ all_admins = [fed_owner] + fed_admins + [int(BOT_ID)]
|
|
|
+ if from_user.id in all_admins or from_user.id in SUDOERS:
|
|
|
+ pass
|
|
|
+ else:
|
|
|
+ return await message.reply_text(
|
|
|
+ "You need to be a Fed Admin to use this command"
|
|
|
+ )
|
|
|
+ if not reply_message:
|
|
|
+ return await message.reply_text(
|
|
|
+ "**You need to reply to a text message to Broadcasted it.**"
|
|
|
+ )
|
|
|
+ sleep_time = 0.1
|
|
|
+
|
|
|
+ if reply_message.text:
|
|
|
+ text = reply_message.text.markdown
|
|
|
+ else:
|
|
|
+ return await message.reply_text("You can only Broadcast text messages.")
|
|
|
+
|
|
|
+ reply_markup = None
|
|
|
+ if reply_message.reply_markup:
|
|
|
+ reply_markup = InlineKeyboardMarkup(reply_message.reply_markup.inline_keyboard)
|
|
|
+ sent = 0
|
|
|
+ chats, _ = await chat_id_and_names_in_fed(fed_id)
|
|
|
+ m = await message.reply_text(
|
|
|
+ f"Broadcast in progress, will take {len(chats) * sleep_time} seconds."
|
|
|
+ )
|
|
|
+ for i in chats:
|
|
|
+ try:
|
|
|
+ await app.send_message(
|
|
|
+ i,
|
|
|
+ text=text,
|
|
|
+ reply_markup=reply_markup,
|
|
|
+ )
|
|
|
+ sent += 1
|
|
|
+ await asyncio.sleep(sleep_time)
|
|
|
+ except FloodWait as e:
|
|
|
+ await asyncio.sleep(int(e.value))
|
|
|
+ except Exception:
|
|
|
+ pass
|
|
|
+ await m.edit(f"**Broadcasted Message In {sent} Chats.**")
|
|
|
+
|
|
|
+
|
|
|
+@app.on_message(filters.command(["fedinfo", "fedadmins"]))
|
|
|
+async def to_do(client, message):
|
|
|
+ await message.reply_text("**Feel free to use your coding skills and open a pull request.**")
|
|
|
+
|
|
|
+
|
|
|
+@app.on_callback_query(filters.regex("rmfed_(.*)"))
|
|
|
+async def del_fed_button(client, cb):
|
|
|
+ query = cb.data
|
|
|
+ userid = cb.message.chat.id
|
|
|
+ fed_id = query.split("_")[1]
|
|
|
+
|
|
|
+ if fed_id == "cancel":
|
|
|
+ await cb.message.edit_text("Federation deletion cancelled")
|
|
|
+ return
|
|
|
+
|
|
|
+ getfed = await get_fed_info(fed_id)
|
|
|
+ if getfed:
|
|
|
+ delete = fedsdb.delete_one({"fed_id": str(fed_id)})
|
|
|
+ if delete:
|
|
|
+ await cb.message.edit_text(
|
|
|
+ "You have removed your Federation! Now all the Groups that are connected with `{}` do not have a Federation.".format(
|
|
|
+ getfed["fed_name"]
|
|
|
+ ),
|
|
|
+ parse_mode=ParseMode.MARKDOWN,
|
|
|
+ )
|
|
|
+
|
|
|
+
|
|
|
+@app.on_callback_query(filters.regex("trfed_(.*)"))
|
|
|
+async def fedtransfer_button(client, cb):
|
|
|
+ query = cb.data
|
|
|
+ userid = cb.message.chat.id
|
|
|
+ data = query.split("_")[1]
|
|
|
+
|
|
|
+ if data == "cancel":
|
|
|
+ await cb.message.edit_text("Federation deletion cancelled")
|
|
|
+ return
|
|
|
+ data2 = data.split("|", 1)
|
|
|
+ new_owner_id = int(data2[0])
|
|
|
+ fed_id = data2[1]
|
|
|
+ transferred = await transfer_owner(fed_id, userid, new_owner_id)
|
|
|
+ if transferred:
|
|
|
+ await cb.message.edit_text(
|
|
|
+ "**Successfully transferred ownership to new owner.**"
|
|
|
+ )
|
|
|
+
|
|
|
+
|
|
|
+@app.on_callback_query(filters.regex("fed_(.*)"))
|
|
|
+async def fed_owner_help(client, cb):
|
|
|
+ query = cb.data
|
|
|
+ userid = cb.message.chat.id
|
|
|
+ data = query.split("_")[1]
|
|
|
+ if data == "owner":
|
|
|
+ text = """**👑 Fed Owner Only:**
|
|
|
+ • /newfed <fed_name>**:** Creates a Federation, One allowed per user
|
|
|
+ • /renamefed <fed_id> <new_fed_name>**:** Renames the fed id to a new name
|
|
|
+ • /delfed <fed_id>**:** Delete a Federation, and any information related to it. Will not cancel blocked users
|
|
|
+ • /myfeds**:** To list the federations that you have created
|
|
|
+ • /fedtransfer <new_owner> <fed_id>**:**To transfer fed ownership to another person
|
|
|
+ • /fpromote <user>**:** Assigns the user as a federation admin. Enables all commands for the user under `Fed Admins`
|
|
|
+ • /fdemote <user>**:** Drops the User from the admin Federation to a normal User
|
|
|
+ • /setfedlog <fed_id>**:** Sets the group as a fed log report base for the federation
|
|
|
+ • /unsetfedlog <fed_id>**:** Removed the group as a fed log report base for the federation
|
|
|
+ • /fbroadcast **:** Broadcasts a messages to all groups that have joined your fed """
|
|
|
+ elif data == "admin":
|
|
|
+ text = """**🔱 Fed Admins:**
|
|
|
+ • /fban <user> <reason>**:** Fed bans a user
|
|
|
+ • /sfban**:** Fban a user without sending notification to chats
|
|
|
+ • /unfban <user> <reason>**:** Removes a user from a fed ban
|
|
|
+ • /sunfban**:** Unfban a user without sending a notification
|
|
|
+ • /fedadmins**:** Show Federation admin
|
|
|
+ • /fedchats <FedID>**:** Get all the chats that are connected in the Federation
|
|
|
+ • /fbroadcast **:** Broadcasts a messages to all groups that have joined your fed
|
|
|
+ """
|
|
|
+ else:
|
|
|
+ text = """**User Commands:**
|
|
|
+• /fedinfo <FedID>: Information about a federation.
|
|
|
+• /fedadmins <FedID>: List the admins in a federation.
|
|
|
+• /joinfed <FedID>: Join the current chat to a federation. A chat can only join one federation. Chat owners only.
|
|
|
+• /leavefed: Leave the current federation. Only chat owners can do this.
|
|
|
+• /fedstat <FedID>: Gives information about your ban in a federation.
|
|
|
+• /fedstat <user ID> <FedID>: Gives information about a user's ban in a federation.
|
|
|
+• /chatfed: Information about the federation the current chat is in.
|
|
|
+"""
|
|
|
+ await cb.message.edit(
|
|
|
+ text,
|
|
|
+ reply_markup=InlineKeyboardMarkup(
|
|
|
+ [
|
|
|
+ [
|
|
|
+ InlineKeyboardButton(
|
|
|
+ "Back", callback_data="help_module(federation)"
|
|
|
+ ),
|
|
|
+ ]
|
|
|
+ ]
|
|
|
+ ),
|
|
|
+ parse_mode=ParseMode.MARKDOWN,
|
|
|
+ )
|
SI_NN_ER_LS