Exemple #1
0
def welcome(update: Update, context: CallbackContext):
    chat = update.effective_chat  # type: Optional[Chat]
    args = update.effective_message.text.split(" ")
    args_option = ""

    if len(args) > 1:
        args_option = args[1].lower()
    # if no args, show current replies.
    if len(args) == 1 or args_option == "noformat":
        noformat = args and args_option == "noformat"
        pref, welcome_m, welcome_type, welc_caption = sql.get_welc_pref(chat.id)

        if welcome_m == None:
            welcome_m = welc_caption

        update.effective_message.reply_text(
            "This chat has it's welcome setting set to: `{}`.\n*The welcome message "
            "(not filling the {{}}) is:*".format(pref),
            parse_mode=ParseMode.MARKDOWN)

        if welcome_type == sql.Types.BUTTON_TEXT:
            buttons = sql.get_welc_buttons(chat.id)
            if noformat:
                welcome_m += revert_buttons(buttons)
                update.effective_message.reply_text(welcome_m)

            else:
                keyb = build_keyboard(buttons)
                keyboard = InlineKeyboardMarkup(keyb)

                send(update, context, welcome_m, keyboard, sql.DEFAULT_WELCOME)

        else:
            if noformat:
                buttons = sql.get_welc_buttons(chat.id)
                if buttons:
                    welc_caption += revert_buttons(buttons)
                ENUM_FUNC_MAP[welcome_type](chat.id, welcome_m, caption=welc_caption)

            else:
                ENUM_FUNC_MAP[welcome_type](chat.id, welcome_m, caption=welc_caption, parse_mode=ParseMode.MARKDOWN)

    elif len(args) >= 2:
        if args_option != "" and args_option in ("on", "yes"):
            sql.set_welc_preference(str(chat.id), True)
            update.effective_message.reply_text("I'll be polite!")

        elif args_option != "" and args_option in ("off", "no"):
            sql.set_welc_preference(str(chat.id), False)
            update.effective_message.reply_text("I'm sulking, not saying hello anymore.")

        else:
            # idek what you're writing, say yes or no
            update.effective_message.reply_text("I understand 'on/yes' or 'off/no' only!")
Exemple #2
0
def goodbye(update: Update, context: CallbackContext):
    chat = update.effective_chat  # type: Optional[Chat]
    args = update.effective_message.text.split(" ")
    args_option = ""
    
    if len(args) > 1:
        args_option = args[1].lower()

    if len(args) == 1 or args_option == "noformat":
        noformat = args and args_option == "noformat"
        pref, goodbye_m, goodbye_type = sql.get_gdbye_pref(chat.id)
        update.effective_message.reply_text(
            "This chat has it's goodbye setting set to: `{}`.\n*The goodbye  message "
            "(not filling the {{}}) is:*".format(pref),
            parse_mode=ParseMode.MARKDOWN)

        if goodbye_type == sql.Types.BUTTON_TEXT:
            buttons = sql.get_gdbye_buttons(chat.id)
            if noformat:
                goodbye_m += revert_buttons(buttons)
                update.effective_message.reply_text(goodbye_m)

            else:
                keyb = build_keyboard(buttons)
                keyboard = InlineKeyboardMarkup(keyb)

                send(update, context, goodbye_m, keyboard, sql.DEFAULT_GOODBYE)

        else:
            if noformat:
                ENUM_FUNC_MAP[goodbye_type](chat.id, goodbye_m)

            else:
                ENUM_FUNC_MAP[goodbye_type](chat.id, goodbye_m, parse_mode=ParseMode.MARKDOWN)

    elif len(args) >= 1:
        if args_option != "" and args_option in ("on", "yes"):
            sql.set_gdbye_preference(str(chat.id), True)
            update.effective_message.reply_text("I'll be sorry when people leave!")

        elif args_option != "" and args_option in ("off", "no"):
            sql.set_gdbye_preference(str(chat.id), False)
            update.effective_message.reply_text("They leave, they're dead to me.")

        else:
            # idek what you're writing, say yes or no
            update.effective_message.reply_text("I understand 'on/yes' or 'off/no' only!")
Exemple #3
0
def get(bot, update, notename, show_none=True, no_format=False):
    chat_id = update.effective_chat.id
    note = sql.get_note(chat_id, notename)
    message = update.effective_message  # type: Optional[Message]

    if note:
        # If we're replying to a message, reply to that message (unless it's an error)
        if message.reply_to_message:
            reply_id = message.reply_to_message.message_id
        else:
            reply_id = message.message_id

        if note.is_reply:
            if MESSAGE_DUMP:
                try:
                    bot.forward_message(chat_id=chat_id,
                                        from_chat_id=MESSAGE_DUMP,
                                        message_id=note.value)
                except BadRequest as excp:
                    if excp.message == "Message to forward not found":
                        message.reply_text(
                            "This message seems to have been lost - I'll remove it "
                            "from your notes list.")
                        sql.rm_note(chat_id, notename)
                    else:
                        raise
            else:
                try:
                    bot.forward_message(chat_id=chat_id,
                                        from_chat_id=chat_id,
                                        message_id=note.value)
                except BadRequest as excp:
                    if excp.message == "Message to forward not found":
                        message.reply_text(
                            "Looks like the original sender of this note has deleted "
                            "their message - sorry! Get your bot admin to start using a "
                            "message dump to avoid this. I'll remove this note from "
                            "your saved notes.")
                        sql.rm_note(chat_id, notename)
                    else:
                        raise
        else:
            text = note.value
            keyb = []
            parseMode = ParseMode.MARKDOWN
            buttons = sql.get_buttons(chat_id, notename)
            if no_format:
                parseMode = None
                text += revert_buttons(buttons)
            else:
                keyb = build_keyboard(buttons)
                user = update.effective_user  # type: Optional[User]
                chat = update.effective_chat  # type: Optional[Chat]
                count = chat.get_members_count()
                first_name = user.first_name or "No Name"
                mention = mention_markdown(user.id, first_name)

                if user.last_name:
                    fullname = "{} {}".format(first_name, user.last_name)
                else:
                    fullname = first_name
                if user.username:
                    username = "******" + escape_markdown(user.username)
                else:
                    username = mention
                valid_format = escape_invalid_curly_brackets(
                    text, VALID_FORMATTERS)
                text = valid_format.format(
                    first=escape_markdown(first_name),
                    last=escape_markdown(user.last_name or first_name),
                    fullname=escape_markdown(fullname),
                    username=username,
                    mention=mention,
                    count=count,
                    chatname=escape_markdown(chat.title),
                    id=user.id)

            keyboard = InlineKeyboardMarkup(keyb)

            try:
                if note.msgtype in (sql.Types.BUTTON_TEXT, sql.Types.TEXT):
                    bot.send_message(chat_id,
                                     text,
                                     reply_to_message_id=reply_id,
                                     parse_mode=parseMode,
                                     disable_web_page_preview=True,
                                     reply_markup=keyboard)
                else:
                    ENUM_FUNC_MAP[note.msgtype](chat_id,
                                                note.file,
                                                caption=text,
                                                reply_to_message_id=reply_id,
                                                parse_mode=parseMode,
                                                disable_web_page_preview=True,
                                                reply_markup=keyboard)

            except BadRequest as excp:
                if excp.message == "Entity_mention_user_invalid":
                    message.reply_text(
                        "Looks like you tried to mention someone I've never seen before. If you really "
                        "want to mention them, forward one of their messages to me, and I'll be able "
                        "to tag them!")
                elif FILE_MATCHER.match(note.value):
                    message.reply_text(
                        "This note was an incorrectly imported file from another bot - I can't use "
                        "it. If you really need it, you'll have to save it again. In "
                        "the meantime, I'll remove it from your notes list.")
                    sql.rm_note(chat_id, notename)
                else:
                    message.reply_text(
                        "This note could not be sent, as it is incorrectly formatted. Ask in "
                        "@stillmav if you can't figure out why!")
                    LOGGER.exception("Could not parse message #%s in chat %s",
                                     notename, str(chat_id))
                    LOGGER.warning("Message was: %s", str(note.value))
        return
    elif show_none:
        message.reply_text("This note doesn't exist")
Exemple #4
0
def reply_filter(update: Update, context: CallbackContext):
    chat = update.effective_chat  # type: Optional[Chat]
    message = update.effective_message  # type: Optional[Message]
    to_match = extract_text(message)
    if not to_match:
        return

    if message.reply_to_message:
        message = message.reply_to_message
    str_filter = ""

    chat_filters = sql.get_chat_triggers(chat.id)
    for keyword in chat_filters:
        pattern = r"( |^|[^\w])" + re.escape(keyword) + r"( |$|[^\w])"
        if re.search(pattern, to_match, flags=re.IGNORECASE):
            filt = sql.get_filter(chat.id, keyword)
            buttons = sql.get_buttons(chat.id, filt.keyword)
            if filt.is_sticker:
                message.reply_sticker(filt.reply)
            elif filt.is_document:
                message.reply_document(filt.reply)
            elif filt.is_image:
                if len(buttons) > 0:
                    keyb = build_keyboard(buttons)
                    keyboard = InlineKeyboardMarkup(keyb)
                    message.reply_photo(filt.reply, reply_markup=keyboard)
                else:
                    message.reply_photo(filt.reply)
            elif filt.is_audio:
                message.reply_audio(filt.reply)
            elif filt.is_voice:
                message.reply_voice(filt.reply)
            elif filt.is_video:
                message.reply_video(filt.reply)
            elif filt.has_markdown:
                keyb = build_keyboard(buttons)
                keyboard = InlineKeyboardMarkup(keyb)

                should_preview_disabled = True
                if "telegra.ph" in filt.reply or "youtu.be" in filt.reply:
                    should_preview_disabled = False

                try:
                    user = update.effective_user  # type: Optional[User]
                    chat = update.effective_chat  # type: Optional[Chat]
                    count = chat.get_members_count()
                    first_name = user.first_name or "No Name"
                    mention = mention_markdown(user.id, first_name)

                    if user.last_name:
                        fullname = "{} {}".format(first_name, user.last_name)
                    else:
                        fullname = first_name
                    if user.username:
                        username = "******" + escape_markdown(user.username)
                    else:
                        username = mention
                    valid_format = escape_invalid_curly_brackets(
                        filt.reply, VALID_FORMATTERS)
                    filt.reply = valid_format.format(
                        first=escape_markdown(first_name),
                        last=escape_markdown(user.last_name or first_name),
                        fullname=escape_markdown(fullname),
                        username=username,
                        mention=mention,
                        count=count,
                        chatname=escape_markdown(chat.title),
                        id=user.id)
                    message.reply_text(
                        str_filter + "\n" + filt.reply,
                        parse_mode=ParseMode.MARKDOWN,
                        disable_web_page_preview=should_preview_disabled,
                        reply_markup=keyboard)
                except BadRequest as excp:
                    if excp.message == "Unsupported url protocol":
                        message.reply_text(
                            "You seem to be trying to use an unsupported url protocol. Telegram "
                            "doesn't support buttons for some protocols, such as tg://. Please try "
                            "again, or ask @stillmav for help.")
                    elif excp.message == "Reply message not found":
                        context.bot.send_message(chat.id,
                                                 filt.reply,
                                                 parse_mode=ParseMode.MARKDOWN,
                                                 disable_web_page_preview=True,
                                                 reply_markup=keyboard)
                    else:
                        message.reply_text(
                            "This note could not be sent, as it is incorrectly formatted. Ask in "
                            "@stillmav if you can't figure out why!")
                        LOGGER.warning("Message %s could not be parsed",
                                       str(filt.reply))
                        LOGGER.exception(
                            "Could not parse filter %s in chat %s",
                            str(filt.keyword), str(chat.id))

            else:
                # LEGACY - all new filters will have has_markdown set to True.
                message.reply_text(str_filter + "\n" + filt.reply)
            break
Exemple #5
0
def left_member(update: Update, context: CallbackContext):
    chat = update.effective_chat  # type: Optional[Chat]
    should_goodbye, cust_goodbye, goodbye_type = sql.get_gdbye_pref(chat.id)
    cust_goodbye = markdown_to_html(cust_goodbye)

    if should_goodbye:
        left_mem = update.effective_message.left_chat_member
        gban_checks = get_gbanned_user(left_mem.id)
        spamwatch_banned = client.get_ban(left_mem.id)
        if left_mem:
            # Ignore bot being kicked
            if left_mem.id == context.bot.id:
                return

            ### BAN CHECKERS ###
            # Ignore gbanned users
            if gban_checks:
                return

            # Ignore spamwatch banned users
            if spamwatch_banned:
                return

            # Give the owner a special goodbye
            if left_mem.id == OWNER_ID:
                update.effective_message.reply_text("RIP Master")
                return

            # if media goodbye, use appropriate function for it
            if goodbye_type != sql.Types.TEXT and goodbye_type != sql.Types.BUTTON_TEXT:
                ENUM_FUNC_MAP[goodbye_type](chat.id, cust_goodbye)
                return

            first_name = left_mem.first_name or "PersonWithNoName"  # edge case of empty name - occurs for some bugs.
            if cust_goodbye:
                if left_mem.last_name:
                    fullname = "{} {}".format(first_name, left_mem.last_name)
                else:
                    fullname = first_name
                count = chat.get_members_count()
                mention = mention_html(left_mem.id, first_name)
                if left_mem.username:
                    username = "******" + escape(left_mem.username)
                else:
                    username = mention

                valid_format = escape_invalid_curly_brackets(cust_goodbye, VALID_WELCOME_FORMATTERS)
                res = valid_format.format(first=escape(first_name),
                                          last=escape(left_mem.last_name or first_name),
                                          fullname=escape(fullname), username=username, mention=mention,
                                          count=count, chatname=escape(chat.title), id=left_mem.id)
                buttons = sql.get_gdbye_buttons(chat.id)
                keyb = build_keyboard(buttons)

            else:
                res = sql.DEFAULT_GOODBYE
                keyb = []

            keyboard = InlineKeyboardMarkup(keyb)

            send(update, context, res, keyboard, sql.DEFAULT_GOODBYE)
Exemple #6
0
def new_member(update: Update, context: CallbackContext):
    chat = update.effective_chat  # type: Optional[Chat]
    user = update.effective_user  # type: Optional[User]
    msg = update.effective_message # type: Optional[Message]
    chat_name = chat.title or chat.first or chat.username # type: Optional:[chat name]
    should_welc, cust_welcome, welc_type, welc_caption = sql.get_welc_pref(chat.id)
    welc_mutes = sql.welcome_mutes(chat.id)
    human_checks = sql.get_human_checks(user.id, chat.id)
    prev_welc = sql.get_clean_pref(chat.id)
    media = False
    no_mute = False

    try:
        for mem in msg.new_chat_members:
            user_id = mem.id
    except:
        LOGGER.log("User being added or no ID found for user.")
    
    gban_checks = get_gbanned_user(user_id)
    
    join_log = sql.get_join_event_pref(chat.id)
    join_members = msg.new_chat_members

    if should_welc:
        sent = None
        new_members = msg.new_chat_members
        for new_mem in new_members:
            spamwatch_banned = client.get_ban(new_mem.id)
            user_add = context.bot.get_chat_member(chat.id, user.id)

            # edge case of empty name - occurs for some bugs.
            first_name = new_mem.first_name or "PersonWithNoName"
            # Give the owner a special welcome
            log = ""
            if join_log == True:
                log += "<b>{}:</b>" \
                       "\n#WELCOME" \
                       "\n<b>A new user has joined:</b>" \
                       "\n<b>• User:</b> {}" \
                       "\n<b>• ID:</b> <code>{}</code>".format(escape(chat.title), mention_html(mem.id, mem.first_name), mem.id)
                if user.id != mem.id:
                    log += "\n<b>• Added by:</b> {}".format(mention_html(user.id, user.first_name))

            if new_mem.id == OWNER_ID:
                update.effective_message.reply_text("Master is in the houseeee, let's get this party started!")
                continue

            #### BAN CHECKERS ####
            # Ignore welc messages for gbanned users
            if gban_checks:
                continue

            # Ignore welc messages for SpamWatch banned users
            if spamwatch_banned:
                continue

            # Make bot greet admins
            elif new_mem.id == context.bot.id:
                update.effective_message.reply_text("Hey {}, I'm {}! Thank you for adding me to {}" 
                " and be sure to check /help in PM for more commands and tricks!".format(user.first_name, 
                                                                                         context.bot.first_name, chat_name))

            else:
                # If welcome message is media, send with appropriate function
                if welc_type != sql.Types.TEXT and welc_type != sql.Types.BUTTON_TEXT:
                    if welc_type == sql.Types.PHOTO:
                        media = True
                        type = 'photo'
                        if welc_caption:
                            res = format_welcome_message(welc_caption, first_name, chat, new_mem)
                            buttons = sql.get_welc_buttons(chat.id)
                            keyb = build_keyboard(buttons)

                        keyboard = InlineKeyboardMarkup(keyb)

                        sent = send(update, context, cust_welcome, keyboard,
                                    sql.DEFAULT_WELCOME.format(first=first_name, chatname=chat_name), res, type)

                        if sent:
                            sql.set_clean_welcome(chat.id, sent.message_id)
                    elif welc_type == sql.Types.VIDEO:
                        media = True
                        type = 'video'
                        if welc_caption:
                            res = format_welcome_message(welc_caption, first_name, chat, new_mem)
                            buttons = sql.get_welc_buttons(chat.id)
                            keyb = build_keyboard(buttons)

                        keyboard = InlineKeyboardMarkup(keyb)

                        sent = send(update, context, cust_welcome, keyboard,
                                    sql.DEFAULT_WELCOME.format(first=first_name, chatname=chat_name), res, type)

                        if sent:
                            sql.set_clean_welcome(chat.id, sent.message_id)
                    elif welc_type == sql.Types.DOCUMENT:
                        media = True
                        type = 'document'
                        if welc_caption:
                            res = format_welcome_message(
                                welc_caption, first_name, chat, new_mem)
                            buttons = sql.get_welc_buttons(chat.id)
                            keyb = build_keyboard(buttons)

                        keyboard = InlineKeyboardMarkup(keyb)

                        sent = send(update, context, cust_welcome, keyboard,
                                    sql.DEFAULT_WELCOME.format(first=first_name, chatname=chat_name), res, type)

                        if sent:
                            sql.set_clean_welcome(chat.id, sent.message_id)
                    else:
                        media = True
                        ENUM_FUNC_MAP[welc_type](chat.id, cust_welcome)

                # else, move on
                if media == False:
                    if welc_caption:
                        res = format_welcome_message(welc_caption, first_name, chat, new_mem)
                        buttons = sql.get_welc_buttons(chat.id)
                        keyb = build_keyboard(buttons)
                    else:
                        res = sql.DEFAULT_WELCOME.format(first=first_name, chatname=chat_name)
                        keyb = []

                    keyboard = InlineKeyboardMarkup(keyb)

                    sent = send(update, context, res, keyboard,
                                sql.DEFAULT_WELCOME.format(first=first_name, chatname=chat_name))  # type: Optional[Message]
                #User exception from mutes:
                if is_user_ban_protected(chat, new_mem.id, chat.get_member(new_mem.id)) or human_checks or gban_checks:
                    no_mute = True

                if not no_mute:
                    #Join welcome: soft mute
                    if welc_mutes == "soft":
                        context.bot.restrict_chat_member(chat.id, new_mem.id, WELCOME_PERMISSIONS_SOFT,
                                                        until_date=(int(time.time() + 24 * 60 * 60)))
                    #Join welcome: strong mute
                    if welc_mutes == "strong":
                        mute_message = msg.reply_text("Hey {} (`{}`),\nClick the button below to prove you're human:".format(new_mem.first_name, 
                                                                                                                            new_mem.id),
                            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton(text="Tap here to speak", 
                            callback_data="user_join_({})".format(new_mem.id))]]), parse_mode=ParseMode.MARKDOWN)
                        context.bot.restrict_chat_member(chat.id, new_mem.id, WELCOME_PERMISSIONS_STRONG)

                    #Join welcome: aggressive mute
                    elif welc_mutes == "aggressive":
                        mute_message = msg.reply_text("Hey {} (`{}`),\nClick the button below to prove you're human:".format(new_mem.first_name, 
                                                                                                                            new_mem.id), 
                            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton(text="Tap here to speak",
                            callback_data="user_join_({})".format(new_mem.id))]]), parse_mode=ParseMode.MARKDOWN)
                        context.bot.restrict_chat_member(chat.id, new_mem.id, WELCOME_PERMISSIONS_AGGRESSIVE)
            delete_join(update, context)

            if prev_welc:
                try:
                    context.bot.delete_message(chat.id, prev_welc)
                except BadRequest as excp:
                    pass

            if sent:
                sql.set_clean_welcome(chat.id, sent.message_id)

            if not human_checks and welc_mutes == "aggressive":
                t = threading.Thread(target=aggr_mute_check, args=(
                    context.bot, chat, mute_message.message_id, new_mem.id,))
                t.start()

            return log

    return ""