async def mute(event):
user, chat = await fetch_user(event, get_chat=True)
if not user:
return
if not chat:
await event.edit(msgRep.FAIL_CHAT)
return
if type(chat) is User:
await event.edit(msgRep.NO_GROUP_ARGS)
return
if hasattr(chat, "broadcast") and chat.broadcast:
await event.edit(msgRep.NOT_MUTE_SUB_CHAN)
return
if user.is_self:
await event.edit(msgRep.CANNOT_MUTE_SELF)
return
remote = isRemoteCMD(event, chat.id)
admin_perms = chat.admin_rights if hasattr(chat, "admin_rights") else None
if admin_perms and not admin_perms.ban_users:
await event.edit(msgRep.NO_BAN_PRIV)
return
try:
mute_perms = ChatBannedRights(until_date=None,
send_messages=True,
change_info=True,
invite_users=True,
pin_messages=True)
await event.client(EditBannedRequest(chat.id, user.id, mute_perms))
name = (f"[{user.first_name}](tg://user?id={user.id})"
if user.first_name else msgRep.DELETED_ACCOUNT)
if remote:
await event.edit(
msgRep.MUTE_SUCCESS_REMOTE.format(name, chat.title))
else:
await event.edit(msgRep.MUTE_SUCCESS.format(name))
if LOGGING:
await event_log(
event,
"MUTE",
user_name=user.first_name,
username=user.username,
user_id=user.id,
chat_title=chat.title,
chat_link=chat.username if hasattr(chat, "username") else None,
chat_id=format_chat_id(chat) if remote else event.chat_id)
except ChatAdminRequiredError:
await event.edit(msgRep.NO_ADMIN)
except Exception as e:
log.warning(e)
await event.edit(msgRep.MUTE_FAILED)
return
async def ban(event):
user, chat = await fetch_user(event, get_chat=True)
if not user:
return
if not chat:
await event.edit(msgRep.FAIL_CHAT)
return
if type(chat) is User:
await event.edit(msgRep.NO_GROUP_CHAN_ARGS)
return
if user.is_self:
await event.edit(msgRep.CANNOT_BAN_SELF)
return
remote = isRemoteCMD(event, chat.id)
admin_perms = chat.admin_rights if hasattr(chat, "admin_rights") else None
if admin_perms and not admin_perms.ban_users:
await event.edit(msgRep.NO_BAN_PRIV)
return
try:
# if view_messages is True then all ban permissions will
# be set to True too
ban_perms = ChatBannedRights(until_date=None, view_messages=True)
await event.client(EditBannedRequest(chat.id, user.id, ban_perms))
name = (f"[{user.first_name}](tg://user?id={user.id})"
if user.first_name else msgRep.DELETED_ACCOUNT)
if remote:
await event.edit(msgRep.BAN_SUCCESS_REMOTE.format(
name, chat.title))
else:
await event.edit(msgRep.BAN_SUCCESS.format(name))
if LOGGING:
await event_log(
event,
"BAN",
user_name=user.first_name,
username=user.username,
user_id=user.id,
chat_title=chat.title,
chat_link=chat.username if hasattr(chat, "username") else None,
chat_id=format_chat_id(chat) if remote else event.chat_id)
except ChatAdminRequiredError:
await event.edit(msgRep.NO_ADMIN)
except UserAdminInvalidError:
await event.edit(msgRep.CANNOT_BAN_ADMIN)
except Exception as e:
log.warning(e)
await event.edit(msgRep.BAN_FAILED)
return
async def kick(event):
user, chat = await fetch_entity(event, get_chat=True)
if not user:
return
if not chat:
await event.edit(msgRep.FAIL_CHAT)
return
if isinstance(chat, User):
await event.edit(msgRep.NO_GROUP_CHAN_ARGS)
return
remote = isRemoteCMD(event, chat.id)
admin_perms = chat.admin_rights if hasattr(chat, "admin_rights") else None
if admin_perms and not admin_perms.ban_users:
await event.edit(msgRep.NO_BAN_PRIV)
return
if not isinstance(user, User):
await event.edit(msgRep.KICK_PERSONS_ONLY)
return
if user.is_self:
await event.edit(msgRep.CANNOT_KICK_SELF)
return
try:
await event.client.kick_participant(chat.id, user.id)
name = (f"[{user.first_name}](tg://user?id={user.id})"
if user.first_name else msgRep.DELETED_ACCOUNT)
if remote:
await event.edit(
msgRep.KICK_SUCCESS_REMOTE.format(name, chat.title))
else:
await event.edit(msgRep.KICK_SUCCESS.format(name))
if LOGGING:
await event_log(
event,
"KICK",
user_name=user.first_name,
username=user.username,
user_id=user.id,
chat_title=chat.title,
chat_link=chat.username if hasattr(chat, "username") else None,
chat_id=format_chat_id(chat) if remote else event.chat_id)
except ChatAdminRequiredError:
await event.edit(msgRep.NO_ADMIN)
except Exception as e:
log.warning(e)
await event.edit(msgRep.KICK_FAILED)
return
async def fetch_info(chat, event):
chat_obj_info = await event.client.get_entity(chat.full_chat.id)
broadcast = (chat_obj_info.broadcast
if hasattr(chat_obj_info, "broadcast") else False)
chat_type = msgRep.CHANNEL if broadcast else msgRep.GROUP
chat_title = chat_obj_info.title
warn_emoji = u"\u26A0"
try:
msg_info = await event.client(
GetHistoryRequest(peer=chat_obj_info.id,
offset_id=0,
offset_date=datetime(2010, 1, 1),
add_offset=-1,
limit=1,
max_id=0,
min_id=0,
hash=0))
except:
msg_info = None
first_msg_valid = (True if msg_info and msg_info.messages
and msg_info.messages[0].id == 1 else False)
owner_id, owner_firstname, owner_username = (None, ) * 3
admins = 0
created = msg_info.messages[0].date if first_msg_valid else None
former_title = (
msg_info.messages[0].action.title if first_msg_valid and
type(msg_info.messages[0].action) is MessageActionChannelMigrateFrom
and msg_info.messages[0].action.title != chat_title else None)
dc_id = (chat.full_chat.chat_photo.dc_id if hasattr(
chat.full_chat.chat_photo, "dc_id") else msgRep.UNKNOWN)
# Prototype's spaghetti, although already salted by me
description = chat.full_chat.about
members = (chat.full_chat.participants_count if hasattr(
chat.full_chat, "participants_count") else
chat_obj_info.participants_count)
banned_users = (chat.full_chat.kicked_count if hasattr(
chat.full_chat, "kicked_count") else None)
restricted_users = (chat.full_chat.banned_count if hasattr(
chat.full_chat, "banned_count") else None)
members_online = (chat.full_chat.online_count if hasattr(
chat.full_chat, "online_count") else 0)
group_stickers = (chat.full_chat.stickerset.title
if hasattr(chat.full_chat, "stickerset")
and chat.full_chat.stickerset else None)
messages_viewable = (msg_info.count
if msg_info and hasattr(msg_info, "count") else None)
messages_sent = (chat.full_chat.read_inbox_max_id if hasattr(
chat.full_chat, "read_inbox_max_id") else None)
messages_sent_alt = (chat.full_chat.read_outbox_max_id if hasattr(
chat.full_chat, "read_outbox_max_id") else None)
if messages_sent and messages_viewable:
deleted_messages = ((messages_sent - messages_viewable)
if messages_sent >= messages_viewable else 0)
elif messages_sent_alt and messages_viewable:
deleted_messages = ((messages_sent_alt - messages_viewable)
if messages_sent_alt >= messages_viewable else 0)
else:
deleted_messages = 0
username = ("@" +
chat_obj_info.username if hasattr(chat_obj_info, "username")
and chat_obj_info.username else None)
chat_type_priv_or_public = (msgRep.CHAT_PUBLIC
if username else msgRep.CHAT_PRIVATE)
bots_list = chat.full_chat.bot_info # this is a list
bots = len(bots_list) if bots_list else 0
supergroup = (True if hasattr(chat_obj_info, "megagroup")
and chat_obj_info.megagroup else False)
gigagroup = (True if hasattr(chat_obj_info, "gigagroup")
and chat_obj_info.gigagroup else False)
slowmode = (msgRep.YES_BOLD if hasattr(chat_obj_info, "slowmode_enabled")
and chat_obj_info.slowmode_enabled else msgRep.NO)
slowmode_time = (chat.full_chat.slowmode_seconds
if hasattr(chat_obj_info, "slowmode_enabled")
and chat_obj_info.slowmode_enabled else None)
restricted = (msgRep.YES_BOLD if hasattr(chat_obj_info, "restricted")
and chat_obj_info.restricted else msgRep.NO)
verified = (msgRep.YES_BOLD if hasattr(chat_obj_info, "verified")
and chat_obj_info.verified else msgRep.NO)
linked_chat_id = (chat.full_chat.linked_chat_id if hasattr(
chat.full_chat, "linked_chat_id") else None)
linked_chat = msgRep.YES_BOLD if linked_chat_id is not None else msgRep.NO
linked_chat_title = None
linked_chat_username = None
if linked_chat_id is not None and chat.chats:
for c in chat.chats:
if c.id == linked_chat_id:
linked_chat_title = c.title
if c.username is not None:
linked_chat_username = "******" + c.username
break
# End of spaghetti block
try:
is_channel_obj = True if isinstance(chat_obj_info, Channel) else False
async for admin in (event.client.iter_participants(
entity=chat.full_chat.id,
filter=(ChannelParticipantsAdmins()
if is_channel_obj else None))):
if isinstance(admin.participant,
(ChannelParticipantCreator, ChatParticipantCreator)):
owner_id = admin.id
owner_username = ("@" +
admin.username if admin.username else None)
if not is_channel_obj:
break
if is_channel_obj:
admins += 1
except:
pass
caption = msgRep.CHATINFO
caption += msgRep.CHAT_ID.format(format_chat_id(chat_obj_info))
caption += msgRep.CHAT_TYPE.format(chat_type, chat_type_priv_or_public)
if not broadcast:
if gigagroup:
group_type = msgRep.GROUP_TYPE_GIGAGROUP
elif supergroup:
group_type = msgRep.GROUP_TYPE_SUPERGROUP
else:
group_type = msgRep.GROUP_TYPE_NORMAL
caption += f"{msgRep.GROUP_TYPE}: {group_type}\n"
if chat_title:
caption += msgRep.CHAT_NAME.format(chat_title)
if former_title: # Meant is the very first title
caption += msgRep.FORMER_NAME.format(former_title)
if username:
caption += f"Link: {username}\n"
if owner_username:
caption += msgRep.OWNER.format(owner_username)
elif owner_id and owner_firstname:
caption += msgRep.OWNER_WITH_URL.format(owner_id, owner_firstname)
if created:
caption += msgRep.CREATED_NOT_NULL.format(
created.date().strftime('%b %d, %Y'), created.time(),
created.tzinfo)
else:
caption += msgRep.CREATED_NULL.format(
chat_obj_info.date.date().strftime('%b %d, %Y'),
chat_obj_info.date.time(), chat_obj_info.date.tzinfo, warn_emoji)
caption += msgRep.DCID.format(dc_id)
if messages_viewable is not None:
caption += msgRep.VIEWABLE_MSG.format(messages_viewable)
if deleted_messages:
caption += msgRep.DELETED_MSG.format(deleted_messages)
if messages_sent:
caption += msgRep.SENT_MSG.format(messages_sent)
elif messages_sent_alt:
caption += msgRep.SENT_MSG_PRED.format(messages_sent_alt, warn_emoji)
if members:
caption += msgRep.MEMBERS.format(members)
if admins:
caption += msgRep.ADMINS.format(admins)
if bots_list:
caption += msgRep.BOT_COUNT.format(bots)
if members_online:
caption += msgRep.ONLINE_MEM.format(members_online)
if restricted_users:
caption += msgRep.RESTRICTED_COUNT.format(restricted_users)
if banned_users:
caption += msgRep.BANNEDCOUNT.format(banned_users)
if group_stickers:
caption += msgRep.GRUP_STICKERS.format(
chat.full_chat.stickerset.short_name, group_stickers)
caption += "\n"
if broadcast or supergroup:
caption += msgRep.LINKED_CHAT.format(linked_chat)
if linked_chat_title:
caption += msgRep.LINKED_CHAT_TITLE.format(linked_chat_title)
if linked_chat_username:
caption += f"> Link: {linked_chat_username}\n"
caption += "\n"
if not broadcast:
caption += msgRep.SLW_MODE.format(slowmode)
if hasattr(chat_obj_info, "slowmode_enabled") and \
chat_obj_info.slowmode_enabled:
caption += msgRep.SLW_MODE_TIME.format(slowmode_time)
else:
caption += "\n\n"
if hasattr(chat_obj_info, "restricted"):
caption += msgRep.RESTR.format(restricted)
if chat_obj_info.restricted:
caption += msgRep.PFORM.format(
chat_obj_info.restriction_reason[0].platform)
caption += msgRep.REASON.format(
chat_obj_info.restriction_reason[0].reason)
caption += msgRep.TEXT.format(
chat_obj_info.restriction_reason[0].text)
else:
caption += "\n"
if hasattr(chat_obj_info, "scam") and chat_obj_info.scam:
caption += msgRep.SCAM
if hasattr(chat_obj_info, "verified"):
caption += msgRep.VERFIED.format(verified)
if description:
caption += msgRep.DESCRIPTION.format(description)
return caption
async def delaccs(event):
arg_from_event = event.pattern_match.group(1)
if arg_from_event:
is_id = False
try:
arg_from_event = int(arg_from_event)
is_id = True
except:
pass
try:
chat = await event.client.get_entity(arg_from_event)
except:
if is_id:
await event.edit(msgRep.INVALID_ID)
else:
await event.edit(msgRep.INVALID_USERNAME)
return
else:
chat = await event.get_chat()
if type(chat) is User:
await event.edit(msgRep.NO_GROUP_CHAN)
return
deleted_accounts, rem_del_accounts = (0, ) * 2
await event.edit(msgRep.TRY_DEL_ACCOUNTS)
async for member in event.client.iter_participants(chat.id):
if member.deleted:
deleted_accounts += 1
if chat.creator or (chat.admin_rights
and chat.admin_rights.ban_users):
try:
await event.client.kick_participant(chat.id, member.id)
await sleep(0.2)
rem_del_accounts += 1
except:
pass
remote = isRemoteCMD(event, chat.id)
if deleted_accounts > 0 and not rem_del_accounts:
if remote:
await event.edit(
msgRep.DEL_ACCS_COUNT_REMOTE.format(deleted_accounts,
chat.title))
else:
await event.edit(msgRep.DEL_ACCS_COUNT.format(deleted_accounts))
elif rem_del_accounts > 0 and rem_del_accounts <= deleted_accounts:
if not (deleted_accounts - rem_del_accounts) == 0:
if remote:
rem_accs_text = msgRep.REM_DEL_ACCS_COUNT_REMOTE.format(
rem_del_accounts, chat.title)
else:
rem_accs_text = msgRep.REM_DEL_ACCS_COUNT.format(
rem_del_accounts)
rem_accs_excp_text = msgRep.REM_DEL_ACCS_COUNT_EXCP.format(
deleted_accounts - rem_del_accounts)
await event.edit(f"{rem_accs_text}`. `{rem_accs_excp_text}")
else:
if remote:
await event.edit(
msgRep.REM_DEL_ACCS_COUNT_REMOTE.format(
rem_del_accounts, chat.title))
else:
await event.edit(
msgRep.REM_DEL_ACCS_COUNT.format(rem_del_accounts))
if LOGGING:
await event_log(
event,
"DELACCS",
chat_title=chat.title,
chat_link=chat.username if hasattr(chat, "username") else None,
chat_id=format_chat_id(chat) if remote else event.chat_id)
else:
if remote:
await event.edit(msgRep.NO_DEL_ACCOUNTS_REMOTE.format(chat.title))
else:
await event.edit(msgRep.NO_DEL_ACCOUNTS)
return
async def ban(event):
entity, chat = await fetch_entity(event, full_obj=True, get_chat=True)
if not entity:
return
if not chat:
await event.edit(msgRep.FAIL_CHAT)
return
if isinstance(chat, User):
await event.edit(msgRep.NO_GROUP_CHAN_ARGS)
return
remote = isRemoteCMD(event, chat.id)
admin_perms = chat.admin_rights if hasattr(chat, "admin_rights") else None
if admin_perms and not admin_perms.ban_users:
await event.edit(msgRep.NO_BAN_PRIV)
return
if isinstance(entity, ChatFull):
if entity.full_chat.linked_chat_id:
if entity.full_chat.linked_chat_id == chat.id:
await event.edit(msgRep.CANNOT_BAN_LINKED.format(chat.title))
return
entity_id = entity.full_chat.id
chatinfo = None
for c in entity.chats:
if c.id == entity_id:
chatinfo = c
break
if chatinfo.creator: # careful, you can expose yourself ;)
await event.edit(msgRep.CANNOT_BAN_CHANNEL_SELF)
return
if entity_id == chat.id:
await event.edit(msgRep.CANNOT_BAN_CHANNEL_ITSELF)
return
name = (f"[{chatinfo.title}](https://t.me/{chatinfo.username})"
if chatinfo.username else chatinfo.title)
entity_id = f"-100{entity_id}"
entity_id = int(entity_id)
elif isinstance(entity, UserFull):
if entity.user.is_self:
await event.edit(msgRep.CANNOT_BAN_SELF)
return
entity_id = entity.user.id
name = (f"[{entity.user.first_name}](tg://user?id={entity_id})"
if entity.user.first_name else msgRep.DELETED_ACCOUNT)
else:
await event.edit(msgRep.UNKNOWN_THING)
log.warning("Ban failed: target is not a channel or an user")
return
try:
# if view_messages is True then all ban permissions will
# be set to True too
ban_perms = ChatBannedRights(until_date=None, view_messages=True)
await event.client(EditBannedRequest(chat.id, entity_id, ban_perms))
if remote:
await event.edit(msgRep.BAN_SUCCESS_REMOTE.format(
name, chat.title))
else:
await event.edit(msgRep.BAN_SUCCESS.format(name))
if LOGGING:
if isinstance(entity, UserFull):
entity_username = entity.user.username
else:
entity_username = chatinfo.username
await event_log(
event,
"BAN",
user_name=name,
username=entity_username,
user_id=entity_id,
chat_title=chat.title,
chat_link=chat.username if hasattr(chat, "username") else None,
chat_id=format_chat_id(chat) if remote else event.chat_id)
except ChatAdminRequiredError:
await event.edit(msgRep.NO_ADMIN)
except UserAdminInvalidError:
await event.edit(msgRep.CANNOT_BAN_ADMIN)
except Exception as e:
log.warning(e)
await event.edit(msgRep.BAN_FAILED)
return
