async def catgban(event): # sourcery no-metrics
"To ban user in every group where you are admin."
cate = await edit_or_reply(event, "`gbanning.......`")
start = datetime.now()
user, reason = await get_user_from_event(event, cate)
if not user:
return
if user.id == catub.uid:
return await edit_delete(cate, "`why would I ban myself`")
if gban_sql.is_gbanned(user.id):
await cate.edit(
f"``[{user.first_name}](tg://user?id={user.id})` is already in gbanned list any way checking again`"
)
else:
gban_sql.catgban(user.id, reason)
san = await admin_groups(event.client)
count = 0
sandy = len(san)
if sandy == 0:
return await edit_delete(cate,
"`you are not admin of atleast one group` ")
await cate.edit(
f"`initiating gban of `[{user.first_name}](tg://user?id={user.id}) `in {len(san)} groups`"
)
for i in range(sandy):
try:
await event.client(
EditBannedRequest(san[i], user.id, BANNED_RIGHTS))
await asyncio.sleep(0.5)
count += 1
except BadRequestError:
achat = await event.client.get_entity(san[i])
await event.client.send_message(
BOTLOG_CHATID,
f"`You don't have required permission in :`\n**Chat :** {get_display_name(achat)}(`{achat.id}`)\n`For banning here`",
)
end = datetime.now()
cattaken = (end - start).seconds
if reason:
await cate.edit(
f"[{user.first_name}](tg://user?id={user.id}) `was gbanned in {count} groups in {cattaken} seconds`!!\n**Reason :** `{reason}`"
)
else:
await cate.edit(
f"[{user.first_name}](tg://user?id={user.id}) `was gbanned in {count} groups in {cattaken} seconds`!!"
)
if BOTLOG and count != 0:
reply = await event.get_reply_message()
if reason:
await event.client.send_message(
BOTLOG_CHATID,
f"#GBAN\
\nGlobal Ban\
\n**User : **[{user.first_name}](tg://user?id={user.id})\
\n**ID : **`{user.id}`\
\n**Reason :** `{reason}`\
\n__Banned in {count} groups__\
\n**Time taken : **`{cattaken} seconds`",
)
else:
await event.client.send_message(
BOTLOG_CHATID,
f"#GBAN\
\nGlobal Ban\
\n**User : **[{user.first_name}](tg://user?id={user.id})\
\n**ID : **`{user.id}`\
\n__Banned in {count} groups__\
\n**Time taken : **`{cattaken} seconds`",
)
try:
if reply:
await reply.forward_to(BOTLOG_CHATID)
await reply.delete()
except BadRequestError:
pass
async def tban(event): # sourcery no-metrics
"To ban a person for specific time"
catevent = await edit_or_reply(event, "**يتم الحظر 🧸♥**")
user, reason = await get_user_from_event(event, catevent)
if not user:
return
if not reason:
return await catevent.edit(
"**- يبدو انك لم تقم بوضع وقت مع الامر ارسل **")
reason = reason.split(" ", 1)
hmm = len(reason)
cattime = reason[0].strip()
reason = "".join(reason[1:]) if hmm > 1 else None
ctime = await extract_time(catevent, cattime)
if not ctime:
return
if user.id == event.client.uid:
return await catevent.edit(f"** عذرا لا يمكنني كتم نفسـي**")
await catevent.edit("** اتـمنالك الخيـر 🖤**")
try:
await event.client(
EditBannedRequest(
event.chat_id,
user.id,
ChatBannedRights(until_date=ctime, view_messages=True),
))
except UserAdminInvalidError:
return await catevent.edit(
"** يبـدو أنك لسـت مشرف في المجموعة او تحاول كتم مشـرف هنا**")
except BadRequestError:
return await catevent.edit(NO_PERM)
# Helps ban group join spammers more easily
try:
reply = await event.get_reply_message()
if reply:
await reply.delete()
except BadRequestError:
return await catevent.edit(
"** لـيس لدي صلاحيـات الحذف لكن سيبقى محظور ❕**")
# Delete message and then tell that the command
# is done gracefully
# Shout out the ID, so that fedadmins can fban later
if reason:
await catevent.edit(
f"**المستخدم {_format.mentionuser(user.first_name ,user.id)}** /n **تـم حظره بنـجاح ✅**\n"
f"مـدة الحـظر {cattime}\n"
f"السـبب:`{reason}`")
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"#الـحظر المـؤقت\n"
f"**المستخدم : **[{user.first_name}](tg://user?id={user.id})\n"
f"**الدردشـه : **{event.chat.title}(`{event.chat_id}`)\n"
f"**مـدة الحـظر : **`{cattime}`\n"
f"**السـبب : **__{reason}__",
)
else:
await catevent.edit(
f"** الـمستخدم {_format.mentionuser(user.first_name ,user.id)} \n **تـم حظره بنـجاح ✅** \n"
f"**مـدة الحـظر** {cattime}\n")
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"#الـحظر المـؤقت\n"
f"**المستخدم : **[{user.first_name}](tg://user?id={user.id})\n"
f"**المستخدم : **{event.chat.title}(`{event.chat_id}`)\n"
f"**مـدة الحـظر : **`{cattime}`",
)
async def welcome_mute(welcm):
''' Ban a recently joined user if it matches the spammer checking algorithm. '''
if not WELCOME_MUTE:
return
if welcm.user_joined or welcm.user_added:
adder = None
ignore = None
if welcm.user_added:
ignore = False
adder = welcm.action_message.from_id
async for admin in bot.iter_participants(welcm.chat_id, filter=ChannelParticipantsAdmins):
if admin.id == adder:
ignore = True
break
if ignore:
return
elif welcm.user_joined:
users_list = hasattr(welcm.action_message.action, "users")
if users_list:
users = welcm.action_message.action.users
else:
users = [welcm.action_message.from_id]
await sleep(5)
spambot = False
for user_id in users:
async for message in bot.iter_messages(
welcm.chat_id,
from_user=user_id
):
correct_type = isinstance(message, Message)
if not message or not correct_type:
break
join_time = welcm.action_message.date
message_date = message.date
if message_date < join_time:
continue # The message was sent before the user joined, thus ignore it
# DEBUGGING. LEAVING IT HERE FOR SOME TIME ###
print(f"User Joined: {join_time}")
print(f"Message Sent: {message_date}")
#
user = await welcm.client.get_entity(user_id)
if "http://" in message.text:
spambot = True
elif "t.me" in message.text:
spambot = True
elif message.fwd_from:
spambot = True
elif "https://" in message.text:
spambot = True
else:
if user.first_name in (
"Bitmex",
"Promotion",
"Information",
"Dex",
"Announcements",
"Info"
):
if user.last_name == "Bot":
spambot = True
if spambot:
print(f"Potential Spam Message: {message.text}")
await message.delete()
break
continue # Check the next messsage
if spambot:
await welcm.reply(
"`Potential Spambot Detected! Kicking away! "
"Will log the ID for further purposes!\n"
f"USER:` [{user.first_name}](tg://user?id={user.id})")
chat = await welcm.get_chat()
admin = chat.admin_rights
creator = chat.creator
if not admin and not creator:
await welcm.reply(
"@admins\n"
"`ANTI SPAMBOT DETECTOR!\n"
"THIS USER MATCHES MY ALGORITHMS AS A SPAMBOT!`")
else:
try:
await welcm.client(
EditBannedRequest(
welcm.chat_id,
user.id,
BANNED_RIGHTS
)
)
await sleep(1)
await welcm.client(
EditBannedRequest(
welcm.chat_id,
user.id,
UNBAN_RIGHTS
)
)
except BaseException:
await welcm.reply(
"@admins\n"
"`ANTI SPAMBOT DETECTOR!\n"
"THIS USER MATCHES MY ALGORITHMS AS A SPAMBOT!`")
if BOTLOG:
await welcm.client.send_message(
BOTLOG_CHATID,
"#SPAMBOT-KICK\n"
f"USER: [{user.first_name}](tg://user?id={user.id})\n"
f"CHAT: {welcm.chat.title}(`{welcm.chat_id}`)"
)
async def catgban(event):
"To unban the person from every group where you are admin."
cate = await edit_or_reply(event, "`ungbanning.....`")
start = datetime.now()
user, reason = await get_user_from_event(event, cate)
if not user:
return
if gban_sql.is_gbanned(user.id):
gban_sql.catungban(user.id)
else:
return await edit_delete(
cate,
f"[{user.first_name}](tg://user?id={user.id}) `is not in your gbanned list`",
)
san = await admin_groups(event.client)
count = 0
sandy = len(san)
if sandy == 0:
return await edit_delete(
cate, "`you are not even admin of atleast one group `")
await cate.edit(
f"initiating ungban of [{user.first_name}](tg://user?id={user.id}) in `{len(san)}` groups"
)
for i in range(sandy):
try:
await event.client(EditBannedRequest(san[i], user.id,
UNBAN_RIGHTS))
await asyncio.sleep(0.5)
count += 1
except BadRequestError:
achat = await event.client.get_entity(san[i])
await event.client.send_message(
BOTLOG_CHATID,
f"`You don't have required permission in :`\n**Chat :** {get_display_name(achat)}(`{achat.id}`)\n`For Unbanning here`",
)
end = datetime.now()
cattaken = (end - start).seconds
if reason:
await cate.edit(
f"[{user.first_name}](tg://user?id={user.id}`) was ungbanned in {count} groups in {cattaken} seconds`!!\n**Reason :** `{reason}`"
)
else:
await cate.edit(
f"[{user.first_name}](tg://user?id={user.id}) `was ungbanned in {count} groups in {cattaken} seconds`!!"
)
if BOTLOG and count != 0:
if reason:
await event.client.send_message(
BOTLOG_CHATID,
f"#UNGBAN\
\nGlobal Unban\
\n**User : **[{user.first_name}](tg://user?id={user.id})\
\n**ID : **`{user.id}`\
\n**Reason :** `{reason}`\
\n__Unbanned in {count} groups__\
\n**Time taken : **`{cattaken} seconds`",
)
else:
await event.client.send_message(
BOTLOG_CHATID,
f"#UNGBAN\
\nGlobal Unban\
\n**User : **[{user.first_name}](tg://user?id={user.id})\
\n**ID : **`{user.id}`\
\n__Unbanned in {count} groups__\
\n**Time taken : **`{cattaken} seconds`",
)
async def startmute(event):
if event.is_private:
await event.edit("Unexpected issues or ugly errors may occur!")
await sleep(3)
await event.get_reply_message()
userid = event.chat_id
replied_user = await event.client(GetFullUserRequest(userid))
chat_id = event.chat_id
if is_muted(userid, chat_id):
return await event.edit("This user is already muted🤣🤣🤣")
try:
mute(userid, chat_id)
except Exception as e:
await event.edit("Error occured!\nError is " + str(e))
else:
await event.edit("Chup reh lawde.\n**｀-´)⊃━☆ﾟ.*･｡ﾟ **")
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"#PM_MUTE\n"
f"USER: [{replied_user.user.first_name}](tg://user?id={userid})\n"
f"CHAT: {event.chat.title}(`{event.chat_id}`)",
)
else:
chat = await event.get_chat()
user, reason = await get_user_from_event(event)
if not user:
return
if user.id == bot.uid:
return await edit_or_reply(event, "Sorry, I can't mute myself")
if is_muted(user.id, event.chat_id):
return await edit_or_reply(
event, "This user is already muted in this chat😏🚶"
)
try:
admin = chat.admin_rights
creator = chat.creator
if not admin and not creator:
await edit_or_reply(
event, "`You can't mute a person without admin rights` ಥ﹏ಥ "
)
return
result = await event.client(
functions.channels.GetParticipantRequest(
channel=event.chat_id, user_id=user.id
)
)
try:
if result.participant.banned_rights.send_messages:
return await edit_or_reply(
event,
"This user is already muted in this chat 😏🚶",
)
except:
pass
await event.client(EditBannedRequest(event.chat_id, user.id, MUTE_RIGHTS))
except UserAdminInvalidError:
if "admin_rights" in vars(chat) and vars(chat)["admin_rights"] is not None:
if chat.admin_rights.delete_messages is not True:
return await edit_or_reply(
event,
"`You can't mute a person if you dont have delete messages permission. ಥ﹏ಥ`",
)
elif "creator" not in vars(chat):
return await edit_or_reply(
event, "`You can't mute a person without admin rights.` ಥ﹏ಥ "
)
try:
mute(user.id, event.chat_id)
except Exception as e:
return await edit_or_reply(event, "Error occured!\nError is " + str(e))
except Exception as e:
return await edit_or_reply(event, f"**Error : **`{str(e)}`")
if reason:
await edit_or_reply(
event,
f"{user.first_name} is muted in {event.chat.title}\n"
f"`Reason:`{reason}",
)
else:
await edit_or_reply(
event, f"{user.first_name} is muted in {event.chat.title}"
)
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"#MUTE\n"
f"USER: [{user.first_name}](tg://user?id={user.id})\n"
f"CHAT: {event.chat.title}(`{event.chat_id}`)",
)
async def startmute(event):
if event.fwd_from:
return
if event.is_private:
await event.edit("`Unexpected issues or ugly errors may occur!`")
await sleep(2)
await event.get_reply_message()
userid = event.chat_id
replied_user = await event.client(GetFullUserRequest(userid))
chat_id = event.chat_id
if is_muted(userid, chat_id):
return await event.edit(
"`This user is already muted in this chat ~~lmfao sed rip~~`")
try:
mute(userid, chat_id)
except Exception as e:
await event.edit(f"**Error **\n`{str(e)}`")
else:
await event.edit(
"`Successfully muted that person.\n**｀-´)⊃━☆ﾟ.*･｡ﾟ **`")
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"#PM_MUTE\n"
f"**User :** [{replied_user.user.first_name}](tg://user?id={userid})\n",
)
else:
chat = await event.get_chat()
user, reason = await get_user_from_event(event)
if not user:
return
if user.id == bot.uid:
return await edit_or_reply(event, "`Sorry, I can't mute myself`")
if is_muted(user.id, event.chat_id):
return await edit_or_reply(
event,
"`This user is already muted in this chat ~~lmfao sed rip~~`")
try:
admin = chat.admin_rights
creator = chat.creator
if not admin and not creator:
await edit_or_reply(
event,
"`You can't mute a person without admin rights niqq.` ಥ﹏ಥ "
)
return
result = await event.client(
functions.channels.GetParticipantRequest(channel=event.chat_id,
user_id=user.id))
try:
if result.participant.banned_rights.send_messages:
return await edit_or_reply(
event,
"`This user is already muted in this chat ~~lmfao sed rip~~`",
)
except Exception as e:
LOGS.info(str(e))
await event.client(
EditBannedRequest(event.chat_id, user.id, MUTE_RIGHTS))
except UserAdminInvalidError:
if "admin_rights" in vars(chat) and vars(
chat)["admin_rights"] is not None:
if chat.admin_rights.delete_messages is not True:
return await edit_or_reply(
event,
"`You can't mute a person if you dont have delete messages permission. ಥ﹏ಥ`",
)
elif "creator" not in vars(chat):
return await edit_or_reply(
event,
"`You can't mute a person without admin rights niqq.` ಥ﹏ಥ "
)
try:
mute(user.id, event.chat_id)
except Exception as e:
return await edit_or_reply(event, f"**Error**\n`{str(e)}`")
except Exception as e:
return await edit_or_reply(event, f"**Error : **`{str(e)}`")
if reason:
await edit_or_reply(
event,
f"{_format.mentionuser(user.first_name, user.id)} `is muted in {event.chat.title}`\n"
f"`Reason:`{reason}",
)
else:
await edit_or_reply(
event,
f"{_format.mentionuser(user.first_name, user.id)} `is muted in {event.chat.title}`\n",
)
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"#MUTE\n"
f"**User :** [{user.first_name}](tg://user?id={user.id})\n"
f"**Chat :** {event.chat.title}(`{event.chat_id}`)",
)
async def ban(bon):
""" .ban komutu belirlenen kişiyi gruptan yasaklar """
# Yetki kontrolü
chat = await bon.get_chat()
admin = chat.admin_rights
creator = chat.creator
import datetime
if not admin and not creator:
await bon.edit(NO_ADMIN)
return
user, reason = await get_user_from_event(bon)
if user:
pass
else:
return
# Eğer kullanıcı sudo ise
if user.id in BRAIN_CHECKER:
await bon.edit("`Ban Hatası! Hawli Yetkilisini yasaklayamam.`")
return
# Hedefi yasaklayacağınızı duyurun
await bon.edit("`Kullanıcı yollanıyor...`")
try:
await bon.client(EditBannedRequest(bon.chat_id, user.id,
BANNED_RIGHTS))
except:
await bon.edit(NO_PERM)
return
# Spamcılar için
try:
reply = await bon.get_reply_message()
if reply:
await reply.delete()
except:
await bon.edit(
"`Mesaj atma hakkım yok! Ama yine de kullanıcı yasaklandı!`")
return
# Mesajı silin ve ardından komutun
# incelikle yapıldığını söyleyin
BANLAYAN = await bot.get_me()
SONMESAJ = PLUGIN_MESAJLAR['ban'].replace(
"$username", f"@{user.username}" if user.username else
"[{}](tg://user?id={})".format(user.first_name, user.id)).replace(
"$id", "`" + str(user.id) + "`").replace(
"$date",
datetime.datetime.strftime(
datetime.datetime.now(), '%c')).replace(
"$from", f"@{BANLAYAN.username}" if BANLAYAN.username
else "[{}](tg://user?id={})".format(
BANLAYAN.first_name, BANLAYAN.id))
if reason:
await bon.edit(f"{SONMESAJ}\nNedeni: {reason}")
else:
await bon.edit(f"{SONMESAJ}")
# Yasaklama işlemini günlüğe belirtelim
if BOTLOG:
await bon.client.send_message(
BOTLOG_CHATID, "#BAN\n"
f"KULLANICI: [{user.first_name}](tg://user?id={user.id})\n"
f"GRUP: {bon.chat.title}(`{bon.chat_id}`)")
async def rm_deletedacc(show):
"""For .zombies command, list all the ghost/deleted/zombie accounts in a chat."""
con = show.pattern_match.group(1).lower()
del_u = 0
del_status = "`No deleted accounts found, Group is clean`"
if con != "clean":
await show.edit("`Searching for ghost/deleted/zombie accounts...`")
async for user in show.client.iter_participants(show.chat_id):
if user.deleted:
del_u += 1
await sleep(1)
if del_u > 0:
del_status = (
f"`Found` **{del_u}** `ghost/deleted/zombie account(s) in this group,"
"\nclean them by using .zombies clean`")
return await show.edit(del_status)
# Here laying the sanity check
chat = await show.get_chat()
admin = chat.admin_rights
creator = chat.creator
# Well
if not admin and not creator:
return await show.edit("`I am not an admin here!`")
await show.edit("`Deleting deleted accounts...\nOh I can do that?!?!`")
del_u = 0
del_a = 0
async for user in show.client.iter_participants(show.chat_id):
if user.deleted:
try:
await show.client(
EditBannedRequest(show.chat_id, user.id, BANNED_RIGHTS))
except ChatAdminRequiredError:
return await show.edit(
"`I don't have ban rights in this group`")
except UserAdminInvalidError:
del_u -= 1
del_a += 1
await show.client(
EditBannedRequest(show.chat_id, user.id, UNBAN_RIGHTS))
del_u += 1
if del_u > 0:
del_status = f"Cleaned **{del_u}** deleted account(s)"
if del_a > 0:
del_status = (f"Cleaned **{del_u}** deleted account(s) "
f"\n**{del_a}** deleted admin accounts are not removed")
await show.edit(del_status)
await sleep(2)
await show.delete()
if BOTLOG:
await show.client.send_message(
BOTLOG_CHATID,
"#CLEANUP\n"
f"Cleaned **{del_u}** deleted account(s) !!"
f"\nCHAT: {show.chat.title}(`{show.chat_id}`)",
)
async def handle_challenge_response(event):
global config, current_challenges
user_ans = event.data.decode()
chat = event.chat
user = await event.get_sender()
username = '******' + user.username if user.username else (
user.first_name + (' ' + user.last_name if user.last_name else ''))
bot_msg = event.message_id
async with config_lock:
group_config = config.get(str(chat.id), config['*'])
# handle manual approval/refusal by group admins
if user_ans in ['+', '-']:
try:
participant = await bot(
GetParticipantRequest(channel=chat, user_id=user))
participant = participant.participant
except errors.UserNotParticipantError:
logging.warning(
f'UserNotParticipantError on handle_challenge_response: user={user.id}, chat={chat.id}'
)
await event.answer(message=group_config['msg_permission_denied'])
return None
can_ban = False
try:
if participant.admin_rights.ban_users or type(
participant) is ChannelParticipantCreator:
can_ban = True
except AttributeError:
pass
if not can_ban:
await event.answer(message=group_config['msg_permission_denied'])
return None
ch_id = '{chat}|{msg}'.format(chat=chat.id, msg=bot_msg)
async with cch_lock:
challenge, target, timeout_event = current_challenges.get(
ch_id, (None, None, None))
try:
del current_challenges[ch_id]
except KeyError:
return None
timeout_event.cancel()
if user_ans == '+':
try:
await lift_restriction(chat, target)
except errors.ChatAdminRequiredError:
await event.answer(
message=group_config['msg_bot_no_permission'])
try:
await event.edit(
text=group_config['msg_approved'].format(user=username),
buttons=None)
except errors.BadRequestError: # message to edit not found
pass
else: # user_ans == '-'
try:
await bot(
EditBannedRequest(
chat, target,
ChatBannedRights(until_date=None, view_messages=True)))
except errors.ChatAdminRequiredError:
await event.answer(
message=group_config['msg_bot_no_permission'])
return None
try:
await event.edit(
text=group_config['msg_refused'].format(user=username),
buttons=None)
except errors.BadRequestError: # message to edit not found
pass
async with upr_lock:
member = user_previous_restrictions.get('{chat}|{user}'.format(
chat=chat.id, user=target))
if member:
del user_previous_restrictions['{chat}|{user}'.format(
chat=chat.id, user=target)]
await event.answer()
return None
ch_id = '{chat}|{msg}'.format(chat=chat.id, msg=bot_msg)
async with cch_lock:
challenge, target, timeout_event = current_challenges.get(
ch_id, (None, None, None))
if user.id != target:
await event.answer(message=group_config['msg_challenge_not_for_you'])
return None
timeout_event.cancel()
async with cch_lock:
del current_challenges[ch_id]
await event.answer()
# verify the ans
correct = (str(challenge.ans()) == user_ans)
delete = None
if correct or not group_config.get('challenge_strict_mode'):
try:
await lift_restriction(chat, target)
except errors.ChatAdminRequiredError:
# This my happen when the bot is deop-ed after the user join
# and before the user click the button
# TODO: design messages for this occation
pass
msg = 'msg_challenge_passed' if correct else 'msg_challenge_mercy_passed'
if correct:
if group_config['delete_passed_challenge']:
delete = asyncio.create_task(
safe_delete_message(
group_config['delete_passed_challenge_interval'],
channel=chat,
id=[bot_msg]))
else:
msg = 'msg_challenge_failed'
await event.edit(text=group_config[msg], buttons=None)
if delete: await delete
async def challenge_user(event):
global config, current_challenges
chat = event.chat
target = event.user
if event.user_added:
me = await bot.get_me()
if me.id in event.user_ids:
async with config_lock:
group_config = config.get(str(event.chat.id), config['*'])
await event.respond(
message=group_config['msg_self_introduction'])
return None
elif not event.user_joined:
return None
# get previous restriction data
async with upr_lock:
key = '{chat}|{user}'.format(chat=chat.id, user=target.id)
# a record probably means the user didn't pass the challenge previously
# (and is fully restricted)
# this time they leave & rejoin the group in order to pass the test
# so we won't update the record which is likely fully restricted
if not user_previous_restrictions.get(key):
try:
member = await bot(GetParticipantRequest(chat, target))
member = member.participant
user_previous_restrictions[key] = member
except errors.UserNotParticipantError:
logging.warning(
f'UserNotParticipantError on challenge_user: user={target.id}, chat={chat.id}'
)
# Attempt to restrict the user
try:
await bot(
EditBannedRequest(
chat, target,
ChatBannedRights(until_date=None,
view_messages=None,
send_messages=True,
send_media=True,
send_stickers=True,
send_gifs=True,
send_games=True,
send_inline=True,
send_polls=True,
embed_links=True,
invite_users=True)))
except errors.ChatAdminRequiredError:
return None
async with config_lock:
group_config = config.get(str(chat.id), config['*'])
challenge = Challenge()
def challenge_to_buttons(ch):
# There can be 8 buttons per row at most (more are ignored).
buttons = [
KeyboardButtonCallback(text=str(c), data=str(c))
for c in ch.choices()
]
choices = [
buttons[i * 8:i * 8 + 8] for i in range((len(buttons) + 7) // 8)
]
# manual approval/refusal by group admins
choices.extend([[
KeyboardButtonCallback(text=group_config['msg_approve_manually'],
data='+'),
KeyboardButtonCallback(text=group_config['msg_refuse_manually'],
data='-')
]])
return choices
timeout = group_config['challenge_timeout']
try:
bot_msg_id = await event.reply(
message=group_config['msg_challenge'].format(
timeout=timeout, challenge=challenge.qus()),
buttons=challenge_to_buttons(challenge))
bot_msg_id = bot_msg_id.id
except errors.BadRequestError: # msg to reply not found
bot_msg_id = await event.respond(
message=group_config['msg_challenge'].format(
timeout=timeout, challenge=challenge.qus()),
buttons=challenge_to_buttons(challenge))
bot_msg_id = bot_msg_id.id
timeout_event = asyncio.create_task(
handle_challenge_timeout(group_config['challenge_timeout'], chat,
target, bot_msg_id))
async with cch_lock:
current_challenges['{chat}|{msg}'.format(
chat=chat.id,
msg=bot_msg_id)] = (challenge, target.id, timeout_event)
try:
await timeout_event
except asyncio.CancelledError:
pass
async def endmute(event):
if event.fwd_from:
return
if event.is_private:
await event.edit("** جاري كتم المـستخدم**")
await sleep(1)
userid = event.chat_id
replied_user = await event.client(GetFullUserRequest(userid))
chat_id = event.chat_id
if not is_muted(userid, chat_id):
return await event.edit(
"** لـم يتـم كتـم هذا المسـتخدم في المجـموعـة**"
)
try:
unmute(userid, chat_id)
except Exception as e:
await event.edit(f"**Error **\n`{str(e)}`")
else:
await event.edit(
"** لقـد تم مسـح الكتـم من المسـتخدم**"
)
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"#PM_UNMUTE\n"
f"**المعرف :** [{replied_user.user.first_name}](tg://user?id={userid})\n",
)
else:
user = await get_user_from_event(event)
user = user[0]
if not user:
return
try:
if is_muted(user.id, event.chat_id):
unmute(user.id, event.chat_id)
else:
result = await event.client(
functions.channels.GetParticipantRequest(
channel=event.chat_id, user_id=user.id
)
)
try:
if result.participant.banned_rights.send_messages:
await event.client(
EditBannedRequest(event.chat_id, user.id, UNBAN_RIGHTS)
)
except Exception:
return await edit_or_reply(
event,
" عـذرا ليـست لدي صـلاحيات كـافية",
)
except Exception as e:
return await edit_or_reply(event, f"**Error : **`{str(e)}`")
await edit_or_reply(
event,
f"{_format.mentionuser(user.first_name ,user.id)} `لقـد تم مسـح الكـتم {event.chat.title}`",
)
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"#UNMUTE\n"
f"**المعرف :** [{user.first_name}](tg://user?id={user.id})\n"
f"**المحادثة :** {event.chat.title}(`{event.chat_id}`)",
)
async def startmute(event):
if event.fwd_from:
return
if event.is_private:
await event.edit("** جاري كتم المـستخدم**")
await sleep(2)
await event.get_reply_message()
userid = event.chat_id
replied_user = await event.client(GetFullUserRequest(userid))
chat_id = event.chat_id
if is_muted(userid, chat_id):
return await event.edit(
"** هذا المستخدم مكتوم بالفعل في هذه الدردشة**"
)
try:
mute(userid, chat_id)
except Exception as e:
await event.edit(f"**هنـاك خطـأ **\n`{str(e)}`")
else:
await event.edit("** تـم كتـم المسـتخدم بنجـاح**")
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"#PM_MUTE\n"
f"**المعرف :** [{replied_user.user.first_name}](tg://user?id={userid})\n",
)
else:
chat = await event.get_chat()
user, reason = await get_user_from_event(event)
if not user:
return
if user.id == bot.uid:
return await edit_or_reply(event, "** اعتـذر لايمكنني كتـم نفـسي**")
if is_muted(user.id, event.chat_id):
return await edit_or_reply(
event, ""
)
try:
admin = chat.admin_rights
creator = chat.creator
if not admin and not creator:
await edit_or_reply(
event, "** عـذرا ليـست لدي صـلاحيات كـافية**"
)
return
result = await event.client(
functions.channels.GetParticipantRequest(
channel=event.chat_id, user_id=user.id
)
)
try:
if result.participant.banned_rights.send_messages:
return await edit_or_reply(
event,
"** هذا المستخدم مكتوم بالفعل في هذه الدردشة**",
)
except Exception as e:
LOGS.info(str(e))
await event.client(EditBannedRequest(event.chat_id, user.id, MUTE_RIGHTS))
except UserAdminInvalidError:
if "admin_rights" in vars(chat) and vars(chat)["admin_rights"] is not None:
if chat.admin_rights.delete_messages is not True:
return await edit_or_reply(
event,
" عـذرا ليـست لدي صـلاحيات كـافية",
)
elif "creator" not in vars(chat):
return await edit_or_reply(
event, " عـذرا ليـست لدي صـلاحيات كـافية"
)
try:
mute(user.id, event.chat_id)
except Exception as e:
return await edit_or_reply(event, f"**هنـاك خطـأ**\n`{str(e)}`")
except Exception as e:
return await edit_or_reply(event, f"**هنـاك خطأ : **`{str(e)}`")
if reason:
await edit_or_reply(
event,
f"{_format.mentionuser(user.first_name ,user.id)} `الان مكـتوم فـي : {event.chat.title}`\n"
f"`السـبب:`{reason}",
)
else:
await edit_or_reply(
event,
f"{_format.mentionuser(user.first_name ,user.id)} `الان مكـتوم فـي {event.chat.title}`\n",
)
if BOTLOG:
await event.client.send_message(
BOTLOG_CHATID,
"#MUTE\n"
f"**المعرف :** [{user.first_name}](tg://user?id={user.id})\n"
f"**المحـادثة :** {event.chat.title}(`{event.chat_id}`)",
)
async def rm_deletedacc(eventDeletedAccs):
if eventDeletedAccs.text[0].isalpha() or eventDeletedAccs.text[0] in (
"/",
"#",
"@",
"!",
):
return
con = eventDeletedAccs.pattern_match.group(1)
del_u = 0
del_status = "`No deleted accounts found, Group is cleaned as Hell`"
if not eventDeletedAccs.is_group:
await eventDeletedAccs.edit("`This command is only for groups!`")
return
if con != "clean":
await eventDeletedAccs.edit("`Searching for ded af accounts...`")
async for user in eventDeletedAccs.client.iter_participants(
eventDeletedAccs.chat_id):
if user.deleted:
del_u += 1
if del_u > 0:
del_status = f"found **{del_u}** deleted account(s) in this group \
\nClean them by using `.delusers clean`"
await eventDeletedAccs.edit(del_status)
return
chat = await eventDeletedAccs.get_chat()
admin = chat.admin_rights
creator = chat.creator
if not admin and not creator:
await eventDeletedAccs.edit("`I am not an admin here!`")
return
await eventDeletedAccs.edit(
"`Deleting deleted accounts...\nOh I can do that?!?!`")
del_u = 0
del_a = 0
async for user in eventDeletedAccs.client.iter_participants(
eventDeletedAccs.chat_id):
if user.deleted:
try:
await eventDeletedAccs.client(
EditBannedRequest(eventDeletedAccs.chat_id, user.id,
BANNED_RIGHTS))
except ChatAdminRequiredError:
await eventDeletedAccs.edit(
"`I don't have ban rights in this group`")
return
except UserAdminInvalidError:
del_u -= 1
del_a += 1
await eventDeletedAccs.client(
EditBannedRequest(eventDeletedAccs.chat_id, user.id,
UNBAN_RIGHTS))
del_u += 1
if del_u > 0:
del_status = f"Cleaned **{del_u}** deleted account(s)"
if del_a > 0:
del_status = f"Cleaned **{del_u}** deleted account(s) \
\n**{del_a}** deleted admin accounts are not removed."
await eventDeletedAccs.edit(del_status)
async def spider(spdr):
if spdr.fwd_from:
return
"""
This function is basically muting peeps
"""
# Check if the function running under SQL mode
try:
from userbot.plugins.sql_helper.spam_mute_sql import mute
except AttributeError:
await spdr.edit(NO_SQL)
return
# Admin or creator check
chat = await spdr.get_chat()
admin = chat.admin_rights
creator = chat.creator
# If not admin and not creator, return
if not admin and not creator:
await spdr.edit(NO_ADMIN)
return
user, reason = await get_user_from_event(spdr)
if user:
pass
else:
return
self_user = await spdr.client.get_me()
if user.id == self_user.id:
await spdr.edit(
"`Hands too short, can't duct tape myself...\n(ヘ･_･)ヘ┳━┳`")
return
# If everything goes well, do announcing and mute
await spdr.edit("`Gets a tape!`")
if mute(spdr.chat_id, user.id) is False:
return await spdr.edit("`Error! User probably already muted.`")
else:
try:
await spdr.client(
EditBannedRequest(spdr.chat_id, user.id, MUTE_RIGHTS))
# Announce that the function is done
if reason:
await spdr.edit(f"`Safely taped !!`\nReason: {reason}")
else:
await spdr.edit("`Safely taped !!`")
# Announce to logging group
if BOTLOG:
await spdr.client.send_message(
BOTLOG_CHATID,
"#MUTE\n"
f"USER: [{user.first_name}](tg://user?id={user.id})\n"
f"CHAT: {spdr.chat.title}(`{spdr.chat_id}`)",
)
except UserIdInvalidError:
return await spdr.edit("`Uh oh my mute logic broke!`")
async def rm_deletedacc(show):
""" .zombies komutu bir sohbette tüm hayalet / silinmiş / zombi hesaplarını listeler. """
con = show.pattern_match.group(1).lower()
del_u = 0
del_status = "`Silinmiş hesap bulunamadı, grup temiz`"
if con != "clean":
await show.edit("`hayalet / silinmiş / zombi hesaplar aranıyor...`")
async for user in show.client.iter_participants(show.chat_id):
if user.deleted:
del_u += 1
await sleep(1)
if del_u > 0:
del_status = f"**`Bu grupta` **{del_u}** `tane hayalet / silinmiş / zombi hesap bulundu,\
\ntemizlemek için --.zombies clean-- komutunu kullanın`"
await show.edit(del_status)
return
# Yetki kontrolü
chat = await show.get_chat()
admin = chat.admin_rights
creator = chat.creator
if not admin and not creator:
await show.edit("`Yönetici değilim!`")
return
await show.edit("`Silinmiş hesaplar çıkarılıyor...`")
del_u = 0
del_a = 0
async for user in show.client.iter_participants(show.chat_id):
if user.deleted:
try:
await show.client(
EditBannedRequest(show.chat_id, user.id, BANNED_RIGHTS))
except UserAdminInvalidError:
del_u -= 1
del_a += 1
except:
await show.edit("`Bu grupta ban yetkim bulunmamakta`")
return
await show.client(
EditBannedRequest(show.chat_id, user.id, UNBAN_RIGHTS))
del_u += 1
if del_u > 0:
del_status = f"**{del_u}** tane silinmiş hesap gruptan çıkarıldı"
if del_a > 0:
del_status = f"**{del_u}** tane silinmiş hesap gruptan çıkarıldı \
\n**{del_a}** tane silinmiş olan yönetici hesapları çıkartılamadı"
await show.edit(del_status)
await sleep(2)
await show.delete()
if BOTLOG:
await show.client.send_message(
BOTLOG_CHATID, "#TEMIZLIK\n"
f"**{del_u}** tane silinmiş hesap çıkartıldı !!\
\nGRUP: {show.chat.title}(`{show.chat_id}`)")
async def zombies(event):
""" For .zombies command, list all the zombies in a chat. """
con = event.pattern_match.group(1).lower()
del_u = 0
del_status = "No Deleted Accounts Found, Group Is Clean."
if con != "clean":
find_zombies = await event.respond("Searching For Zombies...")
async for user in event.client.iter_participants(event.chat_id):
if user.deleted:
del_u += 1
await sleep(1)
if del_u > 0:
del_status = f"Found **{del_u}** Zombies In This Group.\
\nClean Them By Using - `/zombies clean`"
await find_zombies.edit(del_status)
return
# Here laying the sanity check
chat = await event.get_chat()
admin = chat.admin_rights
creator = chat.creator
# Well
if not await is_administrator(user_id=event.from_id, message=event):
await event.respond("You're Not An Admin!")
return
if not admin and not creator:
await event.respond("I Am Not An Admin Here!")
return
cleaning_zombies = await event.respond("Cleaning Zombies...")
del_u = 0
del_a = 0
async for user in event.client.iter_participants(event.chat_id):
if user.deleted:
try:
await event.client(
EditBannedRequest(event.chat_id, user.id, BANNED_RIGHTS))
except ChatAdminRequiredError:
await cleaning_zombies.edit(
"I Don't Have Ban Rights In This Group.")
return
except UserAdminInvalidError:
del_u -= 1
del_a += 1
await event.client(
EditBannedRequest(event.chat_id, user.id, UNBAN_RIGHTS))
del_u += 1
if del_u > 0:
del_status = f"Cleaned `{del_u}` Zombies"
if del_a > 0:
del_status = f"Cleaned `{del_u}` Zombies \
\n`{del_a}` Zombie Admin Accounts Are Not Removed!"
await cleaning_zombies.edit(del_status)
async def rm_deletedacc(show):
""" For .delusers command, list all the ghost/deleted accounts in a chat. """
if not show.text[0].isalpha() and show.text[0] not in ("/", "#", "@", "!"):
con = show.pattern_match.group(1)
del_u = 0
del_status = "`No deleted accounts found, Group is cleaned as Hell`"
if not show.is_group:
await show.edit("`This command is only for groups!`")
return
if con != "clean":
await show.edit("`Searching for zombie accounts...`")
async for user in show.client.iter_participants(show.chat_id):
if user.deleted:
del_u += 1
if del_u > 0:
del_status = f"found **{del_u}** deleted account(s) in this group \
\nclean them by using .delusers clean"
await show.edit(del_status)
return
# Here laying the sanity check
chat = await show.get_chat()
admin = chat.admin_rights
creator = chat.creator
# Well
if not admin and not creator:
await show.edit("`I am not an admin here!`")
return
await show.edit("`Deleting deleted accounts...\nOh I can do that?!?!`")
del_u = 0
del_a = 0
async for user in show.client.iter_participants(show.chat_id):
if user.deleted:
try:
await show.client(
EditBannedRequest(show.chat_id, user.id,
BANNED_RIGHTS))
except ChatAdminRequiredError:
await show.edit("`I don't have ban rights in this group`")
return
except UserAdminInvalidError:
del_u -= 1
del_a += 1
await show.client(
EditBannedRequest(show.chat_id, user.id, UNBAN_RIGHTS))
del_u += 1
if del_u > 0:
del_status = f"cleaned **{del_u}** deleted account(s)"
if del_a > 0:
del_status = f"cleaned **{del_u}** deleted account(s) \
\n**{del_a}** deleted admin accounts are not removed"
await show.edit(del_status)
async def _cleanup_chat(
event,
count: bool = False,
progress_message: Optional[Message] = None) -> MDTeXDocument:
chat: Channel = await event.get_chat()
client: KantekClient = event.client
user: User
deleted_users = 0
deleted_admins = 0
user_counter = 0
participant_count = (await client.get_participants(chat, limit=0)).total
# the number will be 0 if the group has less than 25 participants
modulus = (participant_count // 25) or 1
async for user in client.iter_participants(chat):
if progress_message is not None and user_counter % modulus == 0:
progress = Section(
Bold('Cleanup'),
KeyValueItem(Bold('Progress'),
f'{user_counter}/{participant_count}'),
KeyValueItem(Bold('Deleted Accounts'), deleted_users))
await progress_message.edit(str(progress))
user_counter += 1
if user.deleted:
deleted_users += 1
if not count:
try:
await client(
EditBannedRequest(
chat, user,
ChatBannedRights(until_date=datetime.datetime(
2038, 1, 1),
view_messages=True)))
except UserAdminInvalidError:
deleted_admins += 1
except FloodWaitError as error:
if progress_message is not None:
progress = Section(
Bold('Cleanup | FloodWait'),
Bold(
f'Got FloodWait for {error.seconds}s. Sleeping.'
),
KeyValueItem(
Bold('Progress'),
f'{user_counter}/{participant_count}'),
KeyValueItem(Bold('Deleted Accounts'),
deleted_users))
await progress_message.edit(str(progress))
tlog.error(error)
logger.error(error)
await asyncio.sleep(error.seconds)
await client(
EditBannedRequest(
chat, user,
ChatBannedRights(until_date=datetime.datetime(
2038, 1, 1),
view_messages=True)))
return MDTeXDocument(
Section(
Bold('Cleanup'),
KeyValueItem(Bold('Deleted Accounts'), deleted_users),
KeyValueItem(Bold('Deleted Admins'), deleted_admins)
if deleted_admins else None))
async def rm_deletedacc(show):
con = show.pattern_match.group(1).lower()
del_u = 0
del_status = "`Tidak Menemukan Akun Terhapus, Grup Bersih`"
if con != "clean":
await show.edit("`Mencari Akun Hantu/Terhapus/Zombie...`")
async for user in show.client.iter_participants(show.chat_id):
if user.deleted:
del_u += 1
await sleep(1)
if del_u > 0:
del_status = (
f"`Menemukan` **{del_u}** `Akun Hantu/Terhapus/Zombie Dalam Grup Ini,"
"\nBersihkan Itu Menggunakan Perintah .zombies clean`")
return await show.edit(del_status)
# Here laying the sanity check
chat = await show.get_chat()
admin = chat.admin_rights
creator = chat.creator
# Well
if not admin and not creator:
return await show.edit("`Lord Bukan Admin Disini!`")
await show.edit(
"`Menghapus Akun Terhapus...\nMohon Menunggu Lord Sedang Dalam Proses`"
)
del_u = 0
del_a = 0
async for user in show.client.iter_participants(show.chat_id):
if user.deleted:
try:
await show.client(
EditBannedRequest(show.chat_id, user.id, BANNED_RIGHTS))
except ChatAdminRequiredError:
return await show.edit(
"`Lord Tidak Memiliki Izin Banned Dalam Grup Ini`")
except UserAdminInvalidError:
del_u -= 1
del_a += 1
await show.client(
EditBannedRequest(show.chat_id, user.id, UNBAN_RIGHTS))
del_u += 1
if del_u > 0:
del_status = f"`Membersihkan` **{del_u}** `Akun Terhapus`"
if del_a > 0:
del_status = (
f"Membersihkan **{del_u}** Akun Terhapus "
f"\n**{del_a}** `Admin Akun Terhapus Tidak Bisa Dihapus.`")
await show.edit(del_status)
await sleep(2)
await show.delete()
if BOTLOG:
await show.client.send_message(
BOTLOG_CHATID,
"#MEMBERSIHKAN\n"
f"Membersihkan **{del_u}** Akun Terhapus!"
f"\nGRUP: {show.chat.title}(`{show.chat_id}`)",
)
