Exemple #1
0
def __chat_settings__(chat_id, user_id):
    num_warn_filters = sql.num_warn_chat_filters(chat_id)
    limit, soft_warn = sql.get_warn_setting(chat_id)
    return (
        f"Este chat tiene `{num_warn_filters}` filtros de advertencia. "
        f"Se necesitan {limit} advertencias antes de que el usuario reciba *{'kick' if soft_warn else 'ban'}*."
    )
Exemple #2
0
def set_warn_limit(update: Update, context: CallbackContext) -> str:
    args = context.args
    chat: Optional[Chat] = update.effective_chat
    user: Optional[User] = update.effective_user
    msg: Optional[Message] = update.effective_message

    if args:
        if args[0].isdigit():
            if int(args[0]) < 3:
                msg.reply_text("El límite mínimo de advertencia es 3!")
            else:
                sql.set_warn_limit(chat.id, int(args[0]))
                msg.reply_text(
                    "Se actualizó el límite de advertencias a{}".format(
                        args[0]))
                return (
                    f"<b>{html.escape(chat.title)}:</b>\n"
                    f"#LimiteAdvertencias\n"
                    f"<b>Administrador:</b> {mention_html(user.id, user.first_name)}\n"
                    f"Estableció el límite de advertencias en <code>{args[0]}</code>"
                )
        else:
            msg.reply_text("Dame un número como argumento!")
    else:
        limit, soft_warn = sql.get_warn_setting(chat.id)

        msg.reply_text("El límite de advertencia actual es {}".format(limit))
    return ""
Exemple #3
0
def warns(update: Update, context: CallbackContext):
    args = context.args
    message: Optional[Message] = update.effective_message
    chat: Optional[Chat] = update.effective_chat
    user_id = extract_user(message, args) or update.effective_user.id
    result = sql.get_warns(user_id, chat.id)

    if result and result[0] != 0:
        num_warns, reasons = result
        limit, soft_warn = sql.get_warn_setting(chat.id)

        if reasons:
            text = f"Este usuario tiene {num_warns}/{limit} advertencias, por los siguientes motivos:"
            for reason in reasons:
                text += f"\n • {reason}"

            msgs = split_message(text)
            for msg in msgs:
                update.effective_message.reply_text(msg)
        else:
            update.effective_message.reply_text(
                f"El usuario tiene {num_warns}/{limit} advertencias, pero no hay motivos para ninguna de ellas."
            )
    else:
        update.effective_message.reply_text(
            "Este usuario no tiene advertencias!")
Exemple #4
0
def set_warn_strength(update: Update, context: CallbackContext):
    args = context.args
    chat: Optional[Chat] = update.effective_chat
    user: Optional[User] = update.effective_user
    msg: Optional[Message] = update.effective_message

    if args:
        if args[0].lower() in ("on", "si"):
            sql.set_warn_strength(chat.id, False)
            msg.reply_text(
                "Demasiadas advertencias! ahora resultarán en un BAN!")
            return (
                f"<b>{html.escape(chat.title)}:</b>\n"
                f"<b>Administrador:</b> {mention_html(user.id, user.first_name)}\n"
                f"Se habilito las advertencias fuertes. Los usuarios serán explotados seriamente.(Ban)"
            )

        elif args[0].lower() in ("off", "no"):
            sql.set_warn_strength(chat.id, True)
            msg.reply_text(
                "Demasiadas advertencias ahora resultarán en un explosion! Los usuarios podrán unirse nuevamente después."
            )
            return (
                f"<b>{html.escape(chat.title)}:</b>\n"
                f"<b>Administrador:</b> {mention_html(user.id, user.first_name)}\n"
                f"Se desabilitaron las advertencias fuertes. Usaré un explosion! en los usuarios."
            )

        else:
            msg.reply_text("Solo entiendo on/si/no/off!")
    else:
        limit, soft_warn = sql.get_warn_setting(chat.id)
        if soft_warn:
            msg.reply_text(
                "Las advertencias están configuradas actualmente para *explotar* a los usuarios cuando sobrepasen los límites.(kick)",
                parse_mode=ParseMode.MARKDOWN,
            )
        else:
            msg.reply_text(
                "Las advertencias están configuradas actualmente para *banear* a los usuarios cuando sobrepasen los límites.",
                parse_mode=ParseMode.MARKDOWN,
            )
    return ""
Exemple #5
0
def warn(user: User,
         chat: Chat,
         reason: str,
         message: Message,
         warner: User = None) -> str:
    if is_user_admin(chat, user.id):
        # message.reply_text("Damn admins, They are too far to be One Punched!")
        return

    if user.id in FROG_USERS:
        if warner:
            message.reply_text("Las 'Ranas' no pueden ser advertidos.")
        else:
            message.reply_text(
                "El usuario es una 'Rana'\nNo puedo advertir a estos usuarios, pero deben evitar abusar de esto."
            )
        return

    if user.id in WHITELIST_USERS:
        if warner:
            message.reply_text("Los 'Sapos' no pueden ser advertidos.")
        else:
            message.reply_text(
                "El usuario es una 'Rana'\nNo puedo advertir a estos usuarios, pero deben evitar abusar de esto."
            )
        return

    if warner:
        warner_tag = mention_html(warner.id, warner.first_name)
    else:
        warner_tag = "Filtro de advertencia automatizado."

    limit, soft_warn = sql.get_warn_setting(chat.id)
    num_warns, reasons = sql.warn_user(user.id, chat.id, reason)
    if num_warns >= limit:
        sql.reset_warns(user.id, chat.id)
        if soft_warn:  # punch
            chat.unban_member(user.id)
            reply = (
                f"<code>💥</code> <b>Kickeo</b>\n"
                f" <b>• Usuario:</b> {mention_html(user.id, user.first_name)}\n"
                f" <b>• Advertencias:</b> {limit}")

        else:  # ban
            chat.kick_member(user.id)
            reply = (
                f"<code>💥</code><b>Baneo</b>\n"
                f" <b>• Usuario:</b> {mention_html(user.id, user.first_name)}\n"
                f" <b>• Advertencias:</b> {limit}")

        for warn_reason in reasons:
            reply += f"\n - {html.escape(warn_reason)}"

        # message.bot.send_sticker(chat.id, BAN_STICKER)  # Saitama's sticker
        keyboard = None
        log_reason = (
            f"<b>{html.escape(chat.title)}:</b>\n"
            f"#AdvertenciaBan\n"
            f"<b>Administrador:</b> {warner_tag}\n"
            f"<b>Usuario:</b> {mention_html(user.id, user.first_name)}\n"
            f"<b>Razón:</b> {reason}\n"
            f"<b>Advertencias:</b> <code>{num_warns}/{limit}</code>")

    else:
        keyboard = InlineKeyboardMarkup([[
            InlineKeyboardButton(
                "✖ Quitar Advertencia",
                callback_data="rm_warn({})".format(user.id),
            )
        ]])

        reply = (
            f"<code>💥</code><b>Advertencia</b>\n"
            f"<code> </code><b>• Usuario:</b> {mention_html(user.id, user.first_name)}\n"
            f"<code> </code><b>• Advertencias:</b> {num_warns}/{limit}")
        if reason:
            reply += f"\n<code> </code><b>•  Razón:</b> {html.escape(reason)}"

        log_reason = (
            f"<b>{html.escape(chat.title)}:</b>\n"
            f"#Advertencia\n"
            f"<b>Administrador:</b> {warner_tag}\n"
            f"<b>Usuario:</b> {mention_html(user.id, user.first_name)}\n"
            f"<b>Razón:</b> {reason}\n"
            f"<b>Advertencias:</b> <code>{num_warns}/{limit}</code>")

    try:
        message.reply_text(reply,
                           reply_markup=keyboard,
                           parse_mode=ParseMode.HTML)
    except BadRequest as excp:
        if excp.message == "Reply message not found":
            # Do not reply
            message.reply_text(reply,
                               reply_markup=keyboard,
                               parse_mode=ParseMode.HTML,
                               quote=False)
        else:
            raise
    return log_reason