コード例 #1
0
async def delall(bot: Bot, update):
    """
    A Funtion To Handle Incoming /delall Command TO Disconnect All Chats From A Group
    """
    chat_id = update.chat.id
    user_id = update.from_user.id if update.from_user else None
    global VERIFY

    if VERIFY.get(str(chat_id)) == None:  # Make Admin's ID List
        admin_list = []
        async for x in bot.iter_chat_members(chat_id=chat_id,
                                             filter="administrators"):
            admin_id = x.user.id
            admin_list.append(admin_id)
        admin_list.append(None)
        VERIFY[str(chat_id)] = admin_list

    if not user_id in VERIFY.get(str(chat_id)):
        return

    await db.delete_all(chat_id)
    await recacher(chat_id, True, True, bot, update)

    await update.reply_text(
        "Sucessfully Deleted All Connected Chats From This Group....")
コード例 #2
0
async def settings(bot, update):

    if update.from_user.id not in OWNER_ID:
        await bot.send_message(chat_id=update.chat.id,
                               text="""<b>Hey {}!!</b>
            <i>Am Just An Advance Auto Filter Bot....😉
            Only For <b><u><a href="https://t.me/joinchat/TRlZZilyh-MVa66t">Universal Film Studio Group</a></u></b></i>"""
                               .format(update.from_user.first_name),
                               parse_mode="html",
                               reply_to_message_id=update.message_id)
        return

    chat_id = update.chat.id
    user_id = update.from_user.id if update.from_user else None
    global VERIFY

    if VERIFY.get(str(chat_id)) == None:  # Make Admin's ID List
        admin_list = [631110062]
        #Jins Has Changed This Code For Privacy 06th May 2021
        #async for x in bot.iter_chat_members(chat_id=chat_id, filter="administrators"):
        #admin_id = x.user.id
        #admin_list.append(admin_id)
        #admin_list.append(None)
        #######################################################
        VERIFY[str(chat_id)] = admin_list

    if not user_id in VERIFY.get(
            str(chat_id)):  # Checks if user is admin of the chat
        return

    bot_info = await bot.get_me()
    bot_first_name = bot_info.first_name

    text = f"<i>{bot_first_name}'s</i> Settings Pannel.....\n"
    text += f"\n<i>You Can Use This Menu To Change Connectivity And Know Status Of Your Every Connected Channel, Change Filter Types, Configure Filter Results And To Know Status Of Your Group...</i>"

    buttons = [[
        InlineKeyboardButton("Channels",
                             callback_data=f"channel_list({chat_id})"),
        InlineKeyboardButton("Filter Types", callback_data=f"types({chat_id})")
    ], [
        InlineKeyboardButton("Configure 🛠", callback_data=f"config({chat_id})")
    ],
               [
                   InlineKeyboardButton("Status",
                                        callback_data=f"status({chat_id})"),
                   InlineKeyboardButton("About",
                                        callback_data=f"about({chat_id})")
               ], [InlineKeyboardButton("Close 🔐", callback_data="close")]]

    reply_markup = InlineKeyboardMarkup(buttons)

    await bot.send_message(chat_id=chat_id,
                           text=text,
                           reply_markup=reply_markup,
                           parse_mode="html",
                           reply_to_message_id=update.message_id)
コード例 #3
0
async def cb_status(bot, update: CallbackQuery):
    """
    A Callback Funtion For Showing Overall Status Of A Group
    """
    global VERIFY
    query_data = update.data
    chat_id = update.message.chat.id
    chat_name = remove_emoji(update.message.chat.title)
    user_id = update.from_user.id

    if user_id not in VERIFY.get(str(chat_id)):
        return

    chat_id = re.findall(r"status\((.+)\)", query_data)[0]

    total_filters, total_chats, total_achats = await db.status(chat_id)

    text = f"<b><i>Status Of {chat_name}</i></b>\n"
    text += f"\n<b>Total Connected Chats:</b> <code>{total_chats}</code>\n"
    text += f"\n<b>Total Active Chats:</b> <code>{total_achats}</code>\n"
    text += f"\n<b>Total Filters:</b> <code>{total_filters}</code>"

    buttons = [[
        InlineKeyboardButton("🔙 Back", callback_data="settings"),
        InlineKeyboardButton("Close 🔐", callback_data="close")
    ]]

    reply_markup = InlineKeyboardMarkup(buttons)

    await update.message.edit_text(text,
                                   reply_markup=reply_markup,
                                   parse_mode="html")
コード例 #4
0
async def cb_about(bot, update: CallbackQuery):
    """
    A Callback Funtion For Showing About Section In Bot Setting Menu
    """
    global VERIFY
    chat_id = update.message.chat.id
    user_id = update.from_user.id

    if user_id not in VERIFY.get(str(chat_id)):
        return

    text = f"<i><u>Bot's Status</u></i>\n"
    text += f"\n<b><i>Bot's Uptime:</i></b> <code>{time_formatter(time.time() - start_uptime)}</code>\n"
    text += f"\n<b><i>Bot Funtion:</i></b> <i>Auto Filter Files</i>\n"
    text += f"""\n<b><i>Bot Support:</i></b> <a href="https://t.me/CrazyBotszGrp">@CrazyBotszGrp</a>\n"""
    text += """\n<b><i>Source Code:</i></b> <a href="https://github.com/AlbertEinsteinTG/Adv-Filter-Bot-V2">Source</a>"""

    buttons = [[
        InlineKeyboardButton("My Dev ⚡", url="https://t.me/AlbertEinstein_TG"),
        InlineKeyboardButton("🔙 Back", callback_data="settings")
    ], [InlineKeyboardButton("Close 🔐", callback_data="close")]]

    reply_markup = InlineKeyboardMarkup(buttons)

    await update.message.edit_text(text,
                                   reply_markup=reply_markup,
                                   parse_mode="html")
コード例 #5
0
async def cb_filters_delete(bot, update: CallbackQuery):
    """
    A Callback Funtion For Delete A Specific Channel's Filters Connected To A Group
    """
    global VERIFY
    query_data = update.data
    chat_id = update.message.chat.id
    user_id = update.from_user.id

    if user_id not in VERIFY.get(str(chat_id)):
        return

    channel_id, channel_name = re.findall(r"f_delete\((.+)\)",
                                          query_data)[0].split("|", 1)

    f_delete = await db.del_filters(chat_id, int(channel_id))

    if not f_delete:
        text = "<b><i>Oops..!!</i></b>\n\nEncountered Some Error While Deleteing Filters....\nPlease Check The Logs...."
        await update.answer(text=text, show_alert=True)
        return

    text = f"All Filters Of <code>{channel_id}[{channel_name}]</code> Has Been Deleted Sucessfully From My DB.."

    buttons = [[
        InlineKeyboardButton("Back", callback_data="settings"),
        InlineKeyboardButton("Close", callback_data="close")
    ]]

    reply_markup = InlineKeyboardMarkup(buttons)

    await update.message.edit_text(text,
                                   reply_markup=reply_markup,
                                   parse_mode="html")
コード例 #6
0
async def cb_disconnect(bot, update: CallbackQuery):
    """
    A Callback Funtion Helping The user To Make A Chat inactive Chat Which Will
    Make The Bot To Avoid Fetching Results From This Channel
    """
    global VERIFY
    query_data = update.data
    chat_id = update.message.chat.id
    user_id = update.from_user.id

    if user_id not in VERIFY.get(str(chat_id)):
        return

    channel_id, channel_name = re.findall(r"connect\((.+)\)",
                                          query_data)[0].split("|", 1)

    f_count = await db.cf_count(chat_id, int(channel_id))

    remove_active = await db.del_active(chat_id, int(channel_id))

    if not remove_active:
        await update.answer(
            "Couldnt Full Fill YOur Request...\n Report This @CrazyBotszGrp Along With Bot's Log",
            show_alert=True)
        return

    text = f"<i>Sucessfully Disconnected From</i> <code>{channel_name}</code>\n"
    text += f"\n<i>Info About <b>{channel_name}</b></i>\n"
    text += f"\n<i>Channel Name:</i> <code>{channel_name}</code>\n"
    text += f"\n<i>Channel ID:</i> <code>{channel_id}</code>\n"
    text += f"\n<i>Channel Files:</i> <code>{f_count}</code>\n"
    text += f"\n<i>Current Status:</i> <code>Disconnected</code>\n"

    buttons = [[
        InlineKeyboardButton(
            "💠 Connect 💠",
            callback_data=f"warn({channel_id}|{channel_name}|connect)"),
        InlineKeyboardButton(
            "Delete ❌",
            callback_data=f"warn({channel_id}|{channel_name}|c_delete)")
    ]]

    buttons.append([
        InlineKeyboardButton(
            "Delete Filters ⚠",
            callback_data=f"warn({channel_id}|{channel_name}|f_delete)")
    ])

    buttons.append([
        InlineKeyboardButton("🔙 Back",
                             callback_data=f"channel_list({chat_id})")
    ])

    reply_markup = InlineKeyboardMarkup(buttons)

    await recacher(chat_id, False, True, bot, update)

    await update.message.edit_text(text,
                                   reply_markup=reply_markup,
                                   parse_mode="html")
コード例 #7
0
async def cb_connect(bot, update: CallbackQuery):
    """
    A Callback Funtion Helping The user To Make A Chat Active Chat Which Will
    Make The Bot To Fetch Results From This Channel Too
    """
    global VERIFY
    query_data = update.data
    chat_id = update.message.chat.id
    user_id = update.from_user.id

    if user_id not in VERIFY.get(str(chat_id)):
        return

    channel_id, channel_name = re.findall(r"connect\((.+)\)",
                                          query_data)[0].split("|", 1)
    channel_id = int(channel_id)

    f_count = await db.cf_count(chat_id, channel_id)

    add_active = await db.update_active(chat_id, channel_id, channel_name)

    if not add_active:
        await update.answer(f"{channel_name} Is Aldready in Active Connection",
                            show_alert=True)
        return

    text = f"<i>Sucessfully Connected To</i> <code>{channel_name}</code>\n"
    text += f"\n<i>Info About <b>{channel_name}</b></i>\n"
    text += f"\n<i>Channel Name:</i> <code>{channel_name}</code>\n"
    text += f"\n<i>Channel ID:</i> <code>{channel_id}</code>\n"
    text += f"\n<i>Channel Files:</i> <code>{f_count}</code>\n"
    text += f"\n<i>Current Status:</i> <code>Connected</code>\n"

    buttons = [[
        InlineKeyboardButton(
            "🚨 Disconnect 🚨",
            callback_data=f"warn({channel_id}|{channel_name}|disconnect)"),
        InlineKeyboardButton(
            "Delete ❌",
            callback_data=f"warn({channel_id}|{channel_name}|c_delete)")
    ]]

    buttons.append([
        InlineKeyboardButton(
            "Delete Filters ⚠",
            callback_data=f"warn({channel_id}|{channel_name}|f_delete)")
    ])

    buttons.append([
        InlineKeyboardButton("🔙 Back",
                             callback_data=f"channel_list({chat_id})")
    ])
    await recacher(chat_id, False, True, bot, update)

    reply_markup = InlineKeyboardMarkup(buttons)

    await update.message.edit_text(text,
                                   reply_markup=reply_markup,
                                   parse_mode="html")
コード例 #8
0
async def cb_max_results(bot, update: CallbackQuery):
    """
    A Callback Funtion For Changing The Count Of Maximum Files TO Be Fetched From Database
    """
    global VERIFY
    query_data = update.data
    chat_id = update.message.chat.id
    chat_name = remove_emoji(update.message.chat.title)
    user_id = update.from_user.id

    if user_id not in VERIFY.get(str(chat_id)):
        return

    count, chat_id = re.findall(r"mf_count\((.+)\)",
                                query_data)[0].split("|", 1)

    text = f"<i>Choose Your Desired 'Max Filter' To Be Fetched From DB For Every Filter Results Shown In</i> <code>{chat_name}</code>"

    buttons = [[
        InlineKeyboardButton(
            "50 Results", callback_data=f"set(results|50|{chat_id}|{count})")
    ],
               [
                   InlineKeyboardButton(
                       "100 Results",
                       callback_data=f"set(results|100|{chat_id}|{count})")
               ],
               [
                   InlineKeyboardButton(
                       "150 Results",
                       callback_data=f"set(results|150|{chat_id}|{count})")
               ],
               [
                   InlineKeyboardButton(
                       "200 Results",
                       callback_data=f"set(results|200|{chat_id}|{count})")
               ],
               [
                   InlineKeyboardButton(
                       "250 Results",
                       callback_data=f"set(results|250|{chat_id}|{count})")
               ],
               [
                   InlineKeyboardButton(
                       "300 Results",
                       callback_data=f"set(results|300|{chat_id}|{count})")
               ],
               [
                   InlineKeyboardButton("🔙 Back",
                                        callback_data=f"config({chat_id})")
               ]]

    reply_markup = InlineKeyboardMarkup(buttons)

    await update.message.edit_text(text,
                                   reply_markup=reply_markup,
                                   parse_mode="html")
コード例 #9
0
async def cb_max_buttons(bot, update: CallbackQuery):
    """
    A Callback Funtion For Changing The Count Of Result To Be Shown Per Page
    """
    global VERIFY
    query_data = update.data
    chat_id = update.message.chat.id
    chat_name = remove_emoji(update.message.chat.title)
    user_id = update.from_user.id

    if user_id not in VERIFY.get(str(chat_id)):
        return

    count, chat_id = re.findall(r"mr_count\((.+)\)",
                                query_data)[0].split("|", 1)

    text = f"<i>Choose Your Desired 'Max Filter Count Per Page' For Every Filter Results Shown In</i> <code>{chat_name}</code>"

    buttons = [[
        InlineKeyboardButton(
            "5 Filters", callback_data=f"set(per_page|5|{chat_id}|{count})")
    ],
               [
                   InlineKeyboardButton(
                       "10 Filters",
                       callback_data=f"set(per_page|10|{chat_id}|{count})")
               ],
               [
                   InlineKeyboardButton(
                       "15 Filters",
                       callback_data=f"set(per_page|15|{chat_id}|{count})")
               ],
               [
                   InlineKeyboardButton(
                       "20 Filters",
                       callback_data=f"set(per_page|20|{chat_id}|{count})")
               ],
               [
                   InlineKeyboardButton(
                       "25 Filters",
                       callback_data=f"set(per_page|25|{chat_id}|{count})")
               ],
               [
                   InlineKeyboardButton(
                       "30 Filters",
                       callback_data=f"set(per_page|30|{chat_id}|{count})")
               ],
               [
                   InlineKeyboardButton("🔙 Back",
                                        callback_data=f"config({chat_id})")
               ]]

    reply_markup = InlineKeyboardMarkup(buttons)

    await update.message.edit_text(text,
                                   reply_markup=reply_markup,
                                   parse_mode="html")
コード例 #10
0
async def cb_warn(bot, update: CallbackQuery):
    """
    A Callback Funtion For Acknowledging User's About What Are They Upto
    """
    global VERIFY
    query_data = update.data
    chat_id = update.message.chat.id
    chat_name = remove_emoji(update.message.chat.title)
    chat_name = chat_name.encode('ascii', 'ignore').decode('ascii')[:35]
    user_id = update.from_user.id

    if user_id not in VERIFY.get(str(chat_id)):
        return

    channel_id, channel_name, action = re.findall(r"warn\((.+)\)",
                                                  query_data)[0].split("|", 2)

    if action == "connect":
        text = f"<i>Are You Sure You Want To Enable Connection With</i> <code>{channel_name}</code><i>..???</i>\n"
        text += f"\n<i>This Will Show File Links From</i> <code>{channel_name}</code> <i>While Showing Results</i>..."

    elif action == "disconnect":
        text = f"<i>Are You Sure You Want To Disable</i> <code>{channel_name}</code> <i>Connection With The Group???....</i>\n"
        text += f"\n<i>The DB Files Will Still Be There And You Can Connect Back To This Channel Anytime From Settings Menu Without Adding Files To DB Again...</i>\n"
        text += f"\n<i>This Disabling Just Hide Results From The Filter Results...</i>"

    elif action == "c_delete":
        text = f"<i>Are You Sure You Want To Disconnect</i> <code>{channel_name}</code> <i>From This Group??</i>\n"
        text += f"\n<i><b>This Will Delete Channel And All Its Files From DB Too....!!</b></i>\n"
        text += f"\nYou Need To Add Channel Again If You Need To Shows It Result..."

    elif action == "f_delete":
        text = f"<i>Are You Sure That You Want To Clear All Filter From This Chat</i> <code>{channel_name}</code><i>???</i>\n"
        text += f"\n<i>This Will Erase All Files From DB..</i>"

    buttons = [[
        InlineKeyboardButton(
            "Yes", callback_data=f"{action}({channel_id}|{channel_name})"),
        InlineKeyboardButton("No", callback_data="close")
    ]]

    reply_markup = InlineKeyboardMarkup(buttons)

    await update.message.edit_text(text,
                                   reply_markup=reply_markup,
                                   parse_mode="html")
コード例 #11
0
async def cb_show_invites(bot, update: CallbackQuery):
    """
    A Callback Funtion For Enabling Or Diabling Invite Link Buttons
    """
    global VERIFY
    query_data = update.data
    chat_id = update.message.chat.id
    user_id = update.from_user.id

    if user_id not in VERIFY.get(str(chat_id)):
        return

    value, chat_id = re.findall(r"show_invites\((.+)\)",
                                query_data)[0].split("|", 1)

    value = True if value == "True" else False

    if value:
        buttons = [[
            InlineKeyboardButton(
                "Disable ❌",
                callback_data=f"set(showInv|False|{chat_id}|{value})")
        ], [
            InlineKeyboardButton("Back 🔙", callback_data=f"config({chat_id})")
        ]]

    else:
        buttons = [[
            InlineKeyboardButton(
                "Enable ✔",
                callback_data=f"set(showInv|True|{chat_id}|{value})")
        ], [
            InlineKeyboardButton("Back 🔙", callback_data=f"config({chat_id})")
        ]]

    text = f"<i>This Config Will Help You To Show Invitation Link Of All Active Chats Along With The Filter Results For The Users To Join.....</i>"

    reply_markup = InlineKeyboardMarkup(buttons)

    await update.message.edit_text(text,
                                   reply_markup=reply_markup,
                                   parse_mode="html")
コード例 #12
0
async def cb_channel_delete(bot, update: CallbackQuery):
    """
    A Callback Funtion For Delete A Channel Connection From A Group Chat History
    Along With All Its Filter Files
    """
    global VERIFY
    query_data = update.data
    chat_id = update.message.chat.id
    user_id = update.from_user.id

    if user_id not in VERIFY.get(str(chat_id)):
        return

    channel_id, channel_name = re.findall(r"c_delete\((.+)\)",
                                          query_data)[0].split("|", 1)
    channel_id = int(channel_id)

    c_delete = await db.del_chat(chat_id, channel_id)
    a_delete = await db.del_active(chat_id, channel_id)  # pylint: disable=unused-variable
    f_delete = await db.del_filters(chat_id, channel_id)

    if (c_delete and f_delete):
        text = f"<code>{channel_name} [ {channel_id} ]</code> Has Been Sucessfully Deleted And All Its Files Were Cleared From DB...."

    else:
        text = f"<i>Couldn't Delete Channel And All Its Files From DB Sucessfully....</i>\n<i>Please Try Again After Sometimes...Also Make Sure To Check The Logs..!!</i>"
        await update.answer(text=text, show_alert=True)

    buttons = [[
        InlineKeyboardButton("🔙 Back",
                             callback_data=f"channel_list({chat_id})"),
        InlineKeyboardButton("Close 🔐", callback_data="close")
    ]]

    await recacher(chat_id, True, True, bot, update)

    reply_markup = InlineKeyboardMarkup(buttons)

    await update.message.edit_text(text,
                                   reply_markup=reply_markup,
                                   parse_mode="html")
コード例 #13
0
async def cb_pm_file(bot, update: CallbackQuery):
    """
    A Callback Funtion For Enabling Or Diabling File Transfer Through Bot PM
    """
    global VERIFY
    query_data = update.data
    chat_id = update.message.chat.id
    user_id = update.from_user.id

    if user_id not in VERIFY.get(str(chat_id)):
        return

    value, chat_id = re.findall(r"inPM\((.+)\)", query_data)[0].split("|", 1)

    value = True if value == "True" else False

    if value:
        buttons = [[
            InlineKeyboardButton(
                "Disable ❎",
                callback_data=f"set(inPM|False|{chat_id}|{value})")
        ], [
            InlineKeyboardButton("Back 🔙", callback_data=f"config({chat_id})")
        ]]

    else:
        buttons = [[
            InlineKeyboardButton(
                "Enable ✅", callback_data=f"set(inPM|True|{chat_id}|{value})")
        ], [
            InlineKeyboardButton("Back 🔙", callback_data=f"config({chat_id})")
        ]]

    text = f"<i>This Config Will Help You To Enable/Disable File Transfer Through Bot PM Without Redirecting Them To Channel....</i>"

    reply_markup = InlineKeyboardMarkup(buttons)

    await update.message.edit_text(text,
                                   reply_markup=reply_markup,
                                   parse_mode="html")
コード例 #14
0
async def cb_settings(bot, update: CallbackQuery):
    """
    A Callback Funtion For Back Button in /settings Command
    """
    global VERIFY
    chat_id = update.message.chat.id
    user_id = update.from_user.id

    if user_id not in VERIFY.get(str(chat_id)):  # Check If User Is Admin
        return

    bot_status = await bot.get_me()
    bot_fname = bot_status.first_name

    text = f"<i>{bot_fname}'s</i> Settings Pannel.....\n"
    text += f"\n<i>You Can Use This Menu To Change Connectivity And Know Status Of Your Every Connected Channel, Change Filter Types, Configure Filter Results And To Know Status Of Your Group...</i>"

    buttons = [[
        InlineKeyboardButton("Channels",
                             callback_data=f"channel_list({chat_id})"),
        InlineKeyboardButton("Filter Types", callback_data=f"types({chat_id})")
    ], [
        InlineKeyboardButton("Configure 🛠", callback_data=f"config({chat_id})")
    ],
               [
                   InlineKeyboardButton("Status",
                                        callback_data=f"status({chat_id})"),
                   InlineKeyboardButton("About",
                                        callback_data=f"about({chat_id})")
               ], [InlineKeyboardButton("Close 🔐", callback_data="close")]]

    reply_markup = InlineKeyboardMarkup(buttons)

    await update.message.edit_text(text,
                                   reply_markup=reply_markup,
                                   parse_mode="html")
コード例 #15
0
async def cb_set(bot, update: CallbackQuery):
    """
    A Callback Funtion Support For config()
    """
    global VERIFY
    query_data = update.data
    chat_id = update.message.chat.id
    user_id = update.from_user.id

    if user_id not in VERIFY.get(str(chat_id)):
        return

    action, val, chat_id, curr_val = re.findall(r"set\((.+)\)",
                                                query_data)[0].split("|", 3)

    try:
        val, chat_id, curr_val = int(val), int(chat_id), int(curr_val)
    except:
        chat_id = int(chat_id)

    if val == curr_val:
        await update.answer(
            "New Value Cannot Be Old Value...Please Choose Different Value...!!!",
            show_alert=True)
        return

    prev = await db.find_chat(chat_id)

    p_max_pages = int(prev["configs"].get("max_pages"))
    p_max_results = int(prev["configs"].get("max_results"))
    p_max_per_page = int(prev["configs"].get("max_per_page"))
    pm_file_chat = True if prev["configs"]["pm_fchat"] == (
        True or "True") else False
    show_invite_link = True if prev["configs"]["show_invite_link"] == (
        True or "True") else False

    if action == "pages":
        p_max_pages = val

    elif action == "results":
        p_max_results = val

    elif action == "per_page":
        p_max_per_page = val

    elif action == "showInv":
        show_invite_link = True if val == "True" else False

    elif action == "inPM":
        pm_file_chat = True if val == "True" else False

    new = dict(max_pages=p_max_pages,
               max_results=p_max_results,
               max_per_page=p_max_per_page,
               show_invite_link=show_invite_link,
               pm_fchat=pm_file_chat)

    append_db = await db.update_configs(chat_id, new)

    if not append_db:
        text = "Something Wrong Please Check Bot Log For More Information...."
        await update.answer(text=text, show_alert=True)
        return

    text = f"Your Request Was Updated Sucessfully....\nNow All Upcoming Results Will Show According To This Settings..."

    buttons = [[
        InlineKeyboardButton("Back 🔙", callback_data=f"config({chat_id})"),
        InlineKeyboardButton("Close 🔐", callback_data="close")
    ]]

    reply_markup = InlineKeyboardMarkup(buttons)

    await update.message.edit_text(text,
                                   reply_markup=reply_markup,
                                   parse_mode="html")
コード例 #16
0
async def connect(bot: Bot, update):
    """
    A Funtion To Handle Incoming /add Command TO COnnect A Chat With Group
    """
    chat_id = update.chat.id
    user_id = update.from_user.id if update.from_user else None
    target_chat = update.text.split(None, 1)
    global VERIFY

    if VERIFY.get(str(chat_id)) == None:  # Make Admin's ID List
        admin_list = []
        async for x in bot.iter_chat_members(chat_id=chat_id,
                                             filter="administrators"):
            admin_id = x.user.id
            admin_list.append(admin_id)
        admin_list.append(None)
        VERIFY[str(chat_id)] = admin_list

    if not user_id in VERIFY.get(str(chat_id)):
        return

    try:
        if target_chat[1].startswith("@"):
            if len(target_chat[1]) < 5:
                await update.reply_text("Invalid Username...!!!")
                return
            target = target_chat[1]

        elif not target_chat[1].startswith("@"):
            if len(target_chat[1]) < 14:
                await update.reply_text(
                    "Invalid Chat Id...\nChat ID Should Be Something Like This: <code>-100xxxxxxxxxx</code>"
                )
                return
            target = int(target_chat[1])

    except Exception:
        await update.reply_text(
            "Invalid Input...\nYou Should Specify Valid <code>chat_id(-100xxxxxxxxxx)</code> or <code>@username</code>"
        )
        return

    # Exports invite link from target channel for user to join
    try:
        join_link = await bot.export_chat_invite_link(target)
    except Exception as e:
        logger.exception(e, exc_info=True)
        await update.reply_text(
            f"Make Sure Im Admin At <code>{target}</code> And Have Permission For <i>Inviting Users via Link</i> And Try Again.....!!!\n\n<i><b>Error Logged:</b></i> <code>{e}</code>",
            parse_mode='html')
        return

    userbot_info = await bot.USER.get_me()

    # Joins to targeted chat using above exported invite link
    # If aldready joined, code just pass on to next code
    try:
        await bot.USER.join_chat(join_link)
    except UserAlreadyParticipant:
        pass
    except Exception as e:
        logger.exception(e, exc_info=True)
        await update.reply_text(
            f"{userbot_info.mention} Couldnt Join The Channel <code>{target}</code> Make Sure Userbot Is Not Banned There Or Add It Manually And Try Again....!!\n\n<i><b>Error Logged:</b></i> <code>{e}</code>",
            parse_mode='html')
        return

    try:
        c_chat = await bot.get_chat(target)
        channel_id = c_chat.id
        channel_name = c_chat.title

    except Exception as e:
        await update.reply_text("Encountered Some Issue..Please Check Logs..!!"
                                )
        raise e

    in_db = await db.in_db(chat_id, channel_id)

    if in_db:
        await update.reply_text("Channel Aldready In Db...!!!")
        return

    wait_msg = await update.reply_text(
        "Please Wait Till I Add All Your Files From Channel To Db\n\n<i>This May Take 10 or 15 Mins Depending On Your No. Of Files In Channel.....</i>\n\nUntil Then Please Dont Sent Any Other Command Or This Operation May Be Intrupted...."
    )

    try:
        type_list = ["video", "audio", "document"]
        data = []
        skipCT = 0

        for typ in type_list:

            async for msgs in bot.USER.search_messages(
                    channel_id,
                    filter=typ):  #Thanks To @PrgOfficial For Suggesting

                # Using 'if elif' instead of 'or' to determine 'file_type'
                # Better Way? Make A PR
                try:
                    if msgs.video:
                        try:
                            file_id = await bot.get_messages(
                                channel_id, message_ids=msgs.message_id)
                        except FloodWait as e:
                            asyncio.sleep(e.x)
                            file_id = await bot.get_messages(
                                channel_id, message_ids=msgs.message_id)
                        except Exception as e:
                            print(e)
                            continue
                        file_id = file_id.video.file_id
                        file_name = msgs.video.file_name[0:-4]
                        file_caption = msgs.caption if msgs.caption else ""
                        file_size = msgs.video.file_size
                        file_type = "video"

                    elif msgs.audio:
                        try:
                            file_id = await bot.get_messages(
                                channel_id, message_ids=msgs.message_id)
                        except FloodWait as e:
                            asyncio.sleep(e.x)
                            file_id = await bot.get_messages(
                                channel_id, message_ids=msgs.message_id)
                        except Exception as e:
                            print(e)
                            continue
                        file_id = file_id.audio.file_id
                        file_name = msgs.audio.file_name[0:-4]
                        file_caption = msgs.caption if msgs.caption else ""
                        file_size = msgs.audio.file_size
                        file_type = "audio"

                    elif msgs.document:
                        try:
                            file_id = await bot.get_messages(
                                channel_id, message_ids=msgs.message_id)
                        except FloodWait as e:
                            asyncio.sleep(e.x)
                            file_id = await bot.get_messages(
                                channel_id, message_ids=msgs.message_id)
                        except Exception as e:
                            print(str(e))
                            continue
                        file_id = file_id.document.file_id
                        file_name = msgs.document.file_name[0:-4]
                        file_caption = msgs.caption if msgs.caption else ""
                        file_size = msgs.document.file_size
                        file_type = "document"

                    for i in ["_", "|", "-", "."]:  # Work Around
                        try:
                            file_name = file_name.replace(i, " ")
                        except Exception:
                            pass

                    file_link = msgs.link
                    group_id = chat_id
                    unique_id = ''.join(
                        random.choice(string.ascii_lowercase +
                                      string.ascii_uppercase + string.digits)
                        for _ in range(15))

                    dicted = dict(
                        file_id=file_id,  # Done
                        unique_id=unique_id,
                        file_name=file_name,
                        file_caption=file_caption,
                        file_size=file_size,
                        file_type=file_type,
                        file_link=file_link,
                        chat_id=channel_id,
                        group_id=group_id,
                    )

                    data.append(dicted)
                except Exception as e:
                    if 'NoneType' in str(
                            e
                    ):  # For Some Unknown Reason Some File Names are NoneType
                        skipCT += 1
                        continue
                    print(e)

        print(
            f"{skipCT} Files Been Skipped Due To File Name Been None..... #BlameTG"
        )
    except Exception as e:
        await wait_msg.edit_text(
            "Couldnt Fetch Files From Channel... Please look Into Logs For More Details"
        )
        raise e

    await db.add_filters(data)
    await db.add_chat(chat_id, channel_id, channel_name)
    await recacher(chat_id, True, True, bot, update)

    await wait_msg.edit_text(
        f"Channel Was Sucessfully Added With <code>{len(data)}</code> Files..")
コード例 #17
0
async def disconnect(bot: Bot, update):
    """
    A Funtion To Handle Incoming /del Command TO Disconnect A Chat With A Group
    """
    chat_id = update.chat.id
    user_id = update.from_user.id if update.from_user else None
    target_chat = update.text.split(None, 1)
    global VERIFY

    if VERIFY.get(str(chat_id)) == None:  # Make Admin's ID List
        admin_list = []
        async for x in bot.iter_chat_members(chat_id=chat_id,
                                             filter="administrators"):
            admin_id = x.user.id
            admin_list.append(admin_id)
        admin_list.append(None)
        VERIFY[str(chat_id)] = admin_list

    if not user_id in VERIFY.get(str(chat_id)):
        return

    try:
        if target_chat[1].startswith("@"):
            if len(target_chat[1]) < 5:
                await update.reply_text("Invalid Username...!!!")
                return
            target = target_chat[1]

        elif not target_chat.startswith("@"):
            if len(target_chat[1]) < 14:
                await update.reply_text(
                    "Invalid Chat Id...\nChat ID Should Be Something Like This: <code>-100xxxxxxxxxx</code>"
                )
                return
            target = int(target_chat[1])

    except Exception:
        await update.reply_text(
            "Invalid Input...\nYou Should Specify Valid chat_id(-100xxxxxxxxxx) or @username"
        )
        return

    userbot = await bot.USER.get_me()
    userbot_name = userbot.first_name
    userbot_id = userbot.id

    try:
        channel_info = await bot.USER.get_chat(target)
        channel_id = channel_info.id
    except Exception:
        await update.reply_text(
            f"My UserBot [{userbot_name}](tg://user?id={userbot_id}) Couldnt Fetch Details Of `{target}` Make Sure Userbot Is Not Banned There Or Add It Manually And Try Again....!!"
        )
        return

    in_db = await db.in_db(chat_id, channel_id)

    if not in_db:
        await update.reply_text(
            "This Channel Is Not Connected With The Group...")
        return

    wait_msg = await update.reply_text(
        "Deleting All Files Of This Channel From DB....!!!\n\nPlease Be Patience...Dont Sent Another Command Until This Process Finishes.."
    )

    await db.del_filters(chat_id, channel_id)
    await db.del_active(chat_id, channel_id)
    await db.del_chat(chat_id, channel_id)
    await recacher(chat_id, True, True, bot, update)

    await wait_msg.edit_text("Sucessfully Deleted All Files From DB....")
コード例 #18
0
async def cb_channel_list(bot, update: CallbackQuery):
    """
    A Callback Funtion For Displaying All Channel List And Providing A Menu To Navigate
    To Every COnnect Chats For Furthur Control
    """
    global VERIFY
    query_data = update.data
    chat_id = update.message.chat.id
    chat_name = remove_emoji(update.message.chat.title)
    chat_name = chat_name.encode('ascii', 'ignore').decode('ascii')[:35]
    user_id = update.from_user.id

    if user_id not in VERIFY.get(str(chat_id)):
        return

    chat_id = re.findall(r"channel_list\((.+)\)", query_data)[0]

    text = "<i>Semms Like You Dont Have Any Channel Connected...</i>\n\n<i>Connect To Any Chat To Continue With This Settings...</i>"

    db_list = await db.find_chat(int(chat_id))

    channel_id_list = []
    channel_name_list = []

    if db_list:
        for x in db_list["chat_ids"]:
            channel_id = x["chat_id"]
            channel_name = x["chat_name"]

            try:
                if (channel_id == None or channel_name == None):
                    continue
            except:
                break

            channel_name = remove_emoji(channel_name).encode(
                'ascii', 'ignore').decode('ascii')[:35]
            channel_id_list.append(channel_id)
            channel_name_list.append(channel_name)

    buttons = []

    buttons.append([
        InlineKeyboardButton("🔙 Back", callback_data="settings"),
        InlineKeyboardButton("Close 🔐", callback_data="close")
    ])

    if channel_name_list:

        text = f"<i>List Of Connected Channels With <code>{chat_name}</code> With There Settings..</i>\n"

        for x in range(1, (len(channel_name_list) + 1)):
            text += f"\n<code>{x}. {channel_name_list[x-1]}</code>\n"

        text += "\nChoose Appropriate Buttons To Navigate Through Respective Channels"

        btn_key = [
            "1️⃣",
            "2️⃣",
            "3️⃣",
            "4️⃣",
            "5️⃣",
            "6️⃣",
            "7️⃣",
            "8️⃣",
            "9️⃣",
            "🔟",
            "1️⃣1️⃣",
            "1️⃣2️⃣",
            "1️⃣3️⃣",
            "1️⃣4️⃣",
            "1️⃣5️⃣",
            "1️⃣6️⃣",
            "1️⃣7️⃣",
            "1️⃣8️⃣",
            "1️⃣9️⃣",
            "2️⃣0️⃣"  # Just In Case 😂🤣
        ]

        for i in range(
                1,
            (len(channel_name_list) +
             1)):  # Append The Index Number of Channel In Just A Single Line
            if i == 1:
                buttons.insert(0, [
                    InlineKeyboardButton(
                        btn_key[i - 1],
                        callback_data=
                        f"info({channel_id_list[i-1]}|{channel_name_list[i-1]})"
                    )
                ])

            else:
                buttons[0].append(
                    InlineKeyboardButton(
                        btn_key[i - 1],
                        callback_data=
                        f"info({channel_id_list[i-1]}|{channel_name_list[i-1]})"
                    ))

    reply_markup = InlineKeyboardMarkup(buttons)

    await update.message.edit_text(text=text,
                                   reply_markup=reply_markup,
                                   parse_mode="html")
コード例 #19
0
async def settings(bot, update):
    
    chat_id = update.chat.id
    user_id = update.from_user.id if update.from_user else None
    global VERIFY

    if VERIFY.get(str(chat_id)) == None: # Make Admin's ID List
        admin_list = []
        async for x in bot.iter_chat_members(chat_id=chat_id, filter="administrators"):
            admin_id = x.user.id 
            admin_list.append(admin_id)
        admin_list.append(None)
        VERIFY[str(chat_id)] = admin_list

    if not user_id in VERIFY.get(str(chat_id)): # Checks if user is admin of the chat
        return
    
    bot_info = await bot.get_me()
    bot_first_name= bot_info.first_name
    
    text =f"<i>{bot_first_name}'s</i> Settings Pannel.....\n"
    text+=f"\n<i>You Can Use This Menu To Change Connectivity And Know Status Of Your Every Connected Channel, Change Filter Types, Configure Filter Results And To Know Status Of Your Group...</i>"
    
    buttons = [
        [
            InlineKeyboardButton
                (
                    "Channels", callback_data=f"channel_list({chat_id})"
                ), 
            
            InlineKeyboardButton
                (
                    "Filter Types", callback_data=f"types({chat_id})"
                )
        ],
        [
            InlineKeyboardButton
                (
                    "Configure 🛠", callback_data=f"config({chat_id})"
                )
        ], 
        [
            InlineKeyboardButton
                (
                    "Status", callback_data=f"status({chat_id})"
                ),
            
            InlineKeyboardButton
                (
                    "About", callback_data=f"about({chat_id})"
                )
        ],
        [
            InlineKeyboardButton
                (
                    "Close 🔐", callback_data="close"
                )
        ]
    ]
    
    reply_markup = InlineKeyboardMarkup(buttons)
    
    await bot.send_message (
        
        chat_id=chat_id, 
        text=text, 
        reply_markup=reply_markup, 
        parse_mode="html",
        reply_to_message_id=update.message_id
        
        )
コード例 #20
0
async def cb_config(bot, update: CallbackQuery):
    """
    A Callback Funtion For Chaning The Number Of Total Pages / 
    Total Results / Results Per pages / Enable or Diable Invite Link /
    Enable or Disable PM File Chat
    """
    global VERIFY
    query_data = update.data
    chat_id = update.message.chat.id
    chat_name = remove_emoji(update.message.chat.title)
    user_id = update.from_user.id

    if user_id not in VERIFY.get(str(chat_id)):
        return

    chat_id = re.findall(r"config\((.+)\)", query_data)[0]

    settings = await db.find_chat(int(chat_id))

    mp_count = settings["configs"]["max_pages"]
    mf_count = settings["configs"]["max_results"]
    mr_count = settings["configs"]["max_per_page"]
    pm_file_chat = settings["configs"]["pm_fchat"]
    show_invite = settings["configs"]["show_invite_link"]

    text = f"<i><b>Configure Your <u><code>{chat_name}</code></u> Group's Filter Settings...</b></i>\n"

    text += f"\n<i>{chat_name}</i> Current Settings:\n"

    text += f"\n - Max Filter: <code>{mf_count}</code>\n"

    text += f"\n - Max Pages: <code>{mp_count}</code>\n"

    text += f"\n - Max Filter Per Page: <code>{mr_count}</code>\n"

    text += f"\n - Show Invitation Link: <code>{show_invite}</code>\n"

    text += f"\n - Provide File In Bot PM: <code>{pm_file_chat}</code>\n"

    text += "\nAdjust Above Value Using Buttons Below... "
    buttons = [[
        InlineKeyboardButton("Filter Per Page",
                             callback_data=f"mr_count({mr_count}|{chat_id})"),
        InlineKeyboardButton("Max Pages",
                             callback_data=f"mp_count({mp_count}|{chat_id})")
    ]]

    buttons.append([
        InlineKeyboardButton("Total Filter Count",
                             callback_data=f"mf_count({mf_count}|{chat_id})")
    ])

    buttons.append([
        InlineKeyboardButton(
            "Show Invite Links",
            callback_data=f"show_invites({show_invite}|{chat_id})"),
        InlineKeyboardButton("Bot File Chat",
                             callback_data=f"inPM({pm_file_chat}|{chat_id})")
    ])
    buttons.append([InlineKeyboardButton("🔙 Back", callback_data=f"settings")])

    reply_markup = InlineKeyboardMarkup(buttons)

    await update.message.edit_text(text,
                                   reply_markup=reply_markup,
                                   parse_mode="html")
コード例 #21
0
async def cb_toggle(bot, update: CallbackQuery):
    """
    A Callback Funtion Support handler For types()
    """
    global VERIFY
    query_data = update.data
    chat_id = update.message.chat.id
    user_id = update.from_user.id

    if user_id not in VERIFY.get(str(chat_id)):
        return

    chat_id, types, val = re.findall(r"toggle\((.+)\)",
                                     query_data)[0].split("|", 2)

    _types = await db.find_chat(int(chat_id))

    _types = _types["types"]
    vid = _types["video"]
    doc = _types["document"]
    aud = _types["audio"]

    if types == "video":
        vid = True if val == "True" else False
    elif types == "audio":
        aud = True if val == "True" else False
    elif types == "document":
        doc = True if val == "True" else False

    settings = {"video": vid, "audio": aud, "document": doc}

    process = await db.update_settings(chat_id, settings)

    if process:
        await update.answer(text="Filter Types Updated Sucessfully",
                            show_alert=True)

    else:
        text = "Something Wrong Please Check Bot Log For More Information...."
        await update.answer(text, show_alert=True)
        return

    _types = await db.find_chat(int(chat_id))

    text = f"<i>Filter Types Enabled In <code>{update.message.chat.title}</code></i>\n"

    _types = _types["types"]
    vid = _types["video"]
    doc = _types["document"]
    aud = _types["audio"]

    buttons = []

    if vid:
        text += "\n<i><b>Video Index:</b> Enabled</i>\n"
        v_e = "✅"
        vcb_data = f"toggle({chat_id}|video|False)"

    else:
        text += "\n<i><b>Video Index:</b> Disabled</i>\n"
        v_e = "❎"
        vcb_data = f"toggle({chat_id}|video|True)"

    if doc:
        text += "\n<i><b>Document Index:</b> Enabled</i>\n"
        d_e = "✅"
        dcb_data = f"toggle({chat_id}|document|False)"

    else:
        text += "\n<i><b>Document Index:</b> Disabled</i>\n"
        d_e = "❎"
        dcb_data = f"toggle({chat_id}|document|True)"

    if aud:
        text += "\n<i><b>Audio Index:</b> Enabled</i>\n"
        a_e = "✅"
        acb_data = f"toggle({chat_id}|audio|False)"

    else:
        text += "\n<i><b>Audio Index:</b> Disabled</i>\n"
        a_e = "❎"
        acb_data = f"toggle({chat_id}|audio|True)"

    text += "\n<i>Below Buttons Will Toggle Respective Media Types As Enabled Or Disabled....\n</i>"
    text += "<i>This Will Take Into Action As Soon As You Change Them....</i>"

    buttons.append(
        [InlineKeyboardButton(f"Video Index : {v_e}", callback_data=vcb_data)])
    buttons.append(
        [InlineKeyboardButton(f"Audio Index : {a_e}", callback_data=acb_data)])
    buttons.append([
        InlineKeyboardButton(f"Document Index : {d_e}", callback_data=dcb_data)
    ])

    buttons.append([InlineKeyboardButton("🔙 Back", callback_data=f"settings")])

    reply_markup = InlineKeyboardMarkup(buttons)

    await update.message.edit_text(text,
                                   reply_markup=reply_markup,
                                   parse_mode="html")
コード例 #22
0
async def cb_types(bot, update: CallbackQuery):
    """
    A Callback Funtion For Changing The Result Types To Be Shown In While Sending Results
    """
    global VERIFY
    query_data = update.data
    chat_id = update.message.chat.id
    chat_name = remove_emoji(update.message.chat.title)
    user_id = update.from_user.id

    if user_id not in VERIFY.get(str(chat_id)):
        return

    chat_id = re.findall(r"types\((.+)\)", query_data)[0]

    _types = await db.find_chat(int(chat_id))

    text = f"<i>Filter Types Enabled/Disbled In <code>{chat_name}</code></i>\n"

    _types = _types["types"]
    vid = _types["video"]
    doc = _types["document"]
    aud = _types["audio"]

    buttons = []

    if vid:
        text += "\n<i><b>Video Index:</b> Enabled</i>\n"
        v_e = "✅"
        vcb_data = f"toggle({chat_id}|video|False)"

    else:
        text += "\n<i><b>Video Index:</b> Disabled</i>\n"
        v_e = "❎"
        vcb_data = f"toggle({chat_id}|video|True)"

    if doc:
        text += "\n<i><b>Document Index:</b> Enabled</i>\n"
        d_e = "✅"
        dcb_data = f"toggle({chat_id}|document|False)"

    else:
        text += "\n<i><b>Document Index:</b> Disabled</i>\n"
        d_e = "❎"
        dcb_data = f"toggle({chat_id}|document|True)"

    if aud:
        text += "\n<i><b>Audio Index:</b> Enabled</i>\n"
        a_e = "✅"
        acb_data = f"toggle({chat_id}|audio|False)"

    else:
        text += "\n<i><b>Audio Index:</b> Disabled</i>\n"
        a_e = "❎"
        acb_data = f"toggle({chat_id}|audio|True)"

    text += "\n<i>Below Buttons Will Toggle Respective Media Types As Enabled Or Disabled....\n</i>"
    text += "<i>This Will Take Into Action As Soon As You Change Them....</i>"

    buttons.append(
        [InlineKeyboardButton(f"Video Index: {v_e}", callback_data=vcb_data)])
    buttons.append(
        [InlineKeyboardButton(f"Audio Index: {a_e}", callback_data=acb_data)])
    buttons.append([
        InlineKeyboardButton(f"Document Index: {d_e}", callback_data=dcb_data)
    ])

    buttons.append([InlineKeyboardButton("🔙 Back", callback_data=f"settings")])

    reply_markup = InlineKeyboardMarkup(buttons)

    await update.message.edit_text(text,
                                   reply_markup=reply_markup,
                                   parse_mode="html")
コード例 #23
0
async def cb_navg(bot, update: CallbackQuery):
    """
    A Callback Funtion For The Next Button Appearing In Results
    """
    global VERIFY
    query_data = update.data
    chat_id = update.message.chat.id
    user_id = update.from_user.id

    index_val, btn, query = re.findall(r"navigate\((.+)\)",
                                       query_data)[0].split("|", 2)
    try:
        ruser_id = update.message.reply_to_message.from_user.id
    except Exception as e:
        print(e)
        ruser_id = None

    admin_list = VERIFY.get(str(chat_id))
    if admin_list == None:  # Make Admin's ID List

        admin_list = []

        async for x in bot.iter_chat_members(chat_id=chat_id,
                                             filter="administrators"):
            admin_id = x.user.id
            admin_list.append(admin_id)

        admin_list.append(None)  # Just For Anonymous Admin....
        VERIFY[str(chat_id)] = admin_list

    if not ((user_id == ruser_id) or (user_id in admin_list)
            ):  # Checks if user is same as requested user or is admin
        await update.answer("Nice Try ;)", show_alert=True)
        return

    if btn == "next":
        index_val = int(index_val) + 1
    elif btn == "back":
        index_val = int(index_val) - 1

    achats = ACTIVE_CHATS[str(chat_id)]
    configs = await db.find_chat(chat_id)
    pm_file_chat = configs["configs"]["pm_fchat"]
    show_invite = configs["configs"]["show_invite_link"]
    show_invite = (False if pm_file_chat == True else show_invite)

    results = FIND.get(query).get("results")
    leng = FIND.get(query).get("total_len")
    max_pages = FIND.get(query).get("max_pages")

    try:
        temp_results = results[index_val].copy()
    except IndexError:
        return  # Quick Fix🏃🏃
    except Exception as e:
        print(e)
        return

    if ((index_val + 1) == max_pages) or ((index_val + 1)
                                          == len(results)):  # Max Pages
        temp_results.append([
            InlineKeyboardButton(
                "⏪ Back", callback_data=f"navigate({index_val}|back|{query})")
        ])

    elif int(index_val) == 0:
        pass

    else:
        temp_results.append([
            InlineKeyboardButton(
                "⏪ Back", callback_data=f"navigate({index_val}|back|{query})"),
            InlineKeyboardButton(
                "Next ⏩", callback_data=f"navigate({index_val}|next|{query})")
        ])

    if not int(index_val) == 0:
        temp_results.append([
            InlineKeyboardButton(
                f"🔰 Page {index_val + 1}/{len(results) if len(results) < max_pages else max_pages} 🔰",
                callback_data="ignore")
        ])

    if show_invite and int(index_val) != 0:

        ibuttons = []
        achatId = []
        await gen_invite_links(configs, chat_id, bot, update)

        for x in achats["chats"] if isinstance(achats, dict) else achats:
            achatId.append(int(x["chat_id"])) if isinstance(
                x, dict) else achatId.append(x)

        for y in INVITE_LINK.get(str(chat_id)):

            chat_id = int(y["chat_id"])

            if chat_id not in achatId:
                continue

            chat_name = y["chat_name"]
            invite_link = y["invite_link"]

            if ((len(ibuttons) % 2) == 0):
                ibuttons.append([
                    InlineKeyboardButton(f"⚜ {chat_name} ⚜", url=invite_link)
                ])

            else:
                ibuttons[-1].append(
                    InlineKeyboardButton(f"⚜ {chat_name} ⚜", url=invite_link))

        for x in ibuttons:
            temp_results.insert(0, x)
        ibuttons = None
        achatId = None

    reply_markup = InlineKeyboardMarkup(temp_results)

    text = f"<i>Found</i> <code>{leng}</code> <i>Results For Your Query:</i> <code>{query}</code>"

    try:
        await update.message.edit(text,
                                  reply_markup=reply_markup,
                                  parse_mode="html")

    except FloodWait as f:  # Flood Wait Caused By Spamming Next/Back Buttons
        await asyncio.sleep(f.x)
        await update.message.edit(text,
                                  reply_markup=reply_markup,
                                  parse_mode="html")
コード例 #24
0
async def cb_info(bot, update: CallbackQuery):
    """
    A Callback Funtion For Displaying Details Of The Connected Chat And Provide
    Ability To Connect / Disconnect / Delete / Delete Filters of That Specific Chat
    """
    global VERIFY
    query_data = update.data
    chat_id = update.message.chat.id
    user_id = update.from_user.id

    if user_id not in VERIFY.get(str(chat_id)):
        return

    channel_id, channel_name = re.findall(r"info\((.+)\)",
                                          query_data)[0].split("|", 1)

    f_count = await db.cf_count(chat_id, int(channel_id))
    active_chats = await db.find_active(chat_id)

    if active_chats:  # Checks for active chats connected to a chat
        dicts = active_chats["chats"]
        db_cids = [int(x["chat_id"]) for x in dicts]

        if int(channel_id) in db_cids:
            active_chats = True
            status = "Connected"

        else:
            active_chats = False
            status = "Disconnected"

    else:
        active_chats = False
        status = "Disconnected"

    text = f"<i>Info About <b>{channel_name}</b></i>\n"
    text += f"\n<i>Channel Name:</i> <code>{channel_name}</code>\n"
    text += f"\n<i>Channel ID:</i> <code>{channel_id}</code>\n"
    text += f"\n<i>Channel Files:</i> <code>{f_count}</code>\n"
    text += f"\n<i>Current Status:</i> <code>{status}</code>\n"

    if active_chats:
        buttons = [[
            InlineKeyboardButton(
                "🚨 Disconnect 🚨",
                callback_data=f"warn({channel_id}|{channel_name}|disconnect)"),
            InlineKeyboardButton(
                "Delete ❌",
                callback_data=f"warn({channel_id}|{channel_name}|c_delete)")
        ]]

    else:
        buttons = [[
            InlineKeyboardButton(
                "💠 Connect 💠",
                callback_data=f"warn({channel_id}|{channel_name}|connect)"),
            InlineKeyboardButton(
                "Delete ❌",
                callback_data=f"warn({channel_id}|{channel_name}|c_delete)")
        ]]

    buttons.append([
        InlineKeyboardButton(
            "Delete Filters ⚠",
            callback_data=f"warn({channel_id}|{channel_name}|f_delete)")
    ])

    buttons.append([
        InlineKeyboardButton("🔙 Back",
                             callback_data=f"channel_list({chat_id})")
    ])

    reply_markup = InlineKeyboardMarkup(buttons)

    await update.message.edit_text(text,
                                   reply_markup=reply_markup,
                                   parse_mode="html")