async def unmute_usr(c: Alita, m: Message):
from alita import BOT_ID
if len(m.text.split()) == 1 and not m.reply_to_message:
await m.reply_text("I can't unmute nothing!")
return
user_id, user_first_name, _ = await extract_user(c, m)
if user_id == BOT_ID:
await m.reply_text(
"Huh, why would I unmute myself if you are using me?")
return
try:
await m.chat.restrict_member(user_id, m.chat.permissions)
LOGGER.info(f"{m.from_user.id} unmuted {user_id} in {m.chat.id}")
await m.reply_text((tlang(m, "admin.unmute.unmuted_user")).format(
admin=(await mention_html(m.from_user.first_name, m.from_user.id)),
unmuted=(await mention_html(user_first_name, user_id)),
), )
except ChatAdminRequired:
await m.reply_text(tlang(m, "admin.not_admin"))
except UserNotParticipant:
await m.reply_text(
"How can I unmute a user who is not a part of this chat?")
except RightForbidden:
await m.reply_text(tlang(m, "admin.unmute.bot_no_right"))
except RPCError as ef:
await m.reply_text((tlang(m, "general.some_error")).format(
SUPPORT_GROUP=SUPPORT_GROUP,
ef=ef,
), )
LOGGER.error(ef)
return
async def reload_admins(_, m: Message):
global TEMP_ADMIN_CACHE_BLOCK
if m.chat.type != "supergroup":
return await m.reply_text(
"This command is made to be used in groups only!", )
if ((m.chat.id in set(TEMP_ADMIN_CACHE_BLOCK.keys()))
and (m.from_user.id not in SUPPORT_STAFF)
and TEMP_ADMIN_CACHE_BLOCK[m.chat.id] == "manualblock"):
await m.reply_text("Can only reload admin cache once per 10 mins!")
return
try:
await admin_cache_reload(m, "admincache")
TEMP_ADMIN_CACHE_BLOCK[m.chat.id] = "manualblock"
await m.reply_text(tlang(m, "admin.adminlist.reloaded_admins"))
LOGGER.info(f"Admincache cmd use in {m.chat.id} by {m.from_user.id}")
except RPCError as ef:
await m.reply_text((tlang(m, "general.some_error")).format(
SUPPORT_GROUP=SUPPORT_GROUP,
ef=ef,
), )
LOGGER.error(ef)
LOGGER.error(format_exc())
return
async def get_invitelink(c: Alita, m: Message):
# Bypass the bot devs, sudos and owner
if m.from_user.id not in DEV_LEVEL:
user = await m.chat.get_member(m.from_user.id)
if not user.can_invite_users and user.status != "creator":
await m.reply_text(tlang(m, "admin.no_user_invite_perm"))
return False
try:
link = await c.export_chat_invite_link(m.chat.id)
await m.reply_text(
(tlang(m, "admin.invitelink")).format(
chat_name=m.chat.id,
link=link,
),
disable_web_page_preview=True,
)
LOGGER.info(f"{m.from_user.id} exported invite link in {m.chat.id}")
except ChatAdminRequired:
await m.reply_text(tlang(m, "admin.not_admin"))
except ChatAdminInviteRequired:
await m.reply_text(tlang(m, "admin.no_invite_perm"))
except RightForbidden:
await m.reply_text(tlang(m, "admin.no_user_invite_perm"))
except RPCError as ef:
await m.reply_text((tlang(m, "general.some_error")).format(
SUPPORT_GROUP=SUPPORT_GROUP,
ef=ef,
), )
LOGGER.error(ef)
LOGGER.error(format_exc())
return
async def get_invitelink(c: Alita, m: Message):
try:
link = await c.export_chat_invite_link(m.chat.id)
await m.reply_text(
tlang(m, "admin.invitelink").format(
chat_name=f"<b>{m.chat.id}</b>",
link=link,
),
)
except ChatAdminRequired:
await m.reply_text(tlang(m, "admin.not_admin"))
except ChatAdminInviteRequired:
await m.reply_text(tlang(m, "admin.noinviteperm"))
except RightForbidden:
await m.reply_text(tlang(m, "no_invite_perm"))
except RPCError as ef:
await m.reply_text(
tlang(m, "general.some_error").format(
SUPPORT_GROUP=f"@{SUPPORT_GROUP}",
ef=f"<code>{ef}</code>",
),
)
LOGGER.error(ef)
return
async def get_invitelink(c: Alita, m: Message):
try:
link = await c.export_chat_invite_link(m.chat.id)
await m.reply_text(
(tlang(m, "admin.invitelink")).format(
chat_name=m.chat.id,
link=link,
),
disable_web_page_preview=True,
)
LOGGER.info(f"{m.from_user.id} exported invite link in {m.chat.id}")
except ChatAdminRequired:
await m.reply_text(tlang(m, "admin.not_admin"))
except ChatAdminInviteRequired:
await m.reply_text(tlang(m, "admin.no_invite_perm"))
except RightForbidden:
await m.reply_text(tlang(m, "admin.no_user_invite_perm"))
except RPCError as ef:
await m.reply_text(
(tlang(m, "general.some_error")).format(
SUPPORT_GROUP=SUPPORT_GROUP,
ef=ef,
),
)
LOGGER.error(ef)
LOGGER.error(format_exc())
return
async def adminlist(c: Alita, m: Message):
_ = GetLang(m).strs
try:
me_id = int(get_key("BOT_ID")) # Get Bot ID from Redis!
adminlist = get_key("ADMINDICT")[str(
m.chat.id)] # Load ADMINDICT from string
adminstr = _("admin.adminlist").format(chat_title=m.chat.title)
for i in adminlist:
usr = await c.get_users(i)
if i == me_id:
adminstr += f"- {mention_html(usr.first_name, i)} (Me)\n"
else:
usr = await c.get_users(i)
adminstr += f"- {mention_html(usr.first_name, i)} (`{i}`)\n"
await m.reply_text(adminstr)
except Exception as ef:
if str(ef) == str(m.chat.id):
await m.reply_text(_("admin.useadmincache"))
else:
await m.reply_text(
_("admin.somerror").format(SUPPORT_GROUP=SUPPORT_GROUP, ef=ef))
LOGGER.error(ef)
return
async def reload_admins(_, m: Message):
ADMINDICT = await get_key("ADMINDICT") # Load ADMINDICT from string
try:
adminlist = []
async for i in m.chat.iter_members(filter="administrators"):
if i.user.is_deleted:
continue
adminlist.append(
(
i.user.id,
f"@{i.user.username}" if i.user.username else i.user.first_name,
),
)
ADMINDICT[str(m.chat.id)] = adminlist
await set_key("ADMINDICT", ADMINDICT)
await m.reply_text(tlang(m, "admin.adminlist.reloaded_admins"))
except RPCError as ef:
await m.reply_text(
tlang(m, "general.some_error").format(
SUPPORT_GROUP=f"@{SUPPORT_GROUP}",
ef=f"<code>{ef}</code>",
),
)
LOGGER.error(ef)
return
async def demote_usr(c: Alita, m: Message):
res = await admin_check(c, m)
if not res:
return
from_user = await m.chat.get_member(m.from_user.id)
# If user does not have permission to invite other users, return
if from_user.can_invite_users or from_user.status == "creator":
try:
link = await c.export_chat_invite_link(m.chat.id)
await m.reply_text(_("admin.invitelink").format(link=link))
except errors.ChatAdminRequired:
await m.reply_text(_("admin.notadmin"))
except errors.ChatAdminInviteRequired:
await m.reply_text(_("admin.noinviteperm"))
except Exception as ef:
await m.reply_text(_("admin.useadmincache"))
LOGGER.error(ef)
return
await m.reply_text(_("admin.nouserinviteperm"))
return
async def pin_message(c: Alita, m: Message):
res = await admin_check(c, m)
if not res:
return
pin_loud = m.text.split(" ", 1)
if m.reply_to_message:
try:
disable_notification = True
if len(pin_loud) >= 2 and pin_loud[1] in [
"alert", "notify", "loud"
]:
disable_notification = False
pinned_event = await c.pin_chat_message(
m.chat.id,
m.reply_to_m.message_id,
disable_notification=disable_notification,
)
await m.reply_text(_("admin.pinnedmsg"))
except errors.ChatAdminRequired:
await m.reply_text(_("admin.notadmin"))
except Exception as ef:
await m.reply_text(_("admin.useadmincache"))
LOGGER.error(ef)
else:
await m.reply_text(_("admin.nopinmsg"))
return
async def unpinall_calllback(c: Alita, q: CallbackQuery):
user_id = q.from_user.id
user_status = (await q.message.chat.get_member(user_id)).status
if user_status not in {"creator", "administrator"}:
await q.answer(
"You're not even an admin, don't try this explosive shit!",
show_alert=True,
)
return
if user_status != "creator":
await q.answer(
"You're just an admin, not owner\nStay in your limits!",
show_alert=True,
)
return
try:
await c.unpin_all_chat_messages(q.message.chat.id)
LOGGER.info(
f"{q.from_user.id} unpinned all messages in {q.message.chat.id}")
await q.message.edit_text(tlang(q, "pin.unpinned_all_msg"))
except ChatAdminRequired:
await q.message.edit_text(tlang(q, "admin.notadmin"))
except RightForbidden:
await q.message.edit_text(tlang(q, "pin.no_rights_unpin"))
except RPCError as ef:
await q.message.edit_text((tlang(q, "general.some_error")).format(
SUPPORT_GROUP=SUPPORT_GROUP,
ef=ef,
), )
LOGGER.error(ef)
return
async def unmute_usr(c: Alita, m: Message):
_ = GetLang(m).strs
res = await admin_check(c, m)
if not res:
return
from_user = await m.chat.get_member(m.from_user.id)
if len(m.text.split()) == 1 and not m.reply_to_message:
await m.reply_text("Whom should I unmute?\nSpecify a user first.")
return
if from_user.can_restrict_members or from_user.status == "creator":
user_id, user_first_name = extract_user(m)
try:
await m.chat.restrict_member(user_id, unmute_permissions)
await m.reply_text(f"<b>Muted</b> {mention_html(user_first_name,user_id)}")
except errors.ChatAdminRequired:
await m.reply_text(_("admin.notadmin"))
except Exception as ef:
await m.reply_text(f"<code>{ef}</code>\nReport to @{SUPPORT_GROUP}")
LOGGER.error(ef)
return
await m.reply_text("You don't have permissions to restrict users.")
return
async def kick_usr(c: Alita, m: Message):
_ = GetLang(m).strs
res = await admin_check(c, m)
if not res:
return
from_user = await m.chat.get_member(m.from_user.id)
if len(m.text.split()) == 1 and not m.reply_to_message:
await m.reply_text("Whom should I kick?\nSpecify a user first.")
return
if from_user.can_restrict_members or from_user.status == "creator":
user_id, user_first_name = extract_user(m)
try:
await c.kick_chat_member(m.chat.id, user_id, int(time.time() + 45))
await m.reply_text(f"Banned {mention_html(user_first_name, user_id)}")
except errors.ChatAdminRequired:
await m.reply_text(_("admin.notadmin"))
except Exception as ef:
await m.reply_text(f"<code>{ef}</code>\nReport to @{SUPPORT_GROUP}")
LOGGER.error(ef)
return
async def initial_works(_, m: Message):
try:
if m.migrate_to_chat_id or m.migrate_from_chat_id:
if m.migrate_to_chat_id:
old_chat = m.chat.id
new_chat = m.migrate_to_chat_id
elif m.migrate_from_chat_id:
old_chat = m.migrate_from_chat_id
new_chat = m.chat.id
try:
await migrate_chat(old_chat, new_chat)
except RPCError as ef:
LOGGER.error(ef)
return
else:
userdb.update_user(
m.from_user.id,
m.from_user.username,
m.chat.id,
m.chat.title,
)
if m.reply_to_message:
userdb.update_user(
m.reply_to_message.from_user.id,
m.reply_to_message.from_user.username,
m.chat.id,
m.chat.title,
)
if m.forward_from:
userdb.update_user(m.forward_from.id, m.forward_from.username)
except AttributeError:
pass # Skip attribute errors!
return
async def pin_message(c: Alita, m: Message):
_ = GetLang(m).strs
if not (await admin_check(c, m)):
return
pin_args = m.text.split(None, 1)
if m.reply_to_message:
try:
disable_notification = True
if len(pin_args) >= 2 and pin_args[1] in ["alert", "notify", "loud"]:
disable_notification = False
await c.pin_chat_message(
m.chat.id,
m.reply_to_message.message_id,
disable_notification=disable_notification,
)
await m.reply_text(_("admin.pinnedmsg"))
except errors.ChatAdminRequired:
await m.reply_text(_("admin.notadmin"))
except errors.RightForbidden:
await m.reply_text("I don't have enough rights to pin messages.")
except Exception as ef:
await m.reply_text(f"<code>{ef}</code>\nReport to @{SUPPORT_GROUP}")
LOGGER.error(ef)
else:
await m.reply_text(_("admin.nopinmsg"))
return
async def chat_broadcast(c: Alita, m: Message):
if m.reply_to_message:
msg = m.reply_to_message.text.markdown
else:
await m.reply_text("Reply to a message to broadcast it")
return
exmsg = await m.reply_text("Started broadcasting!")
all_chats = (Chats.list_chats_by_id()) or {}
err_str, done_broadcast = "", 0
for chat in all_chats:
try:
await c.send_message(chat, msg, disable_web_page_preview=True)
done_broadcast += 1
await sleep(0.1)
except RPCError as ef:
LOGGER.error(ef)
err_str += str(ef)
continue
await exmsg.edit_text(
f"Done broadcasting ✅\nSent message to {done_broadcast} chats",
)
if err_str:
with BytesIO(str.encode(await remove_markdown_and_html(err_str))) as f:
f.name = "error_broadcast.txt"
await m.reply_document(
document=f,
caption="Broadcast Error",
)
return
async def reload_admins(c: Alita, m: Message):
_ = GetLang(m).strs
replymsg = await m.reply_text("Refreshing admin list...")
if not (await admin_check(c, m)):
return
ADMINDICT = await get_key("ADMINDICT") # Load ADMINDICT from string
try:
adminlist = []
async for i in m.chat.iter_members(filter="administrators"):
if not i.user.is_deleted:
continue
adminlist.append((
i.user.id,
f"@{i.user.username}"
if i.user.username else i.user.first_name,
), )
ADMINDICT[str(m.chat.id)] = adminlist
await set_key("ADMINDICT", ADMINDICT)
await replymsg.edit_text(_("admin.reloadedadmins"))
LOGGER.info(f"Reloaded admins for {m.chat.title}({m.chat.id})")
except Exception as ef:
await m.reply_text(_("admin.useadmincache"))
LOGGER.error(ef)
return
async def ban_usr(_, m: Message):
user_id, user_first_name = await extract_user(m)
try:
await m.chat.kick_member(user_id)
await m.reply_text(
tlang(m, "admin.banned_user").format(
admin=(await mention_html(m.from_user.first_name,
m.from_user.id)),
banned=(await mention_html(user_first_name, user_id)),
chat_title=f"<b>{m.chat.title}</b>",
), )
except ChatAdminRequired:
await m.reply_text(tlang(m, "admin.not_admin"))
except RightForbidden:
await m.reply_text(tlang(m, tlang(m, "admin.bot_no_ban_right")))
except RPCError as ef:
await m.reply_text(
tlang(m, "general.some_error").format(
SUPPORT_GROUP=f"@{SUPPORT_GROUP}",
ef=f"<code>{ef}</code>",
), )
LOGGER.error(ef)
return
async def get_invitelink(c: Alita, m: Message):
_ = GetLang(m).strs
if not (await admin_check(c, m)):
return
from_user = await m.chat.get_member(m.from_user.id)
# If user does not have permission to invite other users, return
if from_user.can_invite_users or from_user.status == "creator":
try:
link = await c.export_chat_invite_link(m.chat.id)
await m.reply_text(_("admin.invitelink").format(link=link))
except errors.ChatAdminRequired:
await m.reply_text(_("admin.notadmin"))
except errors.ChatAdminInviteRequired:
await m.reply_text(_("admin.noinviteperm"))
except errors.RightForbidden:
await m.reply_text("I don't have enough rights to view invitelink."
)
except Exception as ef:
await m.reply_text(f"<code>{ef}</code>\nReport to @{SUPPORT_GROUP}"
)
LOGGER.error(ef)
return
await m.reply_text(_("admin.nouserinviteperm"))
return
async def unmute_usr(c: Alita, m: Message):
_ = GetLang(m).strs
if not (await admin_check(c, m)):
return
from_user = await m.chat.get_member(m.from_user.id)
if from_user.can_restrict_members or from_user.status == "creator":
user_id, user_first_name = await extract_user(m)
try:
await m.chat.restrict_member(user_id, unmute_permissions)
await m.reply_text(
f"<b>Unmuted</b> {(await mention_html(user_first_name,user_id))}",
)
except errors.ChatAdminRequired:
await m.reply_text(_("admin.notadmin"))
except Exception as ef:
await m.reply_text(f"<code>{ef}</code>\nReport to @{SUPPORT_GROUP}"
)
LOGGER.error(ef)
return
await m.reply_text("You don't have permissions to restrict users.")
return
async def skick_usr(c: Alita, m: Message):
if len(m.text.split()) == 1 and not m.reply_to_message:
await m.reply_text(tlang(m, "admin.kick.no_target"))
return
try:
user_id, _, _ = await extract_user(c, m)
except Exception:
return
if not user_id:
await m.reply_text("Cannot find user to kick")
return
if user_id == BOT_ID:
await m.reply_text("Huh, why would I kick myself?")
await m.stop_propagation()
if user_id in SUPPORT_STAFF:
await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
LOGGER.info(
f"{m.from_user.id} trying to skick {user_id} (SUPPORT_STAFF) in {m.chat.id}",
)
await m.stop_propagation()
try:
admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
except KeyError:
admins_group = await admin_cache_reload(m, "kick")
if user_id in admins_group:
await m.reply_text(tlang(m, "admin.kick.admin_cannot_kick"))
await m.stop_propagation()
try:
LOGGER.info(f"{m.from_user.id} skicked {user_id} in {m.chat.id}")
await m.chat.kick_member(user_id)
await m.delete()
if m.reply_to_message:
await m.reply_to_message.delete()
await m.chat.unban_member(user_id)
except ChatAdminRequired:
await m.reply_text(tlang(m, "admin.not_admin"))
except PeerIdInvalid:
await m.reply_text(
"I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
)
except UserAdminInvalid:
await m.reply_text(tlang(m, "admin.user_admin_invalid"))
except RightForbidden:
await m.reply_text(tlang(m, "admin.kick.bot_no_right"))
except RPCError as ef:
await m.reply_text((tlang(m, "general.some_error")).format(
SUPPORT_GROUP=SUPPORT_GROUP,
ef=ef,
), )
LOGGER.error(ef)
LOGGER.error(format_exc())
return
async def initial_works(c: Alita, m: Message):
if m.migrate_to_chat_id or m.migrate_from_chat_id:
if m.migrate_to_chat_id:
old_chat = m.chat.id
new_chat = m.migrate_to_chat_id
elif m.migrate_from_chat_id:
old_chat = m.migrate_from_chat_id
new_chat = m.chat.id
try:
await migrate_chat(old_chat, new_chat)
except Exception as ef:
LOGGER.error(ef)
return
else:
userdb.update_user(m.from_user.id, m.from_user.username, m.chat.id,
m.chat.title)
if m.reply_to_message:
userdb.update_user(
m.reply_to_message.from_user.id,
m.reply_to_message.from_user.username,
m.chat.id,
m.chat.title,
)
if m.forward_from:
userdb.update_user(m.forward_from.id, m.forward_from.username)
return
def rm_filter(self, chat_id: int, keyword: str):
global FILTER_CACHE
with INSERTION_LOCK:
try:
FILTER_CACHE[chat_id].remove(
next(i for i in FILTER_CACHE[chat_id]
if keyword in i["keyword"].split("|")), )
except KeyError:
pass
except Exception as ef:
LOGGER.error(ef)
LOGGER.error(format_exc())
curr = self.collection.find_one(
{
"chat_id": chat_id,
"keyword": {
"$regex": fr"\|?{keyword}\|?"
}
}, )
if curr:
self.collection.delete_one(curr)
return True
return False
async def pin_message(c: Alita, m: Message):
pin_args = m.text.split(None, 1)
if m.reply_to_message:
try:
disable_notification = True
if len(pin_args) >= 2 and pin_args[1] in [
"alert", "notify", "loud"
]:
disable_notification = False
await c.pin_chat_message(
m.chat.id,
m.reply_to_message.message_id,
disable_notification=disable_notification,
)
await m.reply_text(tlang(m, "pin.pinned_msg"))
except ChatAdminRequired:
await m.reply_text(tlang(m, "admin.not_admin"))
except RightForbidden:
await m.reply_text(tlang(m, "pin.no_rights_pin"))
except RPCError as ef:
await m.reply_text(
tlang(m, "general.some_error").format(
SUPPORT_GROUP=f"@{SUPPORT_GROUP}",
ef=f"<code>{ef}</code>",
), )
LOGGER.error(ef)
else:
await m.reply_text(tlang(m, "admin.nopinmsg"))
return
async def unblacklist_chat(c: Alita, m: Message):
if len(m.text.split()) >= 2:
chat_ids = m.text.split()[1:]
replymsg = await m.reply_text(
f"Removing {len(chat_ids)} chats from blacklist")
LOGGER.info(
f"{m.from_user.id} removed blacklisted {chat_ids} groups for bot")
bl_chats = db.list_all_chats()
for chat in chat_ids:
try:
get_chat = await c.get_chat(chat)
chat_id = get_chat.id
if chat_id not in bl_chats:
# If chat is not blaklisted, continue loop
continue
db.remove_chat(chat_id)
except PeerIdInvalid:
await replymsg.edit_text(
"Haven't seen this group in this session, maybe try again later?",
)
except RPCError as ef:
LOGGER.error(ef)
LOGGER.error(format_exc())
await replymsg.edit_text(
f"Removed the following chats to Blacklist.\n<code>{', '.join(chat_ids)}</code>.",
)
return
async def antichanpin_cleanlinked(c: Alita, m: Message):
try:
msg_id = m.message_id
pins_db = Pins(m.chat.id)
curr = pins_db.get_settings()
if curr["antichannelpin"]:
await c.unpin_chat_message(chat_id=m.chat.id, message_id=msg_id)
LOGGER.info(
f"AntiChannelPin: msgid-{m.message_id} unpinned in {m.chat.id}"
)
if curr["cleanlinked"]:
await c.delete_messages(m.chat.id, msg_id)
LOGGER.info(
f"CleanLinked: msgid-{m.message_id} cleaned in {m.chat.id}")
except ChatAdminRequired:
await m.reply_text(
"Disabled antichannelpin as I don't have enough admin rights!", )
pins_db.antichannelpin_off()
LOGGER.warning(
f"Disabled antichannelpin in {m.chat.id} as i'm not an admin.")
except Exception as ef:
LOGGER.error(ef)
LOGGER.error(format_exc())
return
async def demote_usr(c: Alita, m: Message):
_ = GetLang(m).strs
if not (await admin_check(c, m)):
return
from_user = await m.chat.get_member(m.from_user.id)
# If user does not have permission to demote other users, return
if from_user.can_promote_members or from_user.status == "creator":
user_id, user_first_name = await extract_user(m)
try:
await m.chat.promote_member(
user_id=user_id,
can_change_info=False,
can_delete_messages=False,
can_restrict_members=False,
can_invite_users=False,
can_pin_messages=False,
)
await m.reply_text(
_("admin.demoted").format(
demoter=(await mention_html(m.from_user.first_name,
m.from_user.id)),
demoted=(await mention_html(user_first_name, user_id)),
chat_title=m.chat.title,
), )
# ----- Add admin to redis cache! -----
ADMINDICT = await get_key("ADMINDICT"
) # Load ADMINDICT from string
adminlist = []
async for i in m.chat.iter_members(filter="administrators"):
if not i.user.is_deleted:
continue
adminlist.append([
i.user.id,
f"@{i.user.username}"
if i.user.username else i.user.first_name,
], )
ADMINDICT[str(m.chat.id)] = adminlist
await set_key("ADMINDICT", ADMINDICT)
except errors.ChatAdminRequired:
await m.reply_text(_("admin.notadmin"))
except errors.RightForbidden:
await m.reply_text(
"I don't have enough rights to demote this user.")
except Exception as ef:
await m.reply_text(f"<code>{ef}</code>\nReport to @{SUPPORT_GROUP}"
)
LOGGER.error(ef)
return
await m.reply_text(_("admin.nodemoteperm"))
return
async def smute_usr(c: Alita, m: Message):
if len(m.text.split()) == 1 and not m.reply_to_message:
await m.reply_text("Я не могу никого замьютить!")
return
try:
user_id, _, _ = await extract_user(c, m)
except Exception:
return
if not user_id:
await m.reply_text("Cannot find user to mute")
return
if user_id == Config.BOT_ID:
await m.reply_text("Huh, why would I mute myself?")
return
if user_id in SUPPORT_STAFF:
LOGGER.info(
f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}",
)
await m.reply_text(tlang(m, "admin.support_cannot_restrict"))
return
try:
admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
except KeyError:
admins_group = await admin_cache_reload(m, "mute")
if user_id in admins_group:
await m.reply_text(tlang(m, "admin.mute.admin_cannot_mute"))
return
try:
await m.chat.restrict_member(
user_id,
ChatPermissions(),
)
LOGGER.info(f"{m.from_user.id} smuted {user_id} in {m.chat.id}")
await m.delete()
if m.reply_to_message:
await m.reply_to_message.delete()
return
return
except ChatAdminRequired:
await m.reply_text(tlang(m, "admin.not_admin"))
except RightForbidden:
await m.reply_text(tlang(m, "admin.mute.bot_no_right"))
except UserNotParticipant:
await m.reply_text(
"How can I mute a user who is not a part of this chat?")
except RPCError as ef:
await m.reply_text((tlang(m, "general.some_error")).format(
SUPPORT_GROUP=SUPPORT_GROUP,
ef=ef,
), )
LOGGER.error(ef)
return
async def close_btn_callback(_, q: CallbackQuery):
await q.message.delete()
try:
await q.message.reply_to_message.delete()
except Exception as ef:
LOGGER.error(f"Error: Cannot delete message\n{ef}")
await q.answer()
return
def list_gbans(self):
with INSERTION_LOCK:
try:
return list(ANTISPAM_BANNED)
except Exception as ef:
LOGGER.error(ef)
LOGGER.error(format_exc())
return self.collection.find_all()
def count_gbans(self):
with INSERTION_LOCK:
try:
return len(ANTISPAM_BANNED)
except Exception as ef:
LOGGER.error(ef)
LOGGER.error(format_exc())
return self.collection.count()
