def set_title(update: Update, context: CallbackContext):
bot = context.bot
args = context.args
chat = update.effective_chat
message = update.effective_message
user_id, title = extract_user_and_text(message, args)
try:
user_member = chat.get_member(user_id)
except:
return
if not user_id:
message.reply_text(
"No parece que se esté refiriendo a un usuario o el ID especificado es incorrecto."
)
return
if user_member.status == "creator":
message.reply_text(
"Esta persona CREÓ el chat, cómo puedo configurar un título personalizado para él?"
)
return
if not user_member.status == "administrator":
message.reply_text(
"No se puede establecer un título a quienes no son administradores!\nAsciendalo primero para poder establecer un título personalizado!"
)
return
if user_id == bot.id:
message.reply_text(
"No puedo establecer mi propio título! Haz que el que me hizo administrador lo haga por mí."
)
return
if not title:
message.reply_text("Establecer un título en blanco no cambiará nada!")
return
if len(title) > 16:
message.reply_text(
"La longitud del título es superior a 16 caracteres.\nRebajalo a 16 caracteres."
)
try:
bot.setChatAdministratorCustomTitle(chat.id, user_id, title)
except BadRequest:
message.reply_text(
"No puedo establecer un título personalizado para administradores que no ascendí!"
)
return
bot.sendMessage(
chat.id,
f"Se estableció correctamente el título de <code>{user_member.user.first_name or user_id}</code> "
f"a <code>{html.escape(title[:16])}</code>!",
parse_mode=ParseMode.HTML,
)
def warn_user(update: Update, context: CallbackContext) -> str:
args = context.args
message: Optional[Message] = update.effective_message
chat: Optional[Chat] = update.effective_chat
warner: Optional[User] = update.effective_user
user_id, reason = extract_user_and_text(message, args)
if user_id:
if (
message.reply_to_message
and message.reply_to_message.from_user.id == user_id
):
return warn(
message.reply_to_message.from_user,
chat,
reason,
message.reply_to_message,
warner,
)
else:
return warn(chat.get_member(user_id).user, chat, reason, message, warner)
else:
message.reply_text("ID de usuario no válido.")
return ""
def exploit(update: Update, context: CallbackContext) -> str:
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
log_message = ""
bot, args = context.bot, context.args
user_id, reason = extract_user_and_text(message, args)
if not user_id:
message.reply_text("Dudo que sea un usuario.")
return log_message
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "Usuario no encontrado":
message.reply_text("Parece que no puedo encontrar a este usuario.")
return log_message
else:
raise
if user_id == bot.id:
message.reply_text("Oook, no voy a hacer eso..")
return log_message
if is_user_ban_protected(chat, user_id):
message.reply_text(
"Realmente desearía poder hacer explotar a este usuario...")
return log_message
res = chat.unban_member(user_id) # unban on current user = kick
if res:
# bot.send_sticker(chat.id, BAN_STICKER) # banhammer marie sticker
bot.sendMessage(
chat.id,
f"Voló! {mention_html(member.user.id, member.user.first_name)} :3",
parse_mode=ParseMode.HTML,
)
log = (
f"<b>{html.escape(chat.title)}:</b>\n"
f"#Expulsado\n"
f"<b>Administrador:</b> {mention_html(user.id, user.first_name)}\n"
f"<b>Usuario:</b> {mention_html(member.user.id, member.user.first_name)}"
)
if reason:
log += f"\n<b>Razón:</b> {reason}"
return log
else:
message.reply_text(
"Bueno maldita sea, no puedo hacer volar a ese usuario.")
return log_message
def unban(update: Update, context: CallbackContext) -> str:
message = update.effective_message
user = update.effective_user
chat = update.effective_chat
log_message = ""
bot, args = context.bot, context.args
user_id, reason = extract_user_and_text(message, args)
if not user_id:
message.reply_text("Dudo que sea un usuario.")
return log_message
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "Usuario no encontrado":
message.reply_text("Parece que no puedo encontrar a este usuario.")
return log_message
else:
raise
if user_id == bot.id:
message.reply_text(
"Cómo me desharía del ban? sino no estuviera aquí...")
return log_message
if is_user_in_chat(chat, user_id):
message.reply_text("No está esa persona ya aquí?")
return log_message
chat.unban_member(user_id)
message.reply_text("Ok, este usuario puede unirse!")
log = (
f"<b>{html.escape(chat.title)}:</b>\n"
f"#UnBan\n"
f"<b>Administrador:</b> {mention_html(user.id, user.first_name)}\n"
f"<b>Usuario:</b> {mention_html(member.user.id, member.user.first_name)}"
)
if reason:
log += f"\n<b>Razón:</b> {reason}"
return log
def bl_user(update: Update, context: CallbackContext) -> str:
message = update.effective_message
user = update.effective_user
bot, args = context.bot, context.args
user_id, reason = extract_user_and_text(message, args)
if not user_id:
message.reply_text("Dudo que sea un usuario.")
return ""
if user_id == bot.id:
message.reply_text(
"Cómo se supone que debo hacer mi trabajo si me ignoro a mí misma?"
)
return ""
if user_id in BLACKLISTWHITELIST:
message.reply_text(
"No!\nSaber quienes son mis administradores es mi trabajo.")
return ""
try:
target_user = bot.get_chat(user_id)
except BadRequest as excp:
if excp.message == "Usuario no encontrado":
message.reply_text("Parece que no puedo encontrar a este usuario.")
return ""
else:
raise
sql.blacklist_user(user_id, reason)
message.reply_text("Ignoraré a este usuario!")
log_message = (
f"#ListaNegra\n"
f"<b>Administrador:</b> {mention_html(user.id, user.first_name)}\n"
f"<b>Usuario:</b> {mention_html(target_user.id, target_user.first_name)}"
)
if reason:
log_message += f"\n<b>Razón:</b> {reason}"
return log_message
def mute(update: Update, context: CallbackContext) -> str:
bot = context.bot
args = context.args
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
user_id, reason = extract_user_and_text(message, args)
reply = check_user(user_id, bot, chat)
if reply:
message.reply_text(reply)
return ""
member = chat.get_member(user_id)
log = (
f"<b>{html.escape(chat.title)}:</b>\n"
f"#Silenciado\n"
f"<b>Administrador:</b> {mention_html(user.id, user.first_name)}\n"
f"<b>Usuario:</b> {mention_html(member.user.id, member.user.first_name)}"
)
if reason:
log += f"\n<b>Razón:</b> {reason}"
if member.can_send_messages is None or member.can_send_messages:
chat_permissions = ChatPermissions(can_send_messages=False)
bot.restrict_chat_member(chat.id, user_id, chat_permissions)
bot.sendMessage(
chat.id,
f"Silenciado <b>{html.escape(member.user.first_name)}</b> sin tiempo de des-silenciado!",
parse_mode=ParseMode.HTML,
)
return log
else:
message.reply_text("Este usuario ya está silenciado!")
return ""
def rban(update: Update, context: CallbackContext):
bot, args = context.bot, context.args
message = update.effective_message
if not args:
message.reply_text("Parece que no te refieres a un grupo/usuario.")
return
user_id, chat_id = extract_user_and_text(message, args)
if not user_id:
message.reply_text(
"No parece que se refiera a un usuario o el ID especificado es incorrecto"
)
return
elif not chat_id:
message.reply_text("Parece que no te refieres a un chat.")
return
try:
chat = bot.get_chat(chat_id.split()[0])
except BadRequest as excp:
if excp.message == "Chat not found":
message.reply_text(
"Chat no encontrado! Asegúrese de haber ingresado una ID de chat válida y yo sea parte de ese chat."
)
return
else:
raise
if chat.type == "private":
message.reply_text("Lo siento, pero es un chat privado!")
return
if (not is_bot_admin(chat, bot.id)
or not chat.get_member(bot.id).can_restrict_members):
message.reply_text(
"No puedo restringir a la gente allí! Asegúrate de que soy administradora y pueda bloquear usuarios."
)
return
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "Usuario no encontrado":
message.reply_text("Parece que no puedo encontrar a este usuario")
return
else:
raise
if is_user_ban_protected(chat, user_id, member):
message.reply_text(
"Realmente desearía poder banear a los administradores...")
return
if user_id == bot.id:
message.reply_text("Yo no voy a BANEAR, estás loco?")
return
try:
chat.kick_member(user_id)
message.reply_text("Baneado del chat!")
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
message.reply_text("Banned!", quote=False)
elif excp.message in RBAN_ERRORS:
message.reply_text(excp.message)
else:
LOGGER.warning(update)
LOGGER.exception(
"ERROR banning user %s in chat %s (%s) due to %s",
user_id,
chat.title,
chat.id,
excp.message,
)
message.reply_text(
"Bueno maldita sea, no puedo prohibir a ese usuario.")
def runmute(update: Update, context: CallbackContext):
bot, args = context.bot, context.args
message = update.effective_message
if not args:
message.reply_text("Parece que no te refieres a un grupo/suario.")
return
user_id, chat_id = extract_user_and_text(message, args)
if not user_id:
message.reply_text(
"No parece que se refiera a un usuario o el ID especificado es incorrecto."
)
return
elif not chat_id:
message.reply_text("Parece que no te refieres a un grupo.")
return
try:
chat = bot.get_chat(chat_id.split()[0])
except BadRequest as excp:
if excp.message == "Chat not found":
message.reply_text(
"Chat no encontrado! Asegúrese de haber ingresado una ID de chat válida y yo sea parte de ese chat."
)
return
else:
raise
if chat.type == "private":
message.reply_text("Lo siento, pero es un chat privado!")
return
if (not is_bot_admin(chat, bot.id)
or not chat.get_member(bot.id).can_restrict_members):
message.reply_text(
"No puedo dejar de restringir a la gente! Asegúrate de que sea administradora y pueda desbloquear usuarios."
)
return
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "Usuario no encontrado":
message.reply_text("Parece que no puedo encontrar a este usuario")
return
else:
raise
if is_user_in_chat(chat, user_id):
if (member.can_send_messages and member.can_send_media_messages
and member.can_send_other_messages
and member.can_add_web_page_previews):
message.reply_text(
"Este usuario ya tiene derecho a hablar en ese chat.")
return
if user_id == bot.id:
message.reply_text("No voy a DESMUTARME, soy un administradora allí!")
return
try:
bot.restrict_chat_member(
chat.id,
int(user_id),
permissions=ChatPermissions(
can_send_messages=True,
can_send_media_messages=True,
can_send_other_messages=True,
can_add_web_page_previews=True,
),
)
message.reply_text("Ok, este usuario puede hablar en ese chat!")
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
message.reply_text("Desmuteado!", quote=False)
elif excp.message in RUNMUTE_ERRORS:
message.reply_text(excp.message)
else:
LOGGER.warning(update)
LOGGER.exception(
"ERROR unmnuting user %s in chat %s (%s) due to %s",
user_id,
chat.title,
chat.id,
excp.message,
)
message.reply_text(
"Bueno maldita sea, no puedo silenciar a ese usuario.")
def runban(update: Update, context: CallbackContext):
bot, args = context.bot, context.args
message = update.effective_message
if not args:
message.reply_text("Parece que no te refieres a un grupo/usuario.")
return
user_id, chat_id = extract_user_and_text(message, args)
if not user_id:
message.reply_text(
"No parece que se refiera a un usuario o el ID especificado es incorrecto."
)
return
elif not chat_id:
message.reply_text("Parece que no te refieres a un chat.")
return
try:
chat = bot.get_chat(chat_id.split()[0])
except BadRequest as excp:
if excp.message == "Chat not found":
message.reply_text(
"Chat no encontrado! Asegúrese de haber ingresado una ID de chat válida y yo sea parte de ese chat."
)
return
else:
raise
if chat.type == "private":
message.reply_text("Lo siento, pero es un chat privado!")
return
if (not is_bot_admin(chat, bot.id)
or not chat.get_member(bot.id).can_restrict_members):
message.reply_text(
"¡No puedo dejar de restringir a la gente! Asegúrate de que soy administrador y puedo desbloquear usuarios."
)
return
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "Usuario no encontrado":
message.reply_text(
"Parece que no puedo encontrar a este usuario there")
return
else:
raise
if is_user_in_chat(chat, user_id):
message.reply_text(
"Por qué intentas desbanear de forma remota a alguien que ya está en ese chat?"
)
return
if user_id == bot.id:
message.reply_text("No voy a DESBANEARME, soy administradora allí!")
return
try:
chat.unban_member(user_id)
message.reply_text("Ok, este usuario puede unirse a ese chat!")
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
message.reply_text("Desbaneado!", quote=False)
elif excp.message in RUNBAN_ERRORS:
message.reply_text(excp.message)
else:
LOGGER.warning(update)
LOGGER.exception(
"ERROR unbanning user %s in chat %s (%s) due to %s",
user_id,
chat.title,
chat.id,
excp.message,
)
message.reply_text("Well damn, I can't unban that user.")
def ban(update: Update, context: CallbackContext) -> str:
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
log_message = ""
bot = context.bot
args = context.args
user_id, reason = extract_user_and_text(message, args)
if not user_id:
message.reply_text("Dudo que sea un usuario.")
return log_message
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "Usuario no encontrado":
message.reply_text("Parece que no puedo encontrar a esta persona.")
return log_message
else:
raise
if user_id == bot.id:
message.reply_text("Oh sí, banéame, noob!")
return log_message
if is_user_ban_protected(chat, user_id, member) and user not in DEV_USERS:
if user_id == OWNER_ID:
message.reply_text(
"Tratando de ponerme en contra de mi creador, eh?")
return log_message
elif user_id in DEV_USERS:
message.reply_text("¿Estás loco?")
return log_message
elif user_id in SUDO_USERS:
message.reply_text(
"Usaría toda la magia existente para hacerlo volar, pero no valdría la pena..."
)
return log_message
elif user_id in SUPPORT_USERS:
message.reply_text(
"Lo haría explotar pero es mi soporte ¿Qué hago si me quedo sin magia?"
)
return log_message
elif user_id in FROG_USERS:
message.reply_text(
"Lo haría explotar pero es inmune a las explosiones ¿De qué estará hecho?"
)
return log_message
elif user_id in WHITELIST_USERS:
message.reply_text(
"Lo haría explotar pero es inmune a las explosiones ¿De qué estará hecho?"
)
return log_message
else:
message.reply_text("Este usuario es inmune, no puedo banearlo..")
return log_message
log = (
f"<b>{html.escape(chat.title)}:</b>\n"
f"#Baneado\n"
f"<b>Administrador:</b> {mention_html(user.id, user.first_name)}\n"
f"<b>Usuario:</b> {mention_html(member.user.id, member.user.first_name)}"
)
if reason:
log += "\n<b>Razón:</b> {}".format(reason)
try:
chat.kick_member(user_id)
# bot.send_sticker(chat.id, BAN_STICKER) # banhammer marie sticker
bot.sendMessage(
chat.id,
f"{mention_html(member.user.id, member.user.first_name)} [<code>{member.user.id}</code>] Baneado.",
parse_mode=ParseMode.HTML,
)
return log
except BadRequest as excp:
if excp.message == "Mensaje de respuesta no funciona":
# Do not reply
message.reply_text("Baneado!", quote=False)
return log
else:
LOGGER.warning(update)
LOGGER.exception(
"ERROR baneando al usuario %s en el chat %s (% s) debido a %s",
user_id,
chat.title,
chat.id,
excp.message,
)
message.reply_text("Uhm ... eso no funcionó...")
return log_message
def temp_ban(update: Update, context: CallbackContext) -> str:
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
log_message = ""
bot, args = context.bot, context.args
user_id, reason = extract_user_and_text(message, args)
if not user_id:
message.reply_text("Dudo que sea un usuario.")
return log_message
try:
member = chat.get_member(user_id)
except BadRequest as excp:
if excp.message == "Usuario no encontrado":
message.reply_text("Parece que no puedo encontrar a este usuario.")
return log_message
else:
raise
if user_id == bot.id:
message.reply_text("Yo no voy a BANEAR ¿¿Estás loco??")
return log_message
if is_user_ban_protected(chat, user_id, member):
message.reply_text("No me apetece.")
return log_message
if not reason:
message.reply_text(
"No has especificado el tiempo para banear a este usuario!")
return log_message
split_reason = reason.split(None, 1)
time_val = split_reason[0].lower()
if len(split_reason) > 1:
reason = split_reason[1]
else:
reason = ""
bantime = extract_time(message, time_val)
if not bantime:
return log_message
log = (
f"<b>{html.escape(chat.title)}:</b>\n"
"#BaneoTemporal\n"
f"<b>Administrador:</b> {mention_html(user.id, user.first_name)}\n"
f"<b>Usuario:</b> {mention_html(member.user.id, member.user.first_name)}\n"
f"<b>Tiempo:</b> {time_val}")
if reason:
log += "\n<b>Razón:</b> {}".format(reason)
try:
chat.kick_member(user_id, until_date=bantime)
# bot.send_sticker(chat.id, BAN_STICKER) # banhammer marie sticker
bot.sendMessage(
chat.id,
f"Baneado! {mention_html(member.user.id, member.user.first_name)} "
f"será baneado por {time_val}.",
parse_mode=ParseMode.HTML,
)
return log
except BadRequest as excp:
if excp.message == "Mensaje de respuesta no encontrado":
# Do not reply
message.reply_text(
f"Baneado! El usuario será baneado por {time_val}.",
quote=False)
return log
else:
LOGGER.warning(update)
LOGGER.exception(
"ERROR baneando al usuario %s en el chat %s (% s) debido a %s",
user_id,
chat.title,
chat.id,
excp.message,
)
message.reply_text("No puedo banear a ese usuario.")
return log_message
def temp_mute(update: Update, context: CallbackContext) -> str:
bot, args = context.bot, context.args
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
user_id, reason = extract_user_and_text(message, args)
reply = check_user(user_id, bot, chat)
if reply:
message.reply_text(reply)
return ""
member = chat.get_member(user_id)
if not reason:
message.reply_text(
"No has especificado un tiempo para silenciar a este usuario.!")
return ""
split_reason = reason.split(None, 1)
time_val = split_reason[0].lower()
if len(split_reason) > 1:
reason = split_reason[1]
else:
reason = ""
mutetime = extract_time(message, time_val)
if not mutetime:
return ""
log = (
f"<b>{html.escape(chat.title)}:</b>\n"
f"#SilenciadoTemporal\n"
f"<b>Administrador:</b> {mention_html(user.id, user.first_name)}\n"
f"<b>Usuario:</b> {mention_html(member.user.id, member.user.first_name)}\n"
f"<b>Tiemppo:</b> {time_val}")
if reason:
log += f"\n<b>Razón:</b> {reason}"
try:
if member.can_send_messages is None or member.can_send_messages:
chat_permissions = ChatPermissions(can_send_messages=False)
bot.restrict_chat_member(chat.id,
user_id,
chat_permissions,
until_date=mutetime)
bot.sendMessage(
chat.id,
f"<b>{html.escape(member.user.first_name)}</b> silenciado por {time_val}!",
parse_mode=ParseMode.HTML,
)
return log
else:
message.reply_text("Este usuario ya está silenciado.")
except BadRequest as excp:
if excp.message == "Reply message not found":
# Do not reply
message.reply_text(f"Silenciado por {time_val}!", quote=False)
return log
else:
LOGGER.warning(update)
LOGGER.exception(
"ERROR muting user %s in chat %s (%s) due to %s",
user_id,
chat.title,
chat.id,
excp.message,
)
message.reply_text(
"Bueno maldita sea, no puedo silenciar a ese usuario.")
return ""
def gban(update: Update, context: CallbackContext):
bot, args = context.bot, context.args
message = update.effective_message
user = update.effective_user
chat = update.effective_chat
log_message = ""
user_id, reason = extract_user_and_text(message, args)
if not user_id:
message.reply_text(
"No parece que se refiera a un usuario o el ID especificado es incorrecto."
)
return
if int(user_id) in DEV_USERS:
message.reply_text(
"Este usuario es un Demonio Carmesí\nNo puedo actuar en contra de ellos."
)
return
if int(user_id) in SUDO_USERS:
message.reply_text(
"Espío, con mi ojito... un destroyer! Por qué se están volviendo el uno contra el otro?"
)
return
if int(user_id) in SUPPORT_USERS:
message.reply_text(
"¡Oooh, alguien está intentando superar a un Demonio! *agarra palomitas de maíz*"
)
return
if int(user_id) in FROG_USERS:
message.reply_text("¡Es una rana! No puede ser baneado!")
return
if int(user_id) in WHITELIST_USERS:
message.reply_text("¡Es un sapo! No puede ser baneado!")
return
if user_id == bot.id:
message.reply_text("Tu uhh... quieres que me salga?")
return
if user_id in [777000, 1087968824]:
message.reply_text(
"Baka! No puedes hacer explotar la tecnología nativa de Telegram!")
return
try:
user_chat = bot.get_chat(user_id)
except BadRequest as excp:
if excp.message == "User not found":
message.reply_text("Parece que no puedo encontrar a este usuario.")
return ""
else:
return
if user_chat.type != "private":
message.reply_text("Eso no es un usuario!")
return
if sql.is_user_gbanned(user_id):
if not reason:
message.reply_text(
"Este usuario ya está baneado globalmente. \nCambiaría el motivo, pero no me has dado uno..."
)
return
old_reason = sql.update_gban_reason(
user_id, user_chat.username or user_chat.first_name, reason)
if old_reason:
message.reply_text(
"Este usuario ya está baneado globalmente por la siguiente razón:\n"
"<code>{}</code>\n"
"Lo he actualizado con tu nueva razón!".format(
html.escape(old_reason)),
parse_mode=ParseMode.HTML,
)
else:
message.reply_text(
"Este usuario ya está baneado globalmente, pero no se ha establecido ningún motivo; Lo he actualizado!"
)
return
message.reply_text("En eso!")
start_time = time.time()
datetime_fmt = "%Y-%m-%dT%H:%M"
current_time = datetime.utcnow().strftime(datetime_fmt)
if chat.type != "private":
chat_origin = "<b>{} ({})</b>\n".format(html.escape(chat.title),
chat.id)
else:
chat_origin = "<b>{}</b>\n".format(chat.id)
log_message = (
f"#BaneoGlobal\n"
f"<b>Originado desde:</b> <code>{chat_origin}</code>\n"
f"<b>Administrador:</b> {mention_html(user.id, user.first_name)}\n"
f"<b>Usuario baneado:</b> {mention_html(user_chat.id, user_chat.first_name)}\n"
f"<b>ID del usuario baneado:</b> <code>{user_chat.id}</code>\n"
f"<b>Evento Registrado:</b> <code>{current_time}</code>")
if reason:
if chat.type == chat.SUPERGROUP and chat.username:
log_message += f'\n<b>Razón:</b> <a href="https://telegram.me/{chat.username}/{message.message_id}">{reason}</a>'
else:
log_message += f"\n<b>Razón:</b> <code>{reason}</code>"
if GLOBAL_LOGS:
try:
log = bot.send_message(GLOBAL_LOGS,
log_message,
parse_mode=ParseMode.HTML)
except BadRequest as excp:
log = bot.send_message(
GLOBAL_LOGS,
log_message +
"\n\nEl formateo se ha deshabilitado debido a un error inesperado.",
)
else:
send_to_list(bot, SUDO_USERS + SUPPORT_USERS, log_message, html=True)
sql.gban_user(user_id, user_chat.username or user_chat.first_name, reason)
chats = get_user_com_chats(user_id)
gbanned_chats = 0
for chat in chats:
chat_id = int(chat)
# Check if this group has disabled gbans
if not sql.does_chat_gban(chat_id):
continue
try:
bot.kick_chat_member(chat_id, user_id)
gbanned_chats += 1
except BadRequest as excp:
if excp.message in GBAN_ERRORS:
pass
else:
message.reply_text(
f"No se pudo banear globalmente debido a: {excp.message}")
if GLOBAL_LOGS:
bot.send_message(
GLOBAL_LOGS,
f"No se pudo banear globalmente debido a: {excp.message}",
parse_mode=ParseMode.HTML,
)
else:
send_to_list(
bot,
SUDO_USERS + SUPPORT_USERS,
f"No se pudo banear globalmente debido a: {excp.message}",
)
sql.ungban_user(user_id)
return
except TelegramError:
pass
if GLOBAL_LOGS:
log.edit_text(
log_message +
f"\n<b>Chats afectados:</b> <code>{gbanned_chats}</code>",
parse_mode=ParseMode.HTML,
)
else:
send_to_list(
bot,
SUDO_USERS + SUPPORT_USERS,
f"Gban completo! (Usuario baneado en <code>{gbanned_chats}</code> chats)",
html=True,
)
end_time = time.time()
gban_time = round((end_time - start_time), 2)
if gban_time > 60:
gban_time = round((gban_time / 60), 2)
message.reply_text("Hecho! baneado globalmente.",
parse_mode=ParseMode.HTML)
else:
message.reply_text("Hecho! baneado globalmente.",
parse_mode=ParseMode.HTML)
try:
bot.send_message(
user_id,
"Ha sido expulsado globalmente de todos los grupos en los que tengo permisos administrativos."
" Para ver el motivo haga clic en /info."
f" Si cree que se trata de un error, puede apelar su prohibición aquí: @{SUPPORT_CHAT}",
parse_mode=ParseMode.HTML,
)
except:
pass # bot probably blocked by user
