async def remove_last_warn_btn(c: Alita, q: CallbackQuery):
try:
admins_group = {i[0] for i in ADMIN_CACHE[q.message.chat.id]}
except KeyError:
admins_group = {i[0] for i in (await admin_cache_reload(q, "warn_btn"))}
if q.from_user.id not in admins_group:
await q.answer("You are not allowed to use this!", show_alert=True)
return
args = q.data.split(".")
action = args[1]
user_id = int(args[2])
chat_id = int(q.message.chat.id)
user = Users.get_user_info(int(user_id))
user_first_name = user["name"]
if action == "remove":
warn_db = Warns(q.message.chat.id)
_, num_warns = warn_db.remove_warn(user_id)
await q.message.edit_text(
(
f"Admin {(await mention_html(q.from_user.first_name, q.from_user.id))} "
"removed last warn for "
f"{(await mention_html(user_first_name, user_id))}\n"
f"<b>Current Warnings:</b> {num_warns}"
),
)
if action == "kick":
try:
await c.kick_chat_member(chat_id, user_id, until_date=int(time() + 45))
await q.message.edit_text(
(
f"Admin {(await mention_html(q.from_user.first_name, q.from_user.id))} "
"kicked user "
f"{(await mention_html(user_first_name, user_id))} for last warning!"
),
)
except RPCError as err:
await q.message.edit_text(
f"🛑 Failed to Kick\n<b>Error:</b>\n</code>{err}</code>",
)
await q.answer()
return
async def my_info(c: Alita, m: Message):
try:
user_id, name, user_name = await extract_user(c, m)
except PeerIdInvalid:
await m.reply_text(tlang(m, "utils.user_info.peer_id_error"))
return
except ValueError as ef:
if "Peer id invalid" in str(ef):
await m.reply_text(tlang(m, "utils.user_info.id_not_found"))
return
try:
user = Users.get_user_info(int(user_id))
name = user["name"]
user_name = user["username"]
user_id = user["_id"]
except KeyError:
LOGGER.warning(f"Calling api to fetch info about user {user_id}")
user = await c.get_users(user_id)
name = (escape(user["first_name"] + " " + user["last_name"])
if user["last_name"] else user["first_name"])
user_name = user["username"]
user_id = user["id"]
except PeerIdInvalid:
await m.reply_text(tlang(m, "utils.no_user_db"))
return
except (RPCError, Exception) as ef:
await m.reply_text((tlang(m, "general.some_error")).format(
SUPPORT_GROUP=SUPPORT_GROUP,
ef=ef,
), )
return
gbanned, reason_gban = gban_db.get_gban(user_id)
LOGGER.info(f"{m.from_user.id} used info cmd for {user_id} in {m.chat.id}")
text = (tlang(m, "utils.user_info.info_text.main")).format(
user_id=user_id,
user_name=name,
)
if user_name:
text += (tlang(m, "utils.user_info.info_text.username")).format(
username=user_name, )
text += (tlang(m, "utils.user_info.info_text.perma_link")).format(
perma_link=(await mention_html("Click Here", user_id)), )
if gbanned:
text += f"\nThis user is Globally banned beacuse: {reason_gban}\n"
if user_id == OWNER_ID:
text += tlang(m, "utils.user_info.support_user.owner")
elif user_id in DEV_USERS:
text += tlang(m, "utils.user_info.support_user.dev")
elif user_id in SUDO_USERS:
text += tlang(m, "utils.user_info.support_user.sudo")
elif user_id in WHITELIST_USERS:
text += tlang(m, "utils.user_info.support_user.whitelist")
await m.reply_text(text, parse_mode="html", disable_web_page_preview=True)
return
async def extract_user(c: Alita, m: Message) -> Tuple[int, str, str]:
"""Extract the user from the provided message."""
user_id = None
user_first_name = None
user_name = None
if m.reply_to_message and m.reply_to_message.from_user:
user_id = m.reply_to_message.from_user.id
user_first_name = m.reply_to_message.from_user.first_name
user_name = m.reply_to_message.from_user.username
elif len(m.text.split()) > 1:
if len(m.entities) > 1:
required_entity = m.entities[1]
if required_entity.type == "text_mention":
user_id = required_entity.user.id
user_first_name = required_entity.user.first_name
user_name = required_entity.user.username
elif required_entity.type in ("mention", "phone_number"):
# new long user ids are identified as phone_number
user_found = m.text[required_entity.offset:(
required_entity.offset + required_entity.length)]
try:
user_found = int(user_found)
except (ValueError, Exception) as ef:
if "invalid literal for int() with base 10:" in str(ef):
user_found = str(user_found)
else:
LOGGER.error(ef)
LOGGER.error(format_exc())
try:
user = Users.get_user_info(user_found)
user_id = user["_id"]
user_first_name = user["name"]
user_name = user["username"]
except KeyError:
# If user not in database
try:
user = await c.get_users(user_found)
except Exception as ef:
return await m.reply_text(
f"User not found ! Error: {ef}")
user_id = user.id
user_first_name = user.first_name
user_name = user.username
except Exception as ef:
user_id = user_found
user_first_name = user_found
user_name = ""
LOGGER.error(ef)
LOGGER.error(format_exc())
else:
try:
user_id = int(m.text.split()[1])
except (ValueError, Exception) as ef:
if "invalid literal for int() with base 10:" in str(ef):
user_id = (str(m.text.split()[1]) if
(m.text.split()[1]).startswith("@") else None)
else:
user_id = m.text.split()[1]
LOGGER.error(ef)
LOGGER.error(format_exc())
if user_id is not None:
try:
user = Users.get_user_info(user_id)
user_first_name = user["name"]
user_name = user["username"]
except Exception as ef:
try:
user = await c.get_users(user_id)
except Exception as ef:
return await m.reply_text(
f"User not found ! Error: {ef}")
user_first_name = user.first_name
user_name = user.username
LOGGER.error(ef)
LOGGER.error(format_exc())
else:
user_id = m.from_user.id
user_first_name = m.from_user.first_name
user_name = m.from_user.username
return user_id, user_first_name, user_name