async def add_sudo_cmd(message: Message):
""" add sudo cmd """
if '-all' in message.flags:
await SUDO_CMDS_COLLECTION.drop()
Config.ALLOWED_COMMANDS.clear()
tmp_ = []
for c_d in list(xdecha.manager.enabled_commands):
t_c = c_d.lstrip(Config.CMD_TRIGGER)
tmp_.append({'_id': t_c})
Config.ALLOWED_COMMANDS.add(t_c)
await asyncio.gather(
SUDO_CMDS_COLLECTION.insert_many(tmp_),
message.edit(f"**Added** all (`{len(tmp_)}`) commands to **SUDO** cmds!",
del_in=5, log=__name__))
return
cmd = message.input_str
if not cmd:
await message.err('input not found!')
return
cmd = cmd.lstrip(Config.CMD_TRIGGER)
if cmd in Config.ALLOWED_COMMANDS:
await message.edit(f"cmd : `{cmd}` already in **SUDO**!", del_in=5)
elif cmd not in (c_d.lstrip(Config.CMD_TRIGGER)
for c_d in list(xdecha.manager.enabled_commands)):
await message.edit(f"cmd : `{cmd}` 🤔, is that a command ?", del_in=5)
else:
Config.ALLOWED_COMMANDS.add(cmd)
await asyncio.gather(
SUDO_CMDS_COLLECTION.insert_one({'_id': cmd}),
message.edit(f"cmd : `{cmd}` added to **SUDO**!", del_in=5, log=__name__))
async def del_sudo(message: Message):
""" delete sudo user """
if '-all' in message.flags:
Config.SUDO_USERS.clear()
await asyncio.gather(
SUDO_USERS_COLLECTION.drop(),
message.edit("**SUDO** users cleared!", del_in=5))
return
user_id = message.filtered_input_str
if message.reply_to_message:
user_id = message.reply_to_message.from_user.id
if not user_id:
await message.err(f'user: `{user_id}` not found!')
return
if isinstance(user_id, str) and user_id.isdigit():
user_id = int(user_id)
if not isinstance(user_id, int):
await message.err('invalid type!')
return
if user_id not in Config.SUDO_USERS:
await message.edit(f"user : `{user_id}` not in **SUDO**!", del_in=5)
else:
Config.SUDO_USERS.remove(user_id)
await asyncio.gather(
SUDO_USERS_COLLECTION.delete_one({'_id': user_id}),
message.edit(f"user : `{user_id}` removed from **SUDO**!", del_in=5, log=__name__))
async def enable_userbot(message: Message):
if message.flags:
if '-all' in message.flags:
Config.DISABLED_ALL = False
Config.DISABLED_CHATS.clear()
await asyncio.gather(
DISABLED_CHATS.drop(),
SAVED_SETTINGS.update_one({'_id': 'DISABLE_ALL_CHATS'},
{"$set": {
'on': False
}},
upsert=True),
message.edit("**Enabled** all chats!", del_in=5))
else:
await message.err("invalid flag!")
elif message.input_str:
try:
chat = await message.client.get_chat(message.input_str)
except Exception as err:
await message.err(str(err))
return
if chat.id not in Config.DISABLED_CHATS:
await message.edit("this chat is already enabled!")
else:
Config.DISABLED_CHATS.remove(chat.id)
await asyncio.gather(
DISABLED_CHATS.delete_one({'_id': chat.id}),
message.edit(
f"CHAT : `{chat.title}` removed from **DISABLED_CHATS**!",
del_in=5,
log=__name__))
else:
await message.err("chat_id not found!")
async def delete_filters(message: Message) -> None:
""" delete filter in current chat """
if '-every' in message.flags:
FILTERS_DATA.clear()
await asyncio.gather(
FILTERS_COLLECTION.drop(),
message.edit("`Cleared All Filters in Every Chat !`", del_in=5))
return
if '-all' in message.flags:
if message.chat.id in FILTERS_DATA:
del FILTERS_DATA[message.chat.id]
await asyncio.gather(
FILTERS_COLLECTION.delete_many({'chat_id': message.chat.id}),
message.edit("`Cleared All Filters in This Chat !`", del_in=5))
else:
await message.err("Couldn't find filters in this chat!")
return
filter_ = message.input_str
if not filter_:
out = "`Wrong syntax`\nNo arguements"
elif await FILTERS_COLLECTION.find_one_and_delete({
'chat_id': message.chat.id,
'name': filter_
}):
out = "`Successfully deleted filter:` **{}**".format(filter_)
_filter_deleter(message.chat.id, filter_)
else:
out = "`Couldn't find filter:` **{}**".format(filter_)
await message.edit(text=out, del_in=3)
async def remove_note(message: Message) -> None:
""" delete note in current chat """
if '-every' in message.flags:
NOTES_DATA.clear()
await asyncio.gather(
NOTES_COLLECTION.drop(),
message.edit("`Cleared All Notes in Every Chat !`", del_in=5))
return
if '-all' in message.flags:
if message.chat.id in NOTES_DATA:
del NOTES_DATA[message.chat.id]
await asyncio.gather(
NOTES_COLLECTION.delete_many({'chat_id': message.chat.id}),
message.edit("`Cleared All Notes in This Chat !`", del_in=5))
else:
await message.err("Couldn't find notes in this chat!")
return
notename = message.input_str
if not notename:
out = "`Wrong syntax`\nNo arguements"
elif await NOTES_COLLECTION.find_one_and_delete({
'chat_id': message.chat.id,
'name': notename
}):
out = "`Successfully deleted note:` **{}**".format(notename)
_note_deleter(message.chat.id, notename)
else:
out = "`Couldn't find note:` **{}**".format(notename)
await message.edit(text=out, del_in=3)
async def rmwhitelist(message: Message):
""" remove a user from whitelist """
user_id, _ = message.extract_user_and_text
if not user_id:
await message.err("user-id not found")
return
get_mem = await message.client.get_user_dict(user_id)
firstname = get_mem['fname']
user_id = get_mem['id']
found = await WHITELIST.find_one({'user_id': user_id})
if not found:
await message.err("User Not Found in My WhiteList")
return
await asyncio.gather(
WHITELIST.delete_one({
'firstname': firstname,
'user_id': user_id
}),
message.edit(
r"\\**#Removed_Whitelisted_User**//"
f"\n\n**First Name:** [{firstname}](tg://user?id={user_id})\n"
f"**User ID:** `{user_id}`"),
CHANNEL.log(
r"\\**#Antispam_Log**//"
f"\n**User:** [{firstname}](tg://user?id={user_id})\n"
f"**User ID:** `{user_id}`\n"
f"**Chat:** {message.chat.title}\n"
f"**Chat ID:** `{message.chat.id}`\n\n$RMWHITELISTED #id{user_id}")
)
LOG.info("WhiteListed %s", str(user_id))
async def del_sudo_cmd(message: Message):
""" delete sudo cmd """
if '-all' in message.flags:
Config.ALLOWED_COMMANDS.clear()
await asyncio.gather(
SUDO_CMDS_COLLECTION.drop(),
message.edit("**SUDO** cmds cleared!", del_in=5))
return
cmd = message.filtered_input_str
if not cmd:
await message.err('input not found!')
return
if cmd not in Config.ALLOWED_COMMANDS:
await message.edit(f"cmd : `{cmd}` not in **SUDO**!", del_in=5)
else:
Config.ALLOWED_COMMANDS.remove(cmd)
await asyncio.gather(
SUDO_CMDS_COLLECTION.delete_one({'_id': cmd}),
message.edit(f"cmd : `{cmd}` removed from **SUDO**!", del_in=5, log=__name__))
async def active_afk(message: Message) -> None:
""" turn on or off afk mode """
global REASON, IS_AFK, TIME # pylint: disable=global-statement
IS_AFK = True
TIME = time.time()
REASON = message.input_str
await asyncio.gather(
CHANNEL.log(f"You went AFK! : `{REASON}`"),
message.edit("`You went AFK!`", del_in=1),
AFK_COLLECTION.drop(),
SAVED_SETTINGS.update_one(
{'_id': 'AFK'}, {"$set": {'on': True, 'data': REASON, 'time': TIME}}, upsert=True))
async def disable_userbot(message: Message):
if message.flags:
if '-all' in message.flags:
Config.DISABLED_ALL = True
await asyncio.gather(
SAVED_SETTINGS.update_one({'_id': 'DISABLE_ALL_CHATS'},
{"$set": {
'on': True
}},
upsert=True),
message.edit("**Disabled** all chats!", del_in=5))
else:
await message.err("invalid flag!")
else:
chat = message.chat
if message.input_str:
try:
chat = await message.client.get_chat(message.input_str)
except Exception as err:
await message.err(str(err))
return
if chat.id in Config.DISABLED_CHATS:
await message.edit("this chat is already disabled!")
elif chat.id == Config.LOG_CHANNEL_ID:
await message.err("can't disabled log channel")
else:
Config.DISABLED_CHATS.add(chat.id)
await asyncio.gather(
DISABLED_CHATS.insert_one({
'_id': chat.id,
'title': chat.title
}),
message.edit(
f"CHAT : `{chat.title}` added to **DISABLED_CHATS**!",
del_in=5,
log=__name__))
async def add_sudo(message: Message):
""" add sudo user """
user_id = message.input_str
if message.reply_to_message:
user_id = message.reply_to_message.from_user.id
if not user_id:
await message.err(f'user: `{user_id}` not found!')
return
if isinstance(user_id, str) and user_id.isdigit():
user_id = int(user_id)
try:
user = await message.client.get_user_dict(user_id)
except PeerIdInvalid as p_e:
await message.err(p_e)
return
if user['id'] in Config.SUDO_USERS:
await message.edit(f"user : `{user['id']}` already in **SUDO**!", del_in=5)
else:
Config.SUDO_USERS.add(user['id'])
await asyncio.gather(
SUDO_USERS_COLLECTION.insert_one({'_id': user['id'], 'men': user['mention']}),
message.edit(f"user : `{user['id']}` added to **SUDO**!", del_in=5, log=__name__))
async def ungmute_user(msg: Message):
""" unmute a user globally """
await msg.edit("`UnGMuting this User...`")
user_id, _ = msg.extract_user_and_text
if not user_id:
await msg.err("user-id not found")
return
get_mem = await msg.client.get_user_dict(user_id)
firstname = get_mem['fname']
user_id = get_mem['id']
found = await GMUTE_USER_BASE.find_one({'user_id': user_id})
if not found:
await msg.err("User Not Found in My GMute List")
return
await asyncio.gather(
GMUTE_USER_BASE.delete_one({
'firstname': firstname,
'user_id': user_id
}),
msg.edit(r"\\**#UnGMuted_User**//"
f"\n\n**First Name:** [{firstname}](tg://user?id={user_id})\n"
f"**User ID:** `{user_id}`"))
chats = [
msg.chat
] if msg.client.is_bot else await msg.client.get_common_chats(user_id)
for chat in chats:
try:
await chat.unban_member(user_id)
await CHANNEL.log(
r"\\**#Antispam_Log**//"
f"\n**User:** [{firstname}](tg://user?id={user_id})\n"
f"**User ID:** `{user_id}`\n"
f"**Chat:** {chat.title}\n"
f"**Chat ID:** `{chat.id}`\n\n$UNGMUTED #id{user_id}")
except (ChatAdminRequired, UserAdminInvalid):
pass
LOG.info("UnGMuted %s", str(user_id))
async def gmute_user(msg: Message):
""" Mute a user globally """
await msg.edit("`Globally Muting this User...`")
user_id, reason = msg.extract_user_and_text
if not user_id:
await msg.edit("`no valid user_id or message specified,`"
"`don't do .help gmute for more info. "
"Coz no one's gonna help ya`(｡ŏ_ŏ) ⚠")
return
get_mem = await msg.client.get_user_dict(user_id)
firstname = get_mem['fname']
if not reason:
await msg.edit(
f"**#Aborted**\n\n**GMuting** of [{firstname}](tg://user?id={user_id}) "
"`Aborted coz No reason of GMute provided by User`",
del_in=5)
return
user_id = get_mem['id']
if user_id == msg.from_user.id:
await msg.err(r"LoL. Why would I GMuting myself ¯\(°_o)/¯")
return
if user_id in Config.SUDO_USERS:
await msg.edit(
"`That user is in my Sudo List, Hence I can't GMute him.`\n\n"
"**Tip:** `Remove them from Sudo List and try again. (¬_¬)`",
del_in=5)
return
found = await GMUTE_USER_BASE.find_one({'user_id': user_id})
if found:
await msg.edit(
"**#Already_GMuted**\n\n`This User Already Exists in My GMute List.`\n"
f"**Reason For GMute:** `{found['reason']}`")
return
await asyncio.gather(
GMUTE_USER_BASE.insert_one({
'firstname': firstname,
'user_id': user_id,
'reason': reason
}),
msg.edit(r"\\**#GMuted_User**//"
f"\n\n**First Name:** [{firstname}](tg://user?id={user_id})\n"
f"**User ID:** `{user_id}`\n**Reason:** `{reason}`"))
chats = [
msg.chat
] if msg.client.is_bot else await msg.client.get_common_chats(user_id)
for chat in chats:
try:
await chat.restrict_member(user_id, ChatPermissions())
await CHANNEL.log(
r"\\**#Antispam_Log**//"
f"\n**User:** [{firstname}](tg://user?id={user_id})\n"
f"**User ID:** `{user_id}`\n"
f"**Chat:** {chat.title}\n"
f"**Chat ID:** `{chat.id}`\n"
f"**Reason:** `{reason}`\n\n$GMUTE #id{user_id}")
except (ChatAdminRequired, UserAdminInvalid):
pass
if msg.reply_to_message:
await CHANNEL.fwd_msg(msg.reply_to_message)
await CHANNEL.log(f'$GMUTE #prid{user_id} ⬆️')
LOG.info("G-Muted %s", str(user_id))