示例#1
0
def good_luck(bot, chat_id, message, text):
    ladmin = get_particular_admin(chat_id)
    user_id = message.from_user.id
    if ladmin is not None and ladmin.welcome:
        admin = get_admin_from_linked(chat_id)
        if admin is not None and admin.welcome and admin.admin_bot:
            config = get_config()
            adm_bot = Bot(token=config["telegram"]["admin_token"])
            replace_pogo = support.replace(user_id,
                                           message.from_user.first_name,
                                           admin=True)
            message_text = ("ℹ️ {}\n👤 {} {}").format(message.chat.title,
                                                     replace_pogo, text)
            adm_bot.sendMessage(chat_id=admin.id,
                                text=message_text,
                                parse_mode=telegram.ParseMode.MARKDOWN)
        elif admin is not None and admin.welcome:
            replace_pogo = support.replace(user_id,
                                           message.from_user.first_name,
                                           admin=True)
            message_text = ("ℹ️ {}\n👤 {} {}").format(message.chat.title,
                                                     replace_pogo, text)
            bot.sendMessage(chat_id=admin.id,
                            text=message_text,
                            parse_mode=telegram.ParseMode.MARKDOWN)
示例#2
0
def get_settings_keyboard(chat_id, keyboard="main"):
    if keyboard == "main":
        settings_keyboard = [
            [
                InlineKeyboardButton("👷‍♂️ Administración »",
                                     callback_data='settings_goto_ladmin')
            ],
            [
                InlineKeyboardButton("🛠 Ajustes »",
                                     callback_data='settings_goto_general')
            ],
            [
                InlineKeyboardButton("👋 Bienvenida »",
                                     callback_data='settings_goto_welcome')
            ],
            [
                InlineKeyboardButton("🚪 Entrada »",
                                     callback_data='settings_goto_join')
            ],
            [
                InlineKeyboardButton("📯 Noticias »",
                                     callback_data='settings_goto_news')
            ],
            [
                InlineKeyboardButton("🏫 Modo biblioteca »",
                                     callback_data='settings_goto_nanny')
            ],
            [InlineKeyboardButton("Terminado", callback_data='settings_done')]
        ]

    #2.GROUP SETTINGS
    elif keyboard == "general":
        group = get_group_settings(chat_id)
        if group.games == 1:
            games_text = "✅ Juegos"
        else:
            games_text = "▪️ Juegos"
        if group.hard == 1:
            hard_text = "✅ Ban (Warns)"
        else:
            hard_text = "▪️ Kick (Warns)"
        if group.reply_on_group == 1:
            reply_on_group_text = "✅ Respuestas en el grupo"
        else:
            reply_on_group_text = "▪️ Respuestas al privado"
        if group.warn is model.WarnLimit.SO_EXTRICT.value:
            warn_text = "Limite de warns: 3"
        elif group.warn is model.WarnLimit.EXTRICT.value:
            warn_text = "Limite de warns: 5"
        elif group.warn is model.WarnLimit.LOW_PERMISIVE.value:
            warn_text = "Limite de warns: 10"
        elif group.warn is model.WarnLimit.MED_PERMISIVE.value:
            warn_text = "Limite de warns: 25"
        elif group.warn is model.WarnLimit.HIGH_PERMISIVE.value:
            warn_text = "Limite de warns: 50"
        elif group.warn is model.WarnLimit.SO_TOLERANT.value:
            warn_text = "Limite de warns: 100"

        settings_keyboard = [
            [
                InlineKeyboardButton(games_text,
                                     callback_data='settings_general_games')
            ],
            [
                InlineKeyboardButton(hard_text,
                                     callback_data='settings_general_hard')
            ],
            [
                InlineKeyboardButton(reply_on_group_text,
                                     callback_data='settings_general_reply')
            ],
            [
                InlineKeyboardButton(warn_text,
                                     callback_data='settings_general_warn')
            ],
            [
                InlineKeyboardButton("« Menú principal",
                                     callback_data='settings_goto_main')
            ]
        ]

    #3.JOIN SETTINGS
    elif keyboard == "join":
        join = get_join_settings(chat_id)
        if join.requirment is model.ValidationRequiered.NO_VALIDATION.value:
            validationrequired_text = "▪️ Grupo abierto"
        elif join.requirment is model.ValidationRequiered.VALIDATION.value:
            validationrequired_text = "✅ Validación obligatoria"
        elif join.requirment is model.ValidationRequiered.PROFESSOR.value:
            validationrequired_text = "📚 Profesor"
        elif join.requirment is model.ValidationRequiered.MAGIZOOLOGIST.value:
            validationrequired_text = "🐾 Magizoologo"
        elif join.requirment is model.ValidationRequiered.AUROR.value:
            validationrequired_text = "⚔ Auror"
        elif join.requirment is model.ValidationRequiered.GRYFFINDOR.value:
            validationrequired_text = "🦁 Gryffindor"
        elif join.requirment is model.ValidationRequiered.HUFFLEPUFF.value:
            validationrequired_text = "🦡 Hufflepuff"
        elif join.requirment is model.ValidationRequiered.RAVENCLAW.value:
            validationrequired_text = "🦅 Ravenclaw"
        elif join.requirment is model.ValidationRequiered.SLYTHERIN.value:
            validationrequired_text = "🐍 Slytherin"

        if join.val_alert is True:
            mute_text = "✅ Expulsiones silenciosas"
        else:
            mute_text = "▪️ Expulsiones notificadas"

        if join.delete_header is True:
            silence_text = "✅ Borrar -> entró al grupo"
        else:
            silence_text = "▪️ Borrar -> entró al grupo"

        settings_keyboard = [
            [
                InlineKeyboardButton(mute_text,
                                     callback_data='settings_join_mute')
            ],
            [
                InlineKeyboardButton(silence_text,
                                     callback_data='settings_join_silence')
            ],
            [
                InlineKeyboardButton(validationrequired_text,
                                     callback_data='settings_join_val')
            ],
            [
                InlineKeyboardButton("« Menú principal",
                                     callback_data='settings_goto_main')
            ]
        ]

    #5.NEWS SETTINGS
    elif keyboard == "news":
        providers = get_verified_providers()
        settings_keyboard = []
        for k in providers:
            if is_news_subscribed(chat_id, k.id):
                status = "✅ @"
            else:
                status = "▪️ @"
            text = status + k.alias
            settings_keyboard.append([
                InlineKeyboardButton(text,
                                     callback_data='settings_news_{}'.format(
                                         k.id))
            ])

        settings_keyboard.append([
            InlineKeyboardButton("« Menú principal",
                                 callback_data='settings_goto_main')
        ])

    #6.WELCOME SETTINGS
    elif keyboard == "welcome":
        welcome = get_welcome_settings(chat_id)
        if welcome.should_welcome == 1:
            welcome_text = "✅ Bienvenida"
        else:
            welcome_text = "▪️ Bienvenida"
        settings_keyboard = [[
            InlineKeyboardButton(welcome_text,
                                 callback_data='settings_welcome_welcome')
        ],
                             [
                                 InlineKeyboardButton(
                                     "« Menú principal",
                                     callback_data='settings_goto_main')
                             ]]

    #7.NANNY SETTINGS
    elif keyboard == "nanny":
        nanny = get_nanny_settings(chat_id)
        if nanny is None:
            set_nanny(chat_id)
            nanny = get_nanny_settings(chat_id)

        if nanny.voice == 1:
            voice_text = "✅ Audio y Voz"
        else:
            voice_text = "▪️ Audio y Voz"
        if nanny.command == 1:
            comandos_text = "✅ Comandos"
        else:
            comandos_text = "▪️ Comandos"
        if nanny.contact == 1:
            contact_text = "✅ Contactos"
        else:
            contact_text = "▪️ Contactos"
        if nanny.animation == 1:
            animation_text = "✅ GIFs y Documentos"
        else:
            animation_text = "▪️ GIFs y Documentos"
        if nanny.photo == 1:
            photo_text = "✅ Imagenes"
        else:
            photo_text = "▪️ Imagenes"
        if nanny.games == 1:
            games_text = "✅ Juegos"
        else:
            games_text = "▪️ Juegos"
        if nanny.text == 1:
            text_text = "✅ Mensajes"
        else:
            text_text = "▪️ Mensajes"
        if nanny.sticker == 1:
            sticker_text = "✅ Stickers"
        else:
            sticker_text = "▪️ Stickers"
        if nanny.location == 1:
            location_text = "✅ Ubicaciones"
        else:
            location_text = "▪️ Ubicaciones"
        if nanny.urls == 1:
            url_text = "✅ URLs"
        else:
            url_text = "▪️ URLs"
        if nanny.video == 1:
            video_text = "✅ Video"
        else:
            video_text = "▪️ Video"
        if nanny.warn == 1:
            warn_text = "✅ Warns"
        else:
            warn_text = "▪️ Warns"
        if nanny.admin_too == 1:
            admin_too_text = "️✅ Mensajes de administradores"
        else:
            admin_too_text = "️️️▪️ Mensajes de administradores"

        settings_keyboard = [
            [
                InlineKeyboardButton(voice_text,
                                     callback_data='settings_nanny_voice')
            ],
            [
                InlineKeyboardButton(comandos_text,
                                     callback_data='settings_nanny_command')
            ],
            [
                InlineKeyboardButton(contact_text,
                                     callback_data='settings_nanny_contact')
            ],
            [
                InlineKeyboardButton(animation_text,
                                     callback_data='settings_nanny_animation')
            ],
            [
                InlineKeyboardButton(photo_text,
                                     callback_data='settings_nanny_photo')
            ],
            [
                InlineKeyboardButton(games_text,
                                     callback_data='settings_nanny_games')
            ],
            [
                InlineKeyboardButton(text_text,
                                     callback_data='settings_nanny_text')
            ],
            [
                InlineKeyboardButton(sticker_text,
                                     callback_data='settings_nanny_sticker')
            ],
            [
                InlineKeyboardButton(location_text,
                                     callback_data='settings_nanny_location')
            ],
            [
                InlineKeyboardButton(url_text,
                                     callback_data='settings_nanny_url')
            ],
            [
                InlineKeyboardButton(video_text,
                                     callback_data='settings_nanny_video')
            ],
            [
                InlineKeyboardButton(warn_text,
                                     callback_data='settings_nanny_warn')
            ],
            [
                InlineKeyboardButton(admin_too_text,
                                     callback_data='settings_nanny_admin_too')
            ],
            [
                InlineKeyboardButton("« Menú principal",
                                     callback_data='settings_goto_main')
            ]
        ]

    #8. LOCAL ADMIN
    elif keyboard == "ladmin":
        adgroup = get_particular_admin(chat_id)
        if adgroup.admin == 1:
            admin_text = "✅ @admin"
        else:
            admin_text = "▪️ @admin"
        if adgroup.welcome == 1:
            welcome_text = "✅ Entrada de usuarios"
        else:
            welcome_text = "▪️ Entrada de usuarios"
        if adgroup.ejections == 1:
            ejections_text = "✅ Expulsiones"
        else:
            ejections_text = "▪️ Expulsiones"

        settings_keyboard = [
            [
                InlineKeyboardButton(admin_text,
                                     callback_data='settings_ladmin_admin')
            ],
            [
                InlineKeyboardButton(welcome_text,
                                     callback_data='settings_ladmin_welcome')
            ],
            [
                InlineKeyboardButton(ejections_text,
                                     callback_data='settings_ladmin_ejections')
            ],
            [
                InlineKeyboardButton("« Menú principal",
                                     callback_data='settings_goto_main')
            ]
        ]

    #0. ADMIN
    elif keyboard == "admin":
        adgroup = get_admin(chat_id)
        if adgroup.admin == 1:
            admin_text = "✅ @admin"
        else:
            admin_text = "▪️ @admin"
        if adgroup.welcome == 1:
            welcome_text = "✅ Entrada de usuarios"
        else:
            welcome_text = "▪️ Entrada de usuarios"
        if adgroup.ejections == 1:
            ejections_text = "✅ Expulsiones"
        else:
            ejections_text = "▪️ Expulsiones"

        spy_mode = "🦅 Fawkes"

        settings_keyboard = [
            [
                InlineKeyboardButton(admin_text,
                                     callback_data='settings_admin_admin')
            ],
            [
                InlineKeyboardButton(welcome_text,
                                     callback_data='settings_admin_welcome')
            ],
            [
                InlineKeyboardButton(ejections_text,
                                     callback_data='settings_admin_ejections')
            ],
            [
                InlineKeyboardButton(spy_mode,
                                     callback_data='settings_admin_spy')
            ],
            [InlineKeyboardButton("Terminado", callback_data='settings_done')]
        ]

    settings_markup = InlineKeyboardMarkup(settings_keyboard)
    return settings_markup
示例#3
0
def joined_chat(bot, update, job_queue):
    chat_id, chat_type, user_id, text, message = support.extract_update_info(
        update)
    new_chat_member = message.new_chat_members[
        0] if message.new_chat_members else None

    config = get_config()
    bot_alias = config['telegram']['bot_alias']

    if new_chat_member.username == bot_alias:
        if are_banned(user_id, chat_id):
            bot.leaveChat(chat_id=chat_id)
            return

        chat_title = message.chat.title
        chat_id = message.chat.id
        group = group_sql.get_real_group(chat_id)
        if group is None:
            group_sql.set_group(chat_id, message.chat.title)

        message_text = ("Si necesitais ayuda podéis lanzar chispas rojas c"
                        "on vuestra varita o utilizando el comando `/help`"
                        " para conocer todas las funciones. Aseguraos de v"
                        "er la ayuda para prefectos de los grupos, donde s"
                        "e explica en detalle todos los pasos que se deben"
                        " seguir.".format(escape_markdown(chat_title)))

        admin = get_admin(chat_id)
        if admin is not None and admin.admin_bot is True:
            set_admin_settings(chat_id, "admin_bot")
            message_text = message_text + "\n\n*Fawkes emprendió el vuelo.*"

        bot.sendMessage(chat_id=chat_id,
                        text=message_text,
                        parse_mode=telegram.ParseMode.MARKDOWN)

    elif new_chat_member.username != bot_alias:
        chat_id = message.chat.id
        user_id = update.effective_message.new_chat_members[0].id

        group = get_join_settings(chat_id)
        if group is not None:
            if group.delete_header:
                support.delete_message(chat_id, message.message_id, bot)

            if are_banned(user_id, user_id):
                bot.kickChatMember(chat_id, user_id)
                return

            user = get_user(user_id)
            if user is None and group.requirment is not ValidationRequiered.NO_VALIDATION.value:
                bot.kickChatMember(chat_id=chat_id,
                                   user_id=user_id,
                                   until_date=time.time() + 31)
                if group.val_alert is False:
                    output = "👌 Mago sin registrarse expulsado!"
                    bot.sendMessage(chat_id=chat_id,
                                    text=output,
                                    parse_mode=telegram.ParseMode.MARKDOWN)
                good_luck(bot, chat_id, message,
                          "El usuario no está registrado")
                return

            elif group.requirment is ValidationRequiered.VALIDATION.value and user.level is None:
                bot.kickChatMember(chat_id=chat_id,
                                   user_id=user_id,
                                   until_date=time.time() + 31)
                if group.val_alert is False:
                    output = "👌 Mago infiltrado expulsado!"
                    bot.sendMessage(chat_id=chat_id,
                                    text=output,
                                    parse_mode=telegram.ParseMode.MARKDOWN)
                good_luck(bot, chat_id, message,
                          "El usuario no está registrado")
                try:
                    bot.sendMessage(
                        chat_id=user_id,
                        text="❌ Debes validarte para entrar en este grupo",
                        parse_mode=telegram.ParseMode.MARKDOWN)
                except Exception:
                    pass
                return

            elif group.requirment is ValidationRequiered.PROFESSOR.value and user.profession is not Professions.PROFESSOR.value:
                bot.kickChatMember(chat_id=chat_id,
                                   user_id=user_id,
                                   until_date=time.time() + 31)
                if group.val_alert is False:
                    output = "👌 Mago infiltrado expulsado!"
                    bot.sendMessage(chat_id=chat_id,
                                    text=output,
                                    parse_mode=telegram.ParseMode.MARKDOWN)
                good_luck(bot, chat_id, message,
                          "El usuario no está registrado")
                try:
                    bot.sendMessage(
                        chat_id=user_id,
                        text="❌ Debes validarte para entrar en este grupo",
                        parse_mode=telegram.ParseMode.MARKDOWN)
                except Exception:
                    pass
                return

            elif group.requirment is ValidationRequiered.MAGIZOOLOGIST.value and user.profession is not Professions.MAGIZOOLOGIST.value:
                bot.kickChatMember(chat_id=chat_id,
                                   user_id=user_id,
                                   until_date=time.time() + 31)
                if group.val_alert is False:
                    output = "👌 Mago infiltrado expulsado!"
                    bot.sendMessage(chat_id=chat_id,
                                    text=output,
                                    parse_mode=telegram.ParseMode.MARKDOWN)
                good_luck(bot, chat_id, message,
                          "El usuario no está registrado")
                try:
                    bot.sendMessage(
                        chat_id=user_id,
                        text="❌ Debes validarte para entrar en este grupo",
                        parse_mode=telegram.ParseMode.MARKDOWN)
                except Exception:
                    pass
                return

            elif group.requirment is ValidationRequiered.AUROR.value and user.profession is not Professions.AUROR.value:
                bot.kickChatMember(chat_id=chat_id,
                                   user_id=user_id,
                                   until_date=time.time() + 31)
                if group.val_alert is False:
                    output = "👌 Mago infiltrado expulsado!"
                    bot.sendMessage(chat_id=chat_id,
                                    text=output,
                                    parse_mode=telegram.ParseMode.MARKDOWN)
                good_luck(bot, chat_id, message,
                          "El usuario no está registrado")
                try:
                    bot.sendMessage(
                        chat_id=user_id,
                        text="❌ Debes validarte para entrar en este grupo",
                        parse_mode=telegram.ParseMode.MARKDOWN)
                except Exception:
                    pass
                return

            elif group.requirment is ValidationRequiered.GRYFFINDOR.value and user.house is not Houses.GRYFFINDOR.value:
                bot.kickChatMember(chat_id=chat_id,
                                   user_id=user_id,
                                   until_date=time.time() + 31)
                if group.val_alert is False:
                    output = "👌 Mago infiltrado expulsado!"
                    bot.sendMessage(chat_id=chat_id,
                                    text=output,
                                    parse_mode=telegram.ParseMode.MARKDOWN)
                good_luck(bot, chat_id, message,
                          "El usuario no está registrado")
                try:
                    bot.sendMessage(
                        chat_id=user_id,
                        text="❌ Debes validarte para entrar en este grupo",
                        parse_mode=telegram.ParseMode.MARKDOWN)
                except Exception:
                    pass
                return

            elif group.requirment is ValidationRequiered.HUFFLEPUFF.value and user.house is not Houses.HUFFLEPUFF.value:
                bot.kickChatMember(chat_id=chat_id,
                                   user_id=user_id,
                                   until_date=time.time() + 31)
                if group.val_alert is False:
                    output = "👌 Mago infiltrado expulsado!"
                    bot.sendMessage(chat_id=chat_id,
                                    text=output,
                                    parse_mode=telegram.ParseMode.MARKDOWN)
                good_luck(bot, chat_id, message,
                          "El usuario no está registrado")
                try:
                    bot.sendMessage(
                        chat_id=user_id,
                        text="❌ Debes validarte para entrar en este grupo",
                        parse_mode=telegram.ParseMode.MARKDOWN)
                except Exception:
                    pass
                return

            elif group.requirment is ValidationRequiered.RAVENCLAW.value and user.house is not Houses.RAVENCLAW.value:
                bot.kickChatMember(chat_id=chat_id,
                                   user_id=user_id,
                                   until_date=time.time() + 31)
                if group.val_alert is False:
                    output = "👌 Mago infiltrado expulsado!"
                    bot.sendMessage(chat_id=chat_id,
                                    text=output,
                                    parse_mode=telegram.ParseMode.MARKDOWN)
                good_luck(bot, chat_id, message,
                          "El usuario no está registrado")
                try:
                    bot.sendMessage(
                        chat_id=user_id,
                        text="❌ Debes validarte para entrar en este grupo",
                        parse_mode=telegram.ParseMode.MARKDOWN)
                except Exception:
                    pass
                return

            elif group.requirment is ValidationRequiered.SLYTHERIN.value and user.house is not Houses.SLYTHERIN.value:
                bot.kickChatMember(chat_id=chat_id,
                                   user_id=user_id,
                                   until_date=time.time() + 31)
                if group.val_alert is False:
                    output = "👌 Mago infiltrado expulsado!"
                    bot.sendMessage(chat_id=chat_id,
                                    text=output,
                                    parse_mode=telegram.ParseMode.MARKDOWN)
                good_luck(bot, chat_id, message,
                          "El usuario no está registrado")
                try:
                    bot.sendMessage(
                        chat_id=user_id,
                        text="❌ Debes validarte para entrar en este grupo",
                        parse_mode=telegram.ParseMode.MARKDOWN)
                except Exception:
                    pass
                return

            if group.max_members is not None and group.max_members > 0 and bot.get_chat_members_count(
                    chat_id) >= group.max_members:
                if group.val_alert is False:
                    output = "❌ El número máximo de integrantes en el grupo ha sido alcanzado"
                    sent = bot.sendMessage(
                        chat_id=chat_id,
                        text=output,
                        parse_mode=telegram.ParseMode.MARKDOWN)
                    delete_object = support.DeleteContext(
                        chat_id, sent.message_id)
                    job_queue.run_once(support.callback_delete,
                                       10,
                                       context=delete_object)
                time.sleep(2)
                bot.kickChatMember(chat_id=chat_id,
                                   user_id=user_id,
                                   until_date=time.time() + 31)
                return

            if (not exists_user_group(user_id, chat_id)):
                set_user_group(user_id, chat_id)
            else:
                join_group(user_id, chat_id)

            if has_rules(chat_id):
                bot.restrict_chat_member(chat_id,
                                         user_id,
                                         until_date=0,
                                         can_send_messages=False,
                                         can_send_media_messages=False,
                                         can_send_other_messages=False,
                                         can_add_web_page_previews=False)

            if get_welc_pref(chat_id):
                sent = send_welcome(bot, update)
                if sent is not None and group.delete_cooldown is not None and group.delete_cooldown > 0:
                    delete_object = support.DeleteContext(
                        chat_id, sent.message_id)
                    job_queue.run_once(support.callback_delete,
                                       group.delete_cooldown,
                                       context=delete_object)
            '''
            if group.val_alert and (user is None or user.level is None):
                sent = bot.sendMessage(
                    chat_id=chat_id,
                    text="",
                    parse_mode=telegram.ParseMode.MARKDOWN
                )
                if sent is not None:
                    delete_object = support.DeleteContext(chat_id, sent.message_id)
                    job_queue.run_once(
                        support.callback_delete, 
                        group.delete_cooldown or 60,
                        context=delete_object
                    )
            '''
            ladmin = get_particular_admin(chat_id)
            if ladmin is not None and ladmin.welcome:
                admin = get_admin_from_linked(chat_id)
                if admin is not None and admin.welcome and admin.admin_bot:
                    config = get_config()
                    adm_bot = Bot(token=config["telegram"]["admin_token"])
                    replace_pogo = support.replace(
                        user_id, message.from_user.first_name, admin=True)
                    message_text = (
                        "ℹ️ {}\n👤 {} ha entrado en el grupo").format(
                            message.chat.title, replace_pogo)
                    adm_bot.sendMessage(chat_id=admin.id,
                                        text=message_text,
                                        parse_mode=telegram.ParseMode.MARKDOWN)
                elif admin is not None and admin.welcome:
                    replace_pogo = support.replace(
                        user_id, message.from_user.first_name, admin=True)
                    message_text = (
                        "ℹ️ {}\n👤 {} ha entrado en el grupo").format(
                            message.chat.title, replace_pogo)
                    bot.sendMessage(chat_id=admin.id,
                                    text=message_text,
                                    parse_mode=telegram.ParseMode.MARKDOWN)
示例#4
0
def process_group_message(bot, update, job_queue):
    chat_id, chat_type, user_id, text, message = support.extract_update_info(
        update)
    msg = update.effective_message

    if are_banned(user_id, chat_id):
        return

    group = group_sql.get_group(chat_id)
    if group is None:
        group_sql.set_group(chat_id, message.chat.title)
    if not exists_user_group(user_id, chat_id):
        set_user_group(user_id, chat_id)

    message_counter(user_id, chat_id)
    if get_group_settings(chat_id).games == True and (chat_type == 'supergroup'
                                                      or chat_type == 'group'):
        games_cmd(bot, update)

    if text is None or msg.photo is None:
        if msg and msg.document:
            nanny.process_gif(bot, update, job_queue)
            return
        elif msg and msg.contact:
            nanny.process_contact(bot, update, job_queue)
            return
        elif msg and msg.game:
            nanny.process_game(bot, update, job_queue)
            return
        elif msg and msg.location or msg.venue:
            nanny.process_ubi(bot, update, job_queue)
            return
        elif msg and msg.photo:
            nanny.process_pic(bot, update, job_queue)
            return
        elif msg and msg.sticker:
            nanny.process_sticker(bot, update, job_queue)
            return
        elif msg and msg.voice or msg.audio:
            nanny.process_voice(bot, update, job_queue)
            return
        elif msg and msg.video or msg.video_note:
            nanny.process_video(bot, update, job_queue)
            return

    if msg and msg.entities and nanny.process_url(bot, update, job_queue):
        return

    if nanny.nanny_text(bot, user_id, chat_id, message, job_queue):
        return

    if text is not None and re.search("@admin(?!\w)", text) is not None:
        replace_pogo = support.replace(user_id,
                                       message.from_user.first_name,
                                       admin=True)

        chat_text = support.message_url(message, message.message_id,
                                        message.chat.title)

        message_text = (
            "ℹ️ {}\n👤 {} ha enviado una alerta a los administradores\n\nMensaje: {}"
        ).format(chat_text, replace_pogo, text)
        for admin in bot.get_chat_administrators(chat_id):
            user = get_user(admin.user.id)
            if user is not None and user.alerts:
                bot.sendMessage(chat_id=admin.user.id,
                                text=message_text,
                                parse_mode=telegram.ParseMode.MARKDOWN,
                                disable_web_page_preview=True)
        ladmin = get_particular_admin(chat_id)
        if ladmin is not None and ladmin.admin:
            admin = get_admin_from_linked(chat_id)
            if admin is not None and admin.admin and admin.admin_bot:
                config = get_config()
                adm_bot = Bot(token=config["telegram"]["admin_token"])
                replace_pogo = support.replace(user_id,
                                               message.from_user.first_name,
                                               admin=True)
                message_text = ("ℹ️ {}\n👤 {} {}").format(
                    chat_text, replace_pogo, text)
                adm_bot.sendMessage(chat_id=admin.id,
                                    text=message_text,
                                    parse_mode=telegram.ParseMode.MARKDOWN,
                                    disable_web_page_preview=True)
            elif admin is not None and admin.admin:
                replace_pogo = support.replace(user_id,
                                               message.from_user.first_name,
                                               admin=True)
                message_text = ("ℹ️ {}\n👤 {} {}").format(
                    chat_text, replace_pogo, text)
                bot.sendMessage(chat_id=admin.id,
                                text=message_text,
                                parse_mode=telegram.ParseMode.MARKDOWN,
                                disable_web_page_preview=True)