예제 #1
0
def start(client, message):
    # Hoş Geldin Mesajı
    message.reply_chat_action("typing")
    client.send_message(message.from_user.id,text='text',reply_markup=main_keyboard)
    message.reply(f"☣ **KekikRAT** ☣\n\nBütün veriler [Patron](tg://user?id={adminID})'a Gönderilecek!")

    # LOG Alanı
    log = f"[{message.from_user.first_name}](tg://user?id={message.from_user.id}) | Bota Bağlantı Sağladı"
    #client.send_message(adminID, "Look at that button!", reply_markup=ReplyKeyboardMarkup([["Nice!"]]))


    client.send_message(
        message.from_user.id, "İşte Sana : `InlineKeyboardMarkup`",
        reply_markup=InlineKeyboardMarkup(
            [
                [InlineKeyboardButton("Data", callback_data="hidden_callback_data")],
                [InlineKeyboardButton("Docs", url="https://docs.pyrogram.org")]
            ]
        ))

    client.send_message(
        message.from_user.id,
        "Aşağıdakiler de : `ReplyKeyboardMarkup`",
        reply_markup=ReplyKeyboardMarkup(
            [
                ["Nice!"],
                ["Perfect"],
                ["Bravo Piç"]
            ],
            resize_keyboard=True
        ))
예제 #2
0
async def settings_sticker(_client, message):
    if not DB_AVAILABLE:
        await message.edit("Your database is not avaiable!")
        return
    global TEMP_KEYBOARD, USER_SET
    await app.send_message("@Stickers", "/stats")
    # app.read_history("@Stickers")
    time.sleep(0.2)
    try:
        keyboard = await app.get_history("@Stickers", limit=1)
        keyboard = keyboard[0].reply_markup.keyboard
    except:
        message.message.edit_text(
            "You dont have any sticker pack!\nAdd stickers pack in @Stickers ")
        return
    for x in keyboard:
        for y in x:
            TEMP_KEYBOARD.append(y)
    await app.send_message("@Stickers", "/cancel")
    await message.message.delete()
    msg = await setbot.send_message(
        Owner,
        "Select your stickers for set as kang animation sticker",
        reply_markup=ReplyKeyboardMarkup(keyboard))
    USER_SET[message.from_user.id] = msg.message_id
    USER_SET["type"] = 2
예제 #3
0
async def rate(_client: Client, callback: CallbackQuery):
    _, amount, tgo_id = callback.data.split('|')
    accept_rate(int(tgo_id), int(amount), callback.from_user.id)
    info = get_info(tgo_id)
    await callback.edit_message_text(
        f"Success!\n🌟Rates average: {info.stars_average} / 5")
    review = await _client.ask(
        callback.message.chat.id,
        "Want to write a review?",
        reply_markup=ReplyKeyboardMarkup(
            [[KeyboardButton('Yes'),
              KeyboardButton('No')]],
            resize_keyboard=True,
            one_time_keyboard=True))
    await review.delete()
    await review.request.delete()
    if str(review.text) == 'No':
        return await callback.message.reply("Thanks!",
                                            reply_markup=ReplyKeyboardRemove())
    elif str(review.text) == 'Yes':
        review = await _client.ask(callback.message.chat.id,
                                   "Write your review:",
                                   reply_markup=ReplyKeyboardRemove())
        await review.request.delete()
        await review.delete()
        await callback.message.reply("Thanks!")
        return await _client.send_message(
            info.owner, "Review from "
            f" [{callback.from_user.first_name}]"
            f"(tg://user?id={callback.from_user.id}) "
            f"about [this bot](tg://user?id={info.id})\n\n"
            f"{str(review.text)}")
    else:
        return await callback.message.reply("Stop zaccing me!")
예제 #4
0
    async def _new_document(self, _: Client, message: Message):
        devices = []

        if self._config.upnp_enabled:
            devices.extend(await UpnpDeviceFinder.find(self._config))

        if self._config.chromecast_enabled:
            # noinspection PyUnresolvedReferences
            devices.extend(await ChromecastDeviceFinder.find(self._config))

        if self._config.xbmc_enabled:
            devices.extend(await XbmcDeviceFinder.find(self._config))

        if self._config.vlc_enabled:
            devices.extend(await VlcDeviceFinder.find(self._config))

        if devices:
            try:
                filename = pyrogram_filename(message)
            except TypeError:
                filename = "NaN"

            self._state_machine.set_state(
                message, States.SELECT,
                SelectStateData(message.message_id, filename, devices.copy()))

            buttons = [[KeyboardButton(repr(device))] for device in devices]
            buttons.append([KeyboardButton(_CANCEL_BUTTON)])
            markup = ReplyKeyboardMarkup(buttons, one_time_keyboard=True)
            await message.reply("Select a device", reply_markup=markup)

        else:
            await message.reply("Supported devices not found in the network",
                                reply_markup=_REMOVE_KEYBOARD)
예제 #5
0
async def open_panel(_client: Client, message: Message):
    await message.reply(
        "Select Option below", reply_markup=ReplyKeyboardMarkup([
            [KeyboardButton('Add new')],
            [KeyboardButton('My bots / channels / groups')]
        ], resize_keyboard=True, one_time_keyboard=True)
    )
예제 #6
0
def add_event(client, message):
    _, name, date, hour = message.text.split()
    year, month, day = list(map(int, date.split('/')))
    hour, minute = list(map(int, hour.split(':')))
    date = JalaliDateTime(year, month, day).to_gregorian()
    # date = date.replace(hour=hour, minute=minute, tzinfo=tehran)
    date = date.replace(hour=hour, minute=minute, tzinfo=tz('UTC'))
    events.append({date: [name, message.chat.id]})
    message.reply("Time",
                  reply_markup=ReplyKeyboardMarkup(
                      [["1 Week Before", "1 Day Before", "1 Hour Before"]],
                      resize_keyboard=True))
예제 #7
0
async def get_stickers(client, message):
    global TEMP_KEYBOARD, USER_SET
    await app.send_message("@Stickers", "/stats")
    # app.read_history("@Stickers")
    time.sleep(0.2)
    keyboard = await app.get_history("@Stickers", limit=1)
    keyboard = keyboard[0].reply_markup.keyboard
    for x in keyboard:
        for y in x:
            TEMP_KEYBOARD.append(y)
    await app.send_message("@Stickers", "/cancel")
    msg = await message.reply("Select your stickers for set as kang sticker",
                              reply_markup=ReplyKeyboardMarkup(keyboard))
    USER_SET[message.from_user.id] = msg.message_id
예제 #8
0
def kb(rows = [], **kwargs):
    lines = []
    for row in rows:
        line = []
        for button in row:
            button_type = type(button)
            if button_type == str:
                button = KeyboardButton(button)
            elif button_type == dict:
                button = KeyboardButton(**button)
            
            line.append(button)
        lines.append(line)
    return ReplyKeyboardMarkup(keyboard=lines, **kwargs)
예제 #9
0
def handle_start(c, m):
    edit_home()
    yangilash()
    buyurtmalar[m.chat.id] = []
    bot.send_message(m.chat.id,
                     """Assalomu Alaykum,

EZAZ | Milliy Taomlar botimizga xush kelibsiz.

Iltimos, avval siz bilan bog'lanishimiz uchun o'z raqamingizni 👤 Kontakt ko'rinishda jo'nating yoki pastdagi "📲 Telefon raqamni jo'natish" tugmasini bosing:""",
                     reply_markup=ReplyKeyboardMarkup([[
                         KeyboardButton("📱 Telefon raqamni jo'natish",
                                        request_contact=True),
                     ]],
                                                      resize_keyboard=True))
예제 #10
0
async def contact(_client: Client, message: Message):
    msg = await _client.ask(message.chat.id,
                            "Write a messages and then press 'Done'.",
                            reply_markup=ReplyKeyboardMarkup(
                                [[KeyboardButton('Done')]],
                                resize_keyboard=True))
    if str(msg.text) != "Done":
        await _client.send_message(
            'Oxcafe1c2a', "[{}](tg://user?id={}) said: \n\n\n{}".format(
                message.from_user.first_name, message.from_user.id,
                str(msg.text)))
        await contact(_client, message)
    else:
        await msg.delete()
        await message.reply("The messages was sent successfully!")
        await start_handler(_client, message)
예제 #11
0
async def start(app: Client, message: Message):
    if message.from_user.id in USERS:
        await message.reply_text(plate("hello", USERS[message.from_user.id]))
    else:
        await message.reply_text(
            "Language? Sprache? Linguaggio?",
            reply_markup=ReplyKeyboardMarkup(
                [[
                    KeyboardButton(DE),
                    KeyboardButton(US),
                    KeyboardButton(IT),
                ]],
                resize_keyboard=True,
                one_time_keyboard=True,
            ),
        )
예제 #12
0
async def get_stickers(_client, message):
    if not DB_AVAILABLE:
        await message.edit("Your database is not avaiable!")
        return
    global TEMP_KEYBOARD, USER_SET
    await app.send_message("@Stickers", "/stats")
    # app.read_history("@Stickers")
    time.sleep(0.2)
    keyboard = await app.get_history("@Stickers", limit=1)
    keyboard = keyboard[0].reply_markup.keyboard
    for x in keyboard:
        for y in x:
            TEMP_KEYBOARD.append(y)
    await app.send_message("@Stickers", "/cancel")
    msg = await message.reply("Select your stickers for set as kang sticker",
                              reply_markup=ReplyKeyboardMarkup(keyboard))
    USER_SET[message.from_user.id] = msg.message_id
    USER_SET["type"] = 1
예제 #13
0
def handle_location(c, m: Message):
    if manzil.get(m.chat.id, None):
        manzil[m.chat.id] = "Geolokatsiya"
        geolokatsiya[m.chat.id] = (m.location.latitude, m.location.longitude)
        a = distance(41.120233069494155, 69.07184731700151,
                     m.location.latitude, m.location.longitude)
        xizmat_narxi[m.chat.id] = 6.0
        if a >= 3:
            xizmat_narxi[m.chat.id] += ceil(a - 3)
        jami = 0.0
        text = """👤 <b>Hurmatli mijoz,</b>siz tanlagan taomlar uchun doimiy ravishda "Bir martalik" idish qo'shib oboriladi.
shuning uchun BOT avtomatik tarzda Quyuq taom uchun: quyuq idish(1000so'm) suyuq taom uchun: suyuq idish(1500so'm) hisoblaydi.

🛵 Yetkazib berish xizmatimiz Yangiyo'l shahar va Tumanida amal qiladi.Yetkazib berish xizmatimiz 3kmdan uzoq masofaga km hisobida 1000so'mdan qo'shib boriladi.Bu ishni BOTning o'zi avtomatik tarzda bajaradi.

👇 Siz tanlagan taomlar:\n
--------------"""
        idishlar = 0.0
        for i in buyurtmalar[m.chat.id]:
            if "suyuq" in i[-1].lower() or "uyg'ur" in i[-1].lower():
                idishlar += 1.5 * i[2]
            if "quyuq" in i[-1].lower() or "salatlar" in i[-1].lower():
                idishlar += 1.0 * i[2]
            text += "{} x {}: {}00\n".format(i[2], i[0], i[1] * i[2])
            jami += i[1] * i[2]
        if idishlar:
            text += "🍽 Bir martalik idishlar: {}00\n".format(idishlar)
            jami += idishlar
        text += "🛵 Yetkazib berish hizmati: {}00\n".format(
            xizmat_narxi[m.chat.id])
        jami += xizmat_narxi[m.chat.id]
        text += "<b>📋 Jami: {}00</b>\n" \
                "--------------".format(jami)
        bot.send_message(m.chat.id,
                         text,
                         reply_markup=ReplyKeyboardMarkup(
                             [[ha], [yuq], [qol]], resize_keyboard=True))
        return
예제 #14
0
async def start_handler(_client: Client, message):
    if hasattr(message, 'reply'):
        callback = message.reply
    else:
        await message.message.delete()
        callback = message.message.reply
    await callback(
        f"""
    Hi {message.from_user.first_name}, 
Welcome.

What can i do?
🔸Rate channels / bots / groups.
🔸Send Review for channels / bots / groups.
🔸Contact the admins of channel / bots / group / etc..

Want to support me?
[Donate here](paypal.me/pybots)
    """,
        reply_markup=ReplyKeyboardMarkup(
            [[KeyboardButton('Open panel')], [KeyboardButton('Contact me')]],
            resize_keyboard=True,
            one_time_keyboard=True))
예제 #15
0
async def show_my_tg_objects(_client: Client, callback: CallbackQuery):
    data_splitted = callback.data.split('|')
    how_to_show = None
    if len(data_splitted) == 3:
        tgo_type, how_to_show = data_splitted[1:]
    else:
        tgo_type = data_splitted[1]

    buttons = list_of_tg_objects(callback.from_user.id, tgo_type)
    if not how_to_show:
        how_to_show = await _client.ask(
            callback.message.chat.id,
            'How do you want to show them?',
            reply_markup=ReplyKeyboardMarkup(
                [[KeyboardButton('By name')], [KeyboardButton('By username')]],
                resize_keyboard=True))
        await how_to_show.delete()
        await how_to_show.request.delete()
        how_to_show = how_to_show.text
    if buttons:
        try:
            await callback.edit_message_text(
                f"{Emoji.DOWN_ARROW} " +
                (f"Here your " + tgo_type + 's' if tgo_type != 'all' else
                 "All of your bots / channels / groups") +
                f" {Emoji.DOWN_ARROW}",
                reply_markup=make_buttons_from_tg_objects(
                    buttons, show_by[how_to_show]
                    if len(how_to_show) > 1 else how_to_show,
                    f"{tgo_type}|{show_by[how_to_show] if len(how_to_show) > 1 else how_to_show}"
                ))
        except KeyError:
            await callback.edit_message_text(Emoji.FACE_WITH_ROLLING_EYES)
    else:
        await callback.edit_message_text(
            f'Nothing to show {Emoji.MAN_SHRUGGING}')
예제 #16
0
"""

from pyrogram import Client, ReplyKeyboardMarkup, InlineKeyboardMarkup, InlineKeyboardButton

# Create a client using your bot token
app = Client("my_bot", bot_token="123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11")

with app:
    app.send_message(
        "haskell",  # Edit this
        "This is a ReplyKeyboardMarkup example",
        reply_markup=ReplyKeyboardMarkup(
            [
                ["A", "B", "C", "D"],  # First row
                ["E", "F", "G"],  # Second row
                ["H", "I"],  # Third row
                ["J"]  # Fourth row
            ],
            resize_keyboard=True  # Make the keyboard smaller
        ))

    app.send_message(
        "haskell",  # Edit this
        "This is a InlineKeyboardMarkup example",
        reply_markup=InlineKeyboardMarkup([
            [  # First row
                InlineKeyboardButton(  # Generates a callback query when pressed
                    "Button",
                    callback_data=b"data"  # Note how callback_data must be bytes
                ),
                InlineKeyboardButton(  # Opens a web URL
예제 #17
0
def kb_home(user):
    kb = user.choice_localized(ru_obj=KB_HOME_RU, en_obj=KB_HOME_EN)
    return ReplyKeyboardMarkup(kb, resize_keyboard=True)
예제 #18
0
 def one_time_keyboard(self) -> ReplyKeyboardMarkup:
     return ReplyKeyboardMarkup(
         [row.keyboard_row() for row in self._rows],
         resize_keyboard=True,
         one_time_keyboard=True,
     )
예제 #19
0
def updateHandlers(client, message, redis):
    if redis.get("{}Nbot:bigM".format(BOT_ID)):
        return False
    type = message.chat.type
    try:
        userID = message.from_user.id
        chatID = message.chat.id
    except Exception as e:
        return 0
    c = importlib.import_module("lang.arcmd")
    r = importlib.import_module("lang.arreply")

    if (type is "supergroup" or type is "group") and message.outgoing != True:
        userID = message.from_user.id
        chatID = message.chat.id
        rank = isrank(redis, userID, chatID)
        group = redis.sismember("{}Nbot:groups".format(BOT_ID), chatID)
        text = message.text
        title = message.chat.title
        if text and group is False:
            if (rank is "sudo" or rank is "sudos" or rank is "asudo") or (
                    redis.get("{}Nbot:autoaddbot".format(BOT_ID))
                    and GPranks(userID, chatID) == "creator"):
                if text == c.add:
                    if redis.get("{}Nbot:autoaddbotN".format(BOT_ID)):
                        auN = int(
                            redis.get("{}Nbot:autoaddbotN".format(BOT_ID)))
                    else:
                        auN = 1
                    if auN >= Bot("getChatMembersCount", {
                            "chat_id": chatID
                    })["result"] and not (rank is "sudo" or rank is "sudos"):
                        Bot(
                            "sendMessage", {
                                "chat_id":
                                chatID,
                                "text":
                                r.Toolow.format((int(
                                    redis.get(
                                        "{}Nbot:autoaddbotN".format(BOT_ID)))
                                                 or 0)),
                                "reply_to_message_id":
                                message.message_id,
                                "parse_mode":
                                "html"
                            })
                        return False
                    GetME = Bot("getChatMember", {
                        "chat_id": chatID,
                        "user_id": BOT_ID
                    })["result"]
                    if (not GetME["can_change_info"]
                            or not GetME["can_delete_messages"]
                            or not GetME["can_invite_users"]
                            or not GetME["can_restrict_members"]
                            or not GetME["can_pin_messages"]
                            or not GetME["can_promote_members"]):
                        Bot(
                            "sendMessage", {
                                "chat_id": chatID,
                                "text": r.GiveMEall,
                                "reply_to_message_id": message.message_id,
                                "parse_mode": "html"
                            })
                        return False

                if text == c.add and not redis.sismember(
                        "{}Nbot:disabledgroups".format(BOT_ID),
                        chatID) and Ckuser(message):
                    locksarray = {
                        'Llink', 'Llongtext', 'Lmarkdown', 'Linline', 'Lfiles',
                        'Lcontact', 'Lbots', 'Lfwd', 'Lnote'
                    }
                    for lock in locksarray:
                        redis.sadd("{}Nbot:{}".format(BOT_ID, lock), chatID)
                    ads = Bot("getChatAdministrators", {"chat_id": chatID})
                    for ad in ads['result']:
                        userId = ad["user"]["id"]
                        userFn = ad["user"]["first_name"]
                        if ad['status'] == "administrator" and int(
                                userId) != int(BOT_ID):
                            setrank(redis, "admin", userId, chatID, "array")
                        if ad['status'] == "creator":
                            setrank(redis, "malk", userId, chatID, "one")
                    add = redis.sadd("{}Nbot:groups".format(BOT_ID), chatID)
                    Bot("exportChatInviteLink", {"chat_id": chatID})
                    kb = InlineKeyboardMarkup([[
                        InlineKeyboardButton(r.MoreInfo,
                                             url="t.me/Source_Luffy")
                    ]])
                    Bot(
                        "sendMessage", {
                            "chat_id": chatID,
                            "text": r.doneadd.format(title),
                            "reply_to_message_id": message.message_id,
                            "parse_mode": "markdown",
                            "reply_markup": kb
                        })
                    sendTO = (redis.get("{}Nbot:sudogp".format(BOT_ID))
                              or SUDO)
                    get = (redis.hget("{}Nbot:links".format(BOT_ID), chatID)
                           or GetLink(chatID) or "t.me/Source_Luffy")
                    kb = InlineKeyboardMarkup(
                        [[InlineKeyboardButton("الرابط 🖇", url=get)]])
                    BY = "<a href=\"tg://user?id={}\">{}</a>".format(
                        userID, message.from_user.first_name)
                    Bot(
                        "sendMessage", {
                            "chat_id": sendTO,
                            "text":
                            f"تم تفعيل مجموعه جديدة ℹ️\nاسم المجموعه : {title}\nايدي المجموعه : {chatID}\nالمنشئ : {BY}\n⎯ ⎯ ⎯ ⎯",
                            "parse_mode": "html",
                            "reply_markup": kb
                        })
                elif text == c.add and redis.sismember(
                        "{}Nbot:disabledgroups".format(BOT_ID),
                        chatID) and Ckuser(message):
                    redis.sadd("{}Nbot:groups".format(BOT_ID), chatID)
                    redis.srem("{}Nbot:disabledgroups".format(BOT_ID), chatID)
                    redis.hdel("{}Nbot:disabledgroupsTIME".format(BOT_ID),
                               chatID)

                    Bot(
                        "sendMessage", {
                            "chat_id": chatID,
                            "text": r.doneadd2.format(title),
                            "reply_to_message_id": message.message_id,
                            "parse_mode": "markdown"
                        })
                if text == c.disabl and Ckuser(message):
                    Bot(
                        "sendMessage", {
                            "chat_id": chatID,
                            "text": r.disabled.format(title),
                            "reply_to_message_id": message.message_id,
                            "parse_mode": "markdown"
                        })

        if text and group is True:
            if (rank is "sudo" or rank is "sudos" or rank is "asudo") or (
                    redis.get("{}Nbot:autoaddbot".format(BOT_ID))
                    and GPranks(userID, chatID) == "creator"):
                if text == c.add and Ckuser(message):
                    Bot(
                        "sendMessage", {
                            "chat_id": chatID,
                            "text": r.doneadded.format(title),
                            "reply_to_message_id": message.message_id,
                            "parse_mode": "markdown"
                        })
                if text == c.disabl and Ckuser(message):
                    redis.srem("{}Nbot:groups".format(BOT_ID), chatID)
                    redis.sadd("{}Nbot:disabledgroups".format(BOT_ID), chatID)
                    NextDay_Date = datetime.datetime.today(
                    ) + datetime.timedelta(days=1)
                    redis.hset("{}Nbot:disabledgroupsTIME".format(BOT_ID),
                               chatID, str(NextDay_Date))
                    kb = InlineKeyboardMarkup([[
                        InlineKeyboardButton(r.MoreInfo,
                                             url="t.me/Source_Luffy")
                    ]])
                    Bot(
                        "sendMessage", {
                            "chat_id": chatID,
                            "text": r.disabl.format(title),
                            "reply_to_message_id": message.message_id,
                            "parse_mode": "markdown",
                            "reply_markup": kb
                        })
        if group is True:
            t = threading.Thread(target=allGP, args=(client, message, redis))
            t.daemon = True
            t.start()

        if text and group is True:
            x = redis.smembers("{}Nbot:{}:TXoeders".format(BOT_ID, chatID))
            for x in x:
                try:
                    x = x.split("=")
                    if re.search(f"^\{x[0]}$", text) or re.search(
                            f"^\{x[0]} (.*)$", text):
                        text = text.replace(x[0], x[1])
                except Exception as e:
                    print(e)
            message.text = text
        if (rank is "sudo" or rank is "sudos"
                or rank is "asudo") and group is True:
            t = threading.Thread(target=sudo, args=(client, message, redis))
            t.daemon = True
            t.start()

        if text and (rank is "sudo" or rank is "asudo" or rank is "sudos" or
                     rank is "malk" or rank is "acreator" or rank is "creator"
                     or rank is "owner") and group is True:
            t = threading.Thread(target=ranks, args=(client, message, redis))
            t.daemon = True
            t.start()
        if text and (rank is "sudo" or rank is "asudo" or rank is "sudos"
                     or rank is "malk" or rank is "acreator"
                     or rank is "creator" or rank is "owner"
                     or rank is "admin") and group is True and re.search(
                         c.startlock, text):
            if Ckuser(message):
                t = threading.Thread(target=locks,
                                     args=(client, message, redis))
                t.daemon = True
                t.start()
        if (rank is False or rank is 0) and group is True:
            t = threading.Thread(target=delete, args=(client, message, redis))
            t.daemon = True
            t.start()

        if (rank is "sudo" or rank is "asudo" or rank is "sudos"
                or rank is "malk" or rank is "acreator" or rank is "creator"
                or rank is "owner" or rank is "admin") and group is True:
            t = threading.Thread(target=gpcmd, args=(client, message, redis))
            t.daemon = True
            t.start()

    if type is "private" and message.outgoing != True:
        text = message.text
        rank = isrank(redis, userID, chatID)
        if (rank is "sudo" or rank is "asudo" or rank is "sudos"):
            t = threading.Thread(target=sudo, args=(client, message, redis))
            t.daemon = True
            t.start()
        if text and re.search("^/start$", text):
            userID = message.from_user.id
            userFN = message.from_user.first_name
            redis.sadd("{}Nbot:privates".format(BOT_ID), userID)
            if rank == "sudo":
                kb = ReplyKeyboardMarkup(
                    [[r.RKgp, r.RKgpl], [r.RKaf, r.RKrf], [r.RKf],
                     ["جلب نسخه احتياطيه"], [r.RKub]],
                    resize_keyboard=True)
                Bot(
                    "sendMessage", {
                        "chat_id": chatID,
                        "text": r.sudostart,
                        "reply_to_message_id": message.message_id,
                        "parse_mode": "html",
                        "reply_markup": kb
                    })
                return 0
            getbot = client.get_me()
            kb = InlineKeyboardMarkup([[
                InlineKeyboardButton("Source Luffy", url="t.me/Source_Luffy")
            ]])
            Bot(
                "sendMessage", {
                    "chat_id": chatID,
                    "text": r.botstart.format(getbot.first_name,
                                              getbot.username),
                    "reply_to_message_id": message.message_id,
                    "parse_mode": "html",
                    "reply_markup": kb
                })

        if text and re.search("^/start (.*)$", text):
            tx = text.replace("/start ", "")
            split = tx.split("=")
            order = split[0]
            if order == "showreplylistBOT":
                chatId = split[1]
                userId = split[2]
                TY = split[3]
                rank = isrank(redis, userId, chatId)
                if (rank == "sudo" or rank is "asudo" or rank == "sudos"):
                    li = redis.hkeys("{}Nbot:{}".format(BOT_ID, TY))
                    if li:
                        i = 1
                        words = ""
                        for word in li:
                            words = words + "\n" + str(i) + " - {" + word + "}"
                            i += 1
                            if len(words) > 3000:
                                Bot(
                                    "sendMessage", {
                                        "chat_id": userId,
                                        "text": words,
                                        "reply_to_message_id":
                                        message.message_id,
                                        "parse_mode": "html"
                                    })
                                words = ''
                        Bot(
                            "sendMessage", {
                                "chat_id": userId,
                                "text": words,
                                "reply_to_message_id": message.message_id,
                                "parse_mode": "html"
                            })
                        reply_markup = InlineKeyboardMarkup([[
                            InlineKeyboardButton(
                                r.Delall2R,
                                callback_data=json.dumps(
                                    ["del{}".format(TY + 'BOT'), "", userID])),
                        ]])
                        Bot(
                            "sendMessage", {
                                "chat_id": chatID,
                                "text": r.DelallR,
                                "reply_to_message_id": message.message_id,
                                "disable_web_page_preview": True,
                                "reply_markup": reply_markup
                            })

            if order == "showreplylist":
                chatId = split[1]
                userId = split[2]
                TY = split[3]
                group = redis.sismember("{}Nbot:groups".format(BOT_ID), chatId)
                rank = isrank(redis, userId, chatId)
                if (rank is not False or rank is not 0 or rank != "vip"
                        or rank != "admin") and group is True:
                    li = redis.hkeys("{}Nbot:{}:{}".format(BOT_ID, chatId, TY))
                    if li:
                        i = 1
                        words = ""
                        for word in li:
                            words = words + "\n" + str(i) + " - {" + word + "}"
                            i += 1
                            if len(words) > 3000:
                                Bot(
                                    "sendMessage", {
                                        "chat_id": userId,
                                        "text": words,
                                        "reply_to_message_id":
                                        message.message_id,
                                        "parse_mode": "html"
                                    })
                                words = ''
                        Bot(
                            "sendMessage", {
                                "chat_id": userId,
                                "text": words,
                                "reply_to_message_id": message.message_id,
                                "parse_mode": "html"
                            })
                        reply_markup = InlineKeyboardMarkup([[
                            InlineKeyboardButton(r.Delall2R,
                                                 callback_data=json.dumps([
                                                     "del{}".format(TY),
                                                     chatId, userID
                                                 ])),
                        ]])
                        Bot(
                            "sendMessage", {
                                "chat_id": chatID,
                                "text": r.DelallR,
                                "reply_to_message_id": message.message_id,
                                "disable_web_page_preview": True,
                                "reply_markup": reply_markup
                            })

            if order == "showBlocklist":
                chatId = split[1]
                userId = split[2]
                TY = split[3]
                group = redis.sismember("{}Nbot:groups".format(BOT_ID), chatId)
                rank = isrank(redis, userId, chatId)
                if (rank is not False or rank is not 0
                        or rank != "vip") and group is True:
                    redis.hset("{}Nbot:{}:TXreplys".format(BOT_ID, chatID), tx,
                               text)
                    li = redis.smembers("{}Nbot:{}:{}".format(
                        BOT_ID, chatId, TY))
                    if li:
                        i = 1
                        words = ""
                        for ID in li:
                            reply_markup = InlineKeyboardMarkup([[
                                InlineKeyboardButton(r.Blocklistone,
                                                     callback_data=json.dumps([
                                                         "delfromb", TY,
                                                         userID, chatId
                                                     ])),
                            ]])
                            if TY == "blockanimations":
                                Bot(
                                    "sendAnimation", {
                                        "chat_id": userId,
                                        "animation": ID,
                                        "reply_markup": reply_markup
                                    })
                            if TY == "blockSTICKERs":
                                Bot(
                                    "sendSticker", {
                                        "chat_id": userId,
                                        "sticker": ID,
                                        "reply_markup": reply_markup
                                    })
                            if TY == "blockphotos":
                                Bot(
                                    "sendPhoto", {
                                        "chat_id": userId,
                                        "photo": ID,
                                        "reply_markup": reply_markup
                                    })
                            if TY == "blockTEXTs":
                                words = words + "\n" + str(
                                    i) + " - {" + ID + "}"
                                i += 1
                                print(len(words))
                                if len(words) > 3000:
                                    Bot(
                                        "sendMessage", {
                                            "chat_id": userId,
                                            "text": words,
                                            "reply_to_message_id":
                                            message.message_id,
                                            "parse_mode": "html"
                                        })
                                    words = ''
                        if TY == "blockTEXTs":

                            Bot(
                                "sendMessage", {
                                    "chat_id": userId,
                                    "text": words,
                                    "reply_to_message_id": message.message_id,
                                    "parse_mode": "html"
                                })

                        reply_markup = InlineKeyboardMarkup([[
                            InlineKeyboardButton(r.Delall2,
                                                 callback_data=json.dumps([
                                                     "delBL", TY, userID,
                                                     chatId
                                                 ])),
                        ]])
                        Bot(
                            "sendMessage", {
                                "chat_id": userId,
                                "text": r.Delall,
                                "reply_to_message_id": message.message_id,
                                "parse_mode": "html",
                                "reply_markup": reply_markup
                            })
                    else:
                        Bot(
                            "sendMessage", {
                                "chat_id": userId,
                                "text": r.listempty2,
                                "reply_to_message_id": message.message_id,
                                "parse_mode": "html"
                            })
예제 #20
0
from utils import *
from filters import *

logging.basicConfig(filename="logs.txt",
                    format='%(asctime)s %(message)s',
                    filemode='a')
logger = logging.getLogger()
app = Client("my_bot",
             config.api_id,
             config.api_hash,
             bot_token=config.token,
             workers=config.threads)

sleeping_time = 15

home_markup = ReplyKeyboardMarkup(
    [["Balance", "Spend"], ["Top up", "How to use?"]], resize_keyboard=True)
help_markup = InlineKeyboardMarkup([[
    InlineKeyboardButton("Add LIKE bot to your group",
                         url="https://t.me/minterlikebot?startgroup=hbase")
]])


@app.on_message(Filters.command(["start"]) & Filters.private)
def send_welcome(client, message):
    tg_analytic.statistics(message.chat.id, "start")
    app.send_message(
        message.chat.id,
        f"Hi! Get LIKEs in groups and spend on anything.\n\nFor group owner: Add @MinterLikeBot to your group to get 10% of each transaction.",
        reply_markup=home_markup)

예제 #21
0
        ob_havo = get_weather() or ob_havo
        bosh = bosh_shablon.format(hafta[dt.date.today().weekday()],
                                   dt.date.today(), *ob_havo)


edit_home()
bolimlar = ReplyKeyboardMarkup(
    [
        ["1⃣ Suyuq Taomlar", "2⃣ Quyuq Taomlar"],
        [
            "🍜 Uyg'ur Taomlar",
            "🍢 Kaboblar",
        ],
        ["🍻 BAR", "🥗 Salatlar"],
        [
            korzina,  # tayyor
            buyurtma
        ],
        [sozlamalar, qoidalar],
        [
            boglanish,  # tayyor
            manzil_  # tayyor
        ],
    ],
    resize_keyboard=True)
raqamlar = ReplyKeyboardMarkup([["1", "2", "3"], ["4", "5", "6"],
                                ["7", "8", "9"], [ortga, menu], [
                                    korzina,
                                ]],
                               resize_keyboard=True)
예제 #22
0
def handle_text(c, m: Message):
    edit_home()
    global buyurtmalar, temp, info
    if m.text.lower() == "yangila":
        yangilash()
        return
    if m.chat.id == -1001149535338:
        yangilash()
        return
    if m.chat.id == guruh_id:
        if m.text.lower().startswith("info"):
            text = "Bugun:\n"
            for k, v in info.items():
                text += "{}ta {};\n".format(v, k)
            text += "sotildi"
            bot.send_message(m.chat.id, text)
            return
        elif m.text.lower().startswith("tozala"):
            info = {}
            m.reply("Ma'lumotlar to'liq tozalandi!")
            return
        elif m.text.lower().startswith("javob"):
            if m.text.split("\n")[1] == "hammaga":
                for i in phone_numbers.keys():
                    try:
                        bot.send_message(i, '\n'.join(m.text.split('\n')[2:]))
                    except:
                        pass
            else:
                try:
                    bot.send_message(
                        m.text.split('\n')[1],
                        '\n'.join(m.text.split('\n')[2:]))
                except:
                    pass
            return
    elif m.text == ortga:
        fikr[m.chat.id] = None
        if not temp.get(m.chat.id) or len(temp.get(m.chat.id, [])) <= 1:
            temp[m.chat.id] = None
            bot.send_message(m.chat.id, bosh, reply_markup=bolimlar)
            return
        else:
            # print(1)
            temp[m.chat.id] = [temp[m.chat.id][0]]
            x = []
            try:
                bot.send_message(m.chat.id,
                                 choice(faktlar[temp[m.chat.id][0]]))
            except:
                pass
            for i, t in enumerate(taomlar[temp[m.chat.id][0]]):
                a, b = i // 2, i % 2
                if b == 0:
                    x.append([])
                x[a].append(t[1])
            x.append([ortga, korzina])
            x.append([buyurtma])
            # print(2)
            x = ReplyKeyboardMarkup(x, resize_keyboard=True)
            bot.send_message(m.chat.id,
                             "{} :".format(temp[m.chat.id][0]),
                             reply_markup=x)
            return
    elif fikr.get(m.chat.id, 0):
        text = "{} `{}` mavzu: {}\n\n".format(m.from_user.first_name,
                                              m.from_user.id, fikr[m.chat.id])
        text += m.text
        bot.send_message(guruh_id, text)
        bot.send_message(
            m.chat.id,
            "Rahmat adminstratorlar albatta siz bilan bo'glanadi.",
            reply_markup=bolimlar)
        fikr[m.chat.id] = None
    elif m.text == manzil_:
        bot.send_location(m.chat.id, 41.120233069494155, 69.07184731700151)
        bot.send_message(
            m.chat.id, """🍴 Ezaz Milliy Taomlar:

🇺🇿 Toshkent viloyati,Yangiyo'l shahar,Toshkent shox. 34-uy.  
""")
        return
    elif m.text == menu:
        bot.send_message(m.chat.id, bosh, reply_markup=bolimlar)
        temp[m.chat.id] = None
        return
    elif m.text == boglanish:
        x = ReplyKeyboardMarkup(
            [[shikoyat], [taklif], [xatolik], [shunchaki], [
                ortga,
            ]],
            resize_keyboard=True)
        bot.send_message(m.chat.id,
                         """✉️ Telegram orqali: @EzazAdmin 

📞 Telefon orqali: +998951466616

📧 Elektron Pochta: 
[email protected]

📷 Instagram: 
http://instagram.com/ezazmilliytaomlar

<b>✍ Marhamat: qay tarzda bog'lanmoqchisiz ?</b>""",
                         reply_markup=x)
        return
    elif m.text == qoidalar:
        bot.send_message(
            m.chat.id, """
        👤 <b>Hurmatli mijoz,</b>siz tanlagan taomlar uchun doimiy ravishda "Bir martalik" idish qo'shib oboriladi.
shuning uchun BOT avtomatik tarzda Quyuq taom uchun: quyuq idish(1000so'm) suyuq taom uchun: suyuq idish(1500so'm) hisoblaydi.

🛵 Yetkazib berish xizmatimiz Yangiyo'l shahar va Tumanida amal qiladi.Yetkazib berish xizmatimiz 3kmdan uzoq masofaga km hisobida 1000so'mdan qo'shib boriladi.Bu ishni BOTning o'zi avtomatik tarzda bajaradi.

⚠️Bundan tashqari albatta mahsulot yetkazib berilgandan so'ng siz mahsulotlar nomi yozilgan mahsus chekni talab qilishingiz mumkun bo'ladi.

👨‍💻Shikoyat yoki qandaydir taklif murojaatlar bo'lsa "Bog'lanish" bo'limiga o'tishingiz mumkin,Adminstratorlar albatta siz bilan bog'lanadi.

👤 KONTAKTLAR:
@EZAZSUPPORTBOT
+998951466616
+998903366807
""")
    elif m.text == korzina:
        try:
            if not buyurtmalar[m.chat.id]:
                bot.send_message(
                    m.chat.id,
                    "🧐 Siz hali taom tanlamadingiz \"🔙 Ortga\" qaytib taom tanlang va Savatga yig'ib "
                    "boring.🛒",
                    reply_markup=ReplyKeyboardMarkup([[ortga]],
                                                     resize_keyboard=True))
                return
        except KeyError:
            buyurtmalar[m.chat.id] = []
            bot.send_message(
                m.chat.id,
                '🧐 Siz hali taom tanlamadingiz "🔙 Ortga" qaytib taom tanlang va Savatga yig\'ib boring.🛒',
                reply_markup=ReplyKeyboardMarkup([[ortga]],
                                                 resize_keyboard=True))
            return
        else:
            x = []
            text = "👇 Siz tanlagan taomlar:\n\n"
            for i in buyurtmalar[m.chat.id]:
                # print(i)
                text += "{}x{}: {}00\n".format(i[2], i[0], i[1] * i[2])
                x.append([
                    KeyboardButton("❌ {}ni bekor qilish".format(i[0]),
                                   request_contact=False)
                ])
            x.append([buyurtma])
            x.append([tozalash])
            x.append([ortga])
            x = ReplyKeyboardMarkup(x, resize_keyboard=True)
            bot.send_message(m.chat.id, text, reply_markup=x)
            return
    elif m.text == sozlamalar:
        bot.send_message(
            m.chat.id,
            "Sozlamalar orqali siz bilan bog'lanishimiz mumkin bo'lgan raqamingizni o'zgartirishingiz mumkin:",
            reply_markup=ReplyKeyboardMarkup(
                [[KeyboardButton(telefon, request_contact=True)], [ortga]],
                resize_keyboard=True))
        return
    elif m.text == tozalash:
        buyurtmalar[m.chat.id] = []
        bot.send_message(m.chat.id,
                         """Siz tanlagan barcha taomlar to'liq tozalandi.
       
        👇 Kerakli taomlar bo'limni tanlang:""",
                         reply_markup=ReplyKeyboardMarkup(
                             [[ortga, menu]], resize_keyboard=True))
        return
    elif m.text == shikoyat:
        fikr[m.chat.id] = 'shikoyat'
        bot.send_message(m.chat.id,
                         """<b>Qanday shikoyat qilmoqchisiz ?</b>

🔸 O'z fikringizni yozib qoldiring albatta inobatga olamiz:""",
                         reply_markup=ReplyKeyboardMarkup(
                             [[ortga]], resize_keyboard=True))
        return
    elif m.text == taklif:
        fikr[m.chat.id] = 'taklif'
        bot.send_message(m.chat.id,
                         """<b>Qanday taklifingiz bor ?</b>

🔸 O'z fikringizni yozib qoldiring albatta inobatga olamiz:""",
                         reply_markup=ReplyKeyboardMarkup(
                             [[ortga]], resize_keyboard=True))
        return
    elif m.text == xatolik:
        fikr[m.chat.id] = 'xatolik'
        bot.send_message(m.chat.id,
                         """<b>Qanday xatolik topdingiz ?</b>

🔸 O'z fikringizni yozib qoldiring albatta inobatga olamiz:""",
                         reply_markup=ReplyKeyboardMarkup(
                             [[ortga]], resize_keyboard=True))
        return
    elif m.text == shunchaki:
        fikr[m.chat.id] = 'shunchaki'
        bot.send_message(
            m.chat.id,
            """🔸 O'z fikringizni yozib qoldiring albatta inobatga olamiz:""",
            reply_markup=ReplyKeyboardMarkup([[ortga]], resize_keyboard=True))
        return

    elif m.text == buyurtma:
        x = buyurtmalar.get(m.chat.id, None)
        if x is None:
            buyurtmalar[m.chat.id] = []
        if not x:
            bot.send_message(
                m.chat.id,
                '🧐 Siz hali taom tanlamadingiz "🔙 Ortga" qaytib taom tanlang va Savatga yig\'ib boring.🛒',
                reply_markup=ReplyKeyboardMarkup([[ortga, menu]],
                                                 resize_keyboard=True))
            return

        jami = 0.0
        text = "👇 Siz tanlagan taomlar: \n\n"
        for i in buyurtmalar[m.chat.id]:
            # print(i)
            text += "{} x {}: {}00\n".format(i[2], i[0], i[1] * i[2])
            jami += i[1] * i[2]
        bot.send_message(m.chat.id, text)
        x = ReplyKeyboardMarkup([[ha], [yuq], [qol]], resize_keyboard=True)
        bot.send_message(m.chat.id, "Tasdiqlaysizmi ❓", reply_markup=x)
        return
    elif m.text == ha and not xizmat_narxi.get(m.chat.id, 0):
        manzil[m.chat.id] = True
        bot.send_message(
            m.chat.id,
            """Iltimos oldin manzilni aniqlash uchun "📍<b>Geolokatsiya</b>" tugmasini bosib manzilni jo'nating:""",
            reply_markup=ReplyKeyboardMarkup(
                [[KeyboardButton("📍 Geolokatsiya", request_location=True)]],
                resize_keyboard=True))

        return
    elif m.text == ha:
        komment[m.chat.id] = True
        bot.send_message(
            m.chat.id,
            "💬 Istasangiz, buyurtmangiz haqida izoh kommentariya yozib qoldirishingiz mumkin.Biz uni albatta inobatga olamiz.",
            reply_markup=ReplyKeyboardMarkup([["Shart emas"]],
                                             resize_keyboard=True))
        return
    elif m.text == yuq:
        buyurtmalar[m.chat.id] = []
        bot.send_message(m.chat.id,
                         """Siz tanlagan taomlaringiz to'liq tozalandi 
        
        👇 Kerakli taomlar bo'limni tanlang:""",
                         reply_markup=ReplyKeyboardMarkup(
                             [[ortga, menu]], resize_keyboard=True))
        return
    elif m.text == qol:
        bot.send_message(m.chat.id,
                         """Taomlaringiz savatda saqlandi 
        
        👇 Kerakli taomlar bo'limni tanlang:""",
                         reply_markup=ReplyKeyboardMarkup(
                             [[ortga, menu]], resize_keyboard=True))
    elif m.text in taomlar.keys():
        x = []
        try:
            bot.send_message(m.chat.id, choice(faktlar[m.text]))
        except:
            pass
        for i, t in enumerate(taomlar[m.text]):
            a, b = i // 2, i % 2
            if b == 0:
                x.append([])
            x[a].append(t[1])
        x.append([ortga, korzina])
        x = ReplyKeyboardMarkup(x, resize_keyboard=True)
        temp[m.chat.id] = [m.text]
        bot.send_message(m.chat.id, "{} :".format(m.text), reply_markup=x)
        return
    elif manzil.get(m.chat.id, 0) and komment.get(m.chat.id, 0):

        text = "{} (`{}`) {} buyurtma berdi:\n".format(
            m.from_user.first_name, m.chat.id, m.from_user.last_name or "")
        idishlar = 0.0
        jami = 0.0
        for n, i in enumerate(buyurtmalar[m.chat.id]):
            text += "{}) {} x {} {}00\n".format(n + 1, i[0], i[2], i[1] * i[2])
            jami += i[1] * i[2]
            if "suyuq" in i[-1].lower() or "uyg'ur" in i[-1].lower():
                idishlar += 1.5 * i[2]
            if "quyuq" in i[-1].lower() or "salatlar" in i[-1].lower():
                idishlar += 1.0 * i[2]
        if idishlar:
            text += "🍽 Bir martalik idishlar: {}00\n".format(idishlar)
        text += "🛵 Yetkazib berish hizmati: {}00\n".format(
            xizmat_narxi[m.chat.id])
        jami += xizmat_narxi[m.chat.id]
        text += "🔖 Jami: {0}00\n\n".format(jami + idishlar)
        text += "📞 Tel: {}\n📍 Manzil: {}".format(phone_numbers[m.chat.id],
                                                 manzil[m.chat.id])
        text += "\n💬 Komment: {}".format(m.text)
        bot.send_message(guruh_id, text)
        bot.send_location(guruh_id, *geolokatsiya[m.chat.id])
        for i in buyurtmalar[m.chat.id]:
            a = info.get(i[-1], 0) + i[2]
            info[i[-1]] = a
        temp[m.chat.id] = None
        manzil[m.chat.id] = None
        komment[m.chat.id] = None
        buyurtmalar[m.chat.id] = []
        bot.send_message(
            m.chat.id,
            "Rahmat,tez orada adminstratorlarimiz albatta siz bilan bog'lanishadi "
            "👇 Kerakli taomlar bo'limini tanlang:",
            reply_markup=bolimlar)
        return
    elif "bekor qilish" in m.text:
        import re
        s = re.search(r"(\w*) bekor", m.text)
        s = s.groups()[0][:-2]
        # print(s)
        for i in buyurtmalar[m.chat.id]:
            if s in i[0]:
                buyurtmalar[m.chat.id].remove(i)
                break
        x = []
        jami = 6.0
        text = "👇 Siz tanlagan taomlar:\n\n"
        for i in buyurtmalar[m.chat.id]:
            # print(i)
            text += "{}x{}: {}00\n".format(i[2], i[0], i[1] * i[2])
            jami += i[1] * i[2]
            x.append([
                KeyboardButton("❌ {}ni bekor qilish".format(i[0]),
                               request_contact=False)
            ])
        x.append([buyurtma])
        x.append([tozalash])
        x.append([ortga])
        text += "\nYetkazib berish: 6.000\n\nJami: {}00".format(jami)
        x = ReplyKeyboardMarkup(x, resize_keyboard=True)
        bot.send_message(m.chat.id, text, reply_markup=x)
        return

    elif temp.get(m.chat.id, 0) and len(temp[m.chat.id]) == 1:
        bol = temp[m.chat.id][0]
        x = None
        for i in taomlar[bol]:
            if m.text in i:
                x = i
                break
        if x is None:
            return
        # print(x)
        if "ro'yxat" in m.text.lower():
            bot.send_photo(m.chat.id, x[0])
            return
        temp[m.chat.id].append(m.text)
        temp[m.chat.id].append(x[2])

        if x[3]:
            bot.send_photo(
                m.chat.id,
                x[0],
                caption="""{}\nNarxi: {}00so'm""".format(x[1], x[2]),
                reply_markup=ReplyKeyboardMarkup([[x[3]], [x[4]]],
                                                 resize_keyboard=True))
            if x[-1]:
                bot.send_message(m.chat.id, x[-1])
        else:
            bot.send_photo(m.chat.id,
                           x[0],
                           caption="""{}\nNarxi: {}00so'm""".format(
                               x[1], x[2]),
                           reply_markup=raqamlar)
            if x[-1]:
                bot.send_message(m.chat.id, x[-1])
            bot.send_message(m.chat.id,
                             "👇 Miqdorni kiriting yoki o'zingiz yozing:")

        return
    elif temp.get(m.chat.id, 0) and len(temp[m.chat.id]) == 3:
        if len(m.text) <= 2:
            soni = int(m.text)
            temp[m.chat.id].append(soni)

            try:  # nomi     #narxi         #soni
                buyurtmalar[m.chat.id].append(
                    (temp[m.chat.id][1], temp[m.chat.id][2], soni,
                     temp[m.chat.id][0]))
            except KeyError:
                buyurtmalar[m.chat.id] = []
                buyurtmalar[m.chat.id].append(
                    (temp[m.chat.id][1], temp[m.chat.id][2], soni,
                     temp[m.chat.id][0]))
            bot.send_message(
                m.chat.id,
                "🛒 Siz tanlagan taomlar savatga qo'shildi  Buyurtma Berish bo'limiga kirib buyurtma qilishingiz mumkin!"
                "",
                reply_markup=bolimlar)
            return
        else:
            temp[m.chat.id][1] += "  {}".format(m.text)
            bot.send_message(m.chat.id,
                             "👇 Miqdorni kiriting yoki o'zingiz yozing:",
                             reply_markup=raqamlar)
    elif m.text == "🔙 Ortga":
        bot.send_message(m.chat.id,
                         "👇 Kerakli taomlar bo'limini tanlang:",
                         reply_markup=bolimlar)
        temp[m.chat.id] = None
        return
    elif m.text == "👨‍💻 Bog'lanish":
        bot.send_message(
            m.chat.id, """✉️ Telegram orqali: @EzazAdmin 

📞 Telefon orqali: +998951466616

📧 Elektron Pochta: 
[email protected]

📷 Instagram: 
http://instagram.com/ezazmilliytaomlar """)
        return
예제 #23
0
from pyrogram import Client, Filters, InlineKeyboardMarkup, InlineKeyboardButton, ReplyKeyboardMarkup, ReplyKeyboardRemove
from os import listdir

KekikRAT = Client(
    api_id=xxxxx,                                  # my.telegram.org/apps
    api_hash="xxxx",    # my.telegram.org/apps
    session_name = "@KekikRAT",                     # Fark Etmez
    bot_token = "xxxx:xxxx",               # @BotFather
)

adminID = xxxx                                 # Kendi Kullanıcı id'niz

main_keyboard = ReplyKeyboardMarkup(
    [
        ['1'],
        ['2'],
        ['3']
    ],
    resize_keyboard=True
)

@KekikRAT.on_message(Filters.command(['start'], ['!','.','/']))
def start(client, message):
    # Hoş Geldin Mesajı
    message.reply_chat_action("typing")
    client.send_message(message.from_user.id,text='text',reply_markup=main_keyboard)
    message.reply(f"☣ **KekikRAT** ☣\n\nBütün veriler [Patron](tg://user?id={adminID})'a Gönderilecek!")

    # LOG Alanı
    log = f"[{message.from_user.first_name}](tg://user?id={message.from_user.id}) | Bota Bağlantı Sağladı"
    #client.send_message(adminID, "Look at that button!", reply_markup=ReplyKeyboardMarkup([["Nice!"]]))
예제 #24
0
async def add_bot(_client: Client,
                  callback: CallbackQuery,
                  message="What's the username of your group?"):
    await callback.message.delete()
    username = await _client.ask(callback.message.chat.id, message)  # noqa
    if str(username.text) == '/start':
        return await start_handler(_client, callback.message)
    try:
        username = str(username.text)
        if username.isdigit():
            if username.isdigit():
                return (await add_bot(
                    _client, callback,
                    "Do not send an ID, only username. try again.\n"
                    "What's the username of your channel?"))
        group = await _client.get_chat(username)
    except (IndexError, ValueError, KeyError, UsernameNotOccupied,
            UsernameInvalid, PeerIdInvalid) as e:
        return (await add_bot(
            _client, callback,
            ("username not exist. try again.\n" if not isinstance(
                e, IndexError) else 'Something went wrong, try again\n') +
            "What's the username of your group?"))

    if group.type not in ('group', 'supergroup'):
        await add_bot(
            _client, callback,
            "This username not belong to a group, try again.\n"
            "What's the username of your group?")
    else:
        code = get_code()
        await _client.ask(
            callback.message.chat.id, "How to authorise the group:\n"
            "Go to 'manage group'\n"
            f"Then add this code: `{code}` to your group description,\n"
            f"then press 'Done'\n"
            "[Then remove this from your group description]",
            timeout=200,
            filters=Filters.regex('Done'),
            reply_markup=ReplyKeyboardMarkup([[KeyboardButton('Done')]],
                                             resize_keyboard=True))
        bot = await _client.get_chat(username)
        if code in bot.description:
            await callback.message.reply('OK!',
                                         reply_markup=ReplyKeyboardRemove())
        else:
            await callback.message.reply('Code not found! try again',
                                         reply_markup=ReplyKeyboardRemove())
            return await add_bot(_client, callback)
        add = add_tg(group.id, group.title, callback.from_user.id,
                     group.username, 'group')
        if add:
            await callback.message.reply(
                "That's the details about the group:\n"
                f"🔸Owner: {callback.from_user.first_name}"
                f"{callback.from_user.last_name or ''}"
                f" [{callback.from_user.id}]\n"
                f"🔸Group name: {add.name}\n"
                f"🔸Group id: {add.id}\n" +
                (f"🔸Group username: {add.username or ''}\n" if group.
                 username else '') +
                f"\n\nRate link:\nt.me/TheRatesBot?start={add.id}")
        else:
            await callback.message.reply("The group already exist!")
예제 #25
0
def reply(tg_id):
    kb = ReplyKeyboardMarkup([["💳 My Wallet"], ["🆔 My Address"]],
                             resize_keyboard=True)
    return kb
예제 #26
0
	def generate_section_pad():
		return ReplyKeyboardMarkup( keyboard = [
			[KeyboardButton( text = x )] for x in custom_service_bot_class.SECTION
		], resize_keyboard = True, one_time_keyboard = True)