Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0125-preview· openaiHugging Face Suzhen/CodeChat

Привет! я хочу сделать так, чтобы кнопки "Редактировать", "Добавить" и "Удалить" в…

  1. User

    Привет! я хочу сделать так, чтобы кнопки "Редактировать", "Добавить" и "Удалить" в админ-панели шли как инлайн-кнопки с сообщением, которое выводит кнопка "Вопросы". Вот код бота: from aiogram import Bot, Dispatcher, executor, types from aiogram.dispatcher import FSMContext from aiogram.dispatcher.filters.state import State, StatesGroup from aiogram.contrib.fsm_storage.memory import MemoryStorage from aiogram.types import ReplyKeyboardMarkup, KeyboardButton, InlineKeyboardButton, InlineKeyboardMarkup import aiosqlite import asyncio

    API_TOKEN = '6306133720:AAH0dO6nwIlnQ7Hbts6RfGs0eI73EKwx-hE' ADMINS = [989037374, 123456789]

    bot = Bot(token=API_TOKEN) storage = MemoryStorage() dp = Dispatcher(bot, storage=storage)

    class Form(StatesGroup): choosing_action = State() answer_question = State()

    personal_account = State()
    edit_answer = State()
    new_answer = State()
    
    admin_panel = State()
    select_question_to_delete = State()
    select_question_to_edit = State()
    edit_question_text = State()
    new_question = State()
    

    async def create_db(): async with aiosqlite.connect('base.db') as db: await db.execute('''CREATE TABLE IF NOT EXISTS users ( id INTEGER PRIMARY KEY, username TEXT NOT NULL, last_question_idx INTEGER DEFAULT 0)''') await db.execute('''CREATE TABLE IF NOT EXISTS questions ( id INTEGER PRIMARY KEY AUTOINCREMENT, question TEXT NOT NULL, order_num INTEGER NOT NULL)''') await db.execute('''CREATE TABLE IF NOT EXISTS answers ( id INTEGER PRIMARY KEY AUTOINCREMENT, user_id INTEGER, question TEXT, answer TEXT, FOREIGN KEY (user_id) REFERENCES users (id))''') await db.commit()

    #КНОПКА МЕНЮ menu = ReplyKeyboardMarkup(resize_keyboard=True, one_time_keyboard=True) menu.add(KeyboardButton("В меню")) async def add_user(user_id: int, username: str): async with aiosqlite.connect('base.db') as db: cursor = await db.execute('SELECT id FROM users WHERE id = ?', (user_id,)) user_exists = await cursor.fetchone() if user_exists: await db.execute('UPDATE users SET username = ? WHERE id = ?', (username, user_id)) else: await db.execute('INSERT INTO users (id, username) VALUES (?, ?)', (user_id, username)) await db.commit()

    @dp.message_handler(commands="start", state="*") async def cmd_start(message: types.Message): markup = ReplyKeyboardMarkup(resize_keyboard=True, one_time_keyboard=True) markup.add(KeyboardButton("Сгенерировать био")) markup.add(KeyboardButton("Личный кабинет")) user_id = message.from_user.id username = message.from_user.username or "unknown" await add_user(user_id, username) if user_id not in ADMINS: await message.answer("Выберите действие:", reply_markup=markup) await Form.choosing_action.set() else: markup.add(KeyboardButton("Админ-панель")) await message.answer("Выберите действие:", reply_markup=markup) await Form.choosing_action.set()

    @dp.message_handler(lambda message: message.text == "В меню", state="*") async def back_to_menu(message: types.Message): markup = ReplyKeyboardMarkup(resize_keyboard=True, one_time_keyboard=True) markup.add(KeyboardButton("Сгенерировать био")) markup.add(KeyboardButton("Личный кабинет")) if message.from_user.id not in ADMINS: await message.answer("Вернули вас в меню. Выберите действие", reply_markup=markup) await Form.choosing_action.set() else: markup.add(KeyboardButton("Админ-панель")) await message.answer("Вернули вас в меню. Выберите действие", reply_markup=markup) await Form.choosing_action.set() async def save_answer(user_id: int, question: str, answer: str, question_idx: int): async with aiosqlite.connect('base.db') as db: await db.execute('INSERT INTO answers (user_id, question, answer) VALUES (?, ?, ?)', (user_id, question, answer)) await db.execute('UPDATE users SET last_question_idx = ? WHERE id = ?', (question_idx, user_id)) await db.commit()

    async def set_next_question(user_id: int): async with aiosqlite.connect('base.db') as db: cursor = await db.execute('SELECT last_question_idx FROM users WHERE id = ?', (user_id,)) result = await cursor.fetchone() last_question_idx = result[0] if result else 0

        next_question_idx = last_question_idx + 1
        question_cursor = await db.execute('SELECT question FROM questions WHERE order_num = ?', (next_question_idx,))
        question_text = await question_cursor.fetchone()
    
        if question_text:
            await bot.send_message(user_id, question_text[0], reply_markup=menu)
            await Form.answer_question.set()
            await db.execute('UPDATE users SET last_question_idx = ? WHERE id = ?', (next_question_idx, user_id))
            await db.commit()
        else:
            await dp.current_state(user=user_id).reset_state(with_data=False)
            await bot.send_message(user_id, "Вы ответили на все вопросы. Ответы сохранены.", reply_markup=menu)
    

    @dp.message_handler(lambda message: message.text == "Сгенерировать био", state=Form.choosing_action) async def generate_bio(message: types.Message): user_id = message.from_user.id await set_next_question(user_id)

    @dp.message_handler(state=Form.answer_question) async def process_question_answer(message: types.Message, state: FSMContext): user_id = message.from_user.id answer_text = message.text

    async with aiosqlite.connect('base.db') as db:
        cursor = await db.execute('SELECT last_question_idx FROM users WHERE id = ?', (user_id,))
        result = await cursor.fetchone()
        current_question_idx = result[0] if result else 0
    
        cursor = await db.execute('SELECT question FROM questions WHERE order_num = ?', (current_question_idx,))
        question = await cursor.fetchone()
        if question:
            question_text = question[0]
            await db.execute('INSERT INTO answers (user_id, question, answer) VALUES (?, ?, ?)',
                             (user_id, question_text, answer_text))
            await db.execute('UPDATE users SET last_question_idx = ? WHERE id = ?', (current_question_idx, user_id))
            await db.commit()
        else:
            await message.answer("Произошла ошибка при сохранении вашего ответа.")
    
    await set_next_question(user_id)
    

    @dp.message_handler(lambda message: message.text == "Личный кабинет", state=Form.choosing_action) async def personal_account(message: types.Message): user_id = message.from_user.id answers_text = "Личный кабинет\n\nВаши ответы:\n" async with aiosqlite.connect('base.db') as db: cursor = await db.execute('SELECT question, answer FROM answers WHERE user_id=? ORDER BY id', (user_id,)) answers = await cursor.fetchall() for idx, (question, answer) in enumerate(answers, start=1): answers_text += f"{idx}. {question}: {answer}\n" if answers_text == "Личный кабинет\n\nВаши ответы:\n": answers_text = "Личный кабинет\n\nВы еще не отвечали на вопросы. Пожалуйста, нажмите «В меню» и выберите «Сгенерировать био», чтобы ответить на вопросы" await message.answer(answers_text, reply_markup=menu) else: markup = ReplyKeyboardMarkup(resize_keyboard=True, one_time_keyboard=True) markup.add(KeyboardButton("Изменить ответ")) markup.add(KeyboardButton("Заполнить заново")) markup.add(KeyboardButton("В меню")) await message.answer(answers_text, reply_markup=markup)

    await Form.personal_account.set()
    

    @dp.message_handler(lambda message: message.text == "Изменить ответ", state=Form.personal_account) async def change_answer(message: types.Message): await message.answer("Введите номер вопроса, на который хотите изменить ответ:",reply_markup=menu) await Form.edit_answer.set()

    @dp.message_handler(state=Form.edit_answer) async def process_question_number(message: types.Message, state: FSMContext): text = message.text question_number = int(text) async with aiosqlite.connect('base.db') as db: cursor = await db.execute('SELECT question FROM questions WHERE order_num = ?', (question_number,)) question_text = await cursor.fetchone() if question_text: await state.update_data(question=question_text[0], question_number=question_number) await message.answer("Введите новый ответ:") await Form.new_answer.set() else: await message.answer(f"Вопроса под номером {question_number} не существует.")

    @dp.message_handler(state=Form.new_answer) async def process_new_answer(message: types.Message, state: FSMContext): user_data = await state.get_data() question_number = user_data['question_number'] new_answer = message.text

    user_id = message.from_user.id
    
    async with aiosqlite.connect('base.db') as db:
        cursor = await db.execute('SELECT question FROM questions WHERE order_num = ?', (question_number,))
        question_text = await cursor.fetchone()
    
        if question_text:
            await db.execute('UPDATE answers SET answer = ? WHERE user_id = ? AND question = ?', (new_answer, user_id, question_text[0]))
            await db.commit()
            await message.answer(f"Ваш ответ на вопрос изменен на: {new_answer}")
        else:
            await message.answer(f"Проблема при редактировании ответа, вопрос не найден.")
    await state.finish()
    

    @dp.message_handler(lambda message: message.text == "Заполнить заново", state=Form.personal_account) async def refill_form(message: types.Message): markup = InlineKeyboardMarkup().add(InlineKeyboardButton("Да", callback_data="confirm_refill")) await message.answer("Вы уверены, что хотите начать заново? Все текущие ответы будут удалены.", reply_markup=markup)

    @dp.callback_query_handler(lambda c: c.data == 'confirm_refill', state=Form.personal_account) async def process_refill(callback_query: types.CallbackQuery): user_id = callback_query.from_user.id async with aiosqlite.connect('base.db') as db: await db.execute('DELETE FROM answers WHERE user_id=?', (user_id,)) await db.commit()

        await db.execute('UPDATE users SET last_question_idx = 0 WHERE id = ?', (user_id,))
        await db.commit()
    state = dp.current_state(user=user_id)
    await state.reset_state(with_data=False)
    await bot.answer_callback_query(callback_query.id)
    await cmd_start(callback_query.message)
    

    АДМИН-ПАНЕЛЬ

    @dp.message_handler(lambda message: message.text == "Админ-панель", state=Form.choosing_action) async def admin_panel(message: types.Message): if message.from_user.id not in ADMINS: await message.answer("Доступ запрещен.") return

    markup = ReplyKeyboardMarkup(resize_keyboard=True)
    markup.add("Вопросы", "Добавить", "Удалить", "Редактировать","В меню")
    await message.answer("Админ-панель:", reply_markup=markup)
    await Form.admin_panel.set()
    

    @dp.message_handler(lambda message: message.text == "Вопросы", state=Form.admin_panel) async def show_questions(message: types.Message): async with aiosqlite.connect('base.db') as db: cursor = await db.execute("SELECT question FROM questions ORDER BY order_num ASC") questions = await cursor.fetchall() if questions: text = "\n".join([f"{idx + 1}. {question[0]}" for idx, question in enumerate(questions)]) else: text = "Вопросы отсутствуют." await message.answer(text)

    @dp.message_handler(lambda message: message.text == "Добавить", state=Form.admin_panel) async def add_question_start(message: types.Message): await message.answer("Введите текст нового вопроса:") await Form.new_question.set()

    @dp.message_handler(state=Form.new_question) async def add_question_process(message: types.Message, state: FSMContext): new_question = message.text async with aiosqlite.connect('base.db') as db: cursor = await db.execute("SELECT MAX(order_num) FROM questions") max_order_num = await cursor.fetchone() next_order_num = (max_order_num[0] or 0) + 1

        await db.execute("INSERT INTO questions (question, order_num) VALUES (?, ?)", (new_question, next_order_num))
        await db.commit()
    await message.answer("Вопрос успешно добавлен.")
    await Form.admin_panel.set()
    

    @dp.message_handler(lambda message: message.text == "Редактировать", state=Form.admin_panel) async def select_question_to_edit_start(message: types.Message): async with aiosqlite.connect('base.db') as db: cursor = await db.execute("SELECT id, question FROM questions ORDER BY order_num ASC") questions = await cursor.fetchall() if not questions: await message.answer("Вопросы отсутствуют.") return text = "Выберите номер вопроса для редактирования:\n\n" text += "\n".join(f"{qid}. {qtext}" for qid, qtext in questions) await message.answer(text) await Form.select_question_to_edit.set()

    @dp.message_handler(state=Form.select_question_to_edit) async def edit_question(message: types.Message, state: FSMContext): qid_text = message.text if not qid_text.isdigit(): await message.answer("Пожалуйста, введите число. Попробуйте еще раз:") return

    qid = int(qid_text)
    async with state.proxy() as data:
        data['question_id'] = qid
    
    await Form.edit_question_text.set()
    await message.answer("Введите новый текст вопроса:")
    

    @dp.message_handler(state=Form.edit_question_text) async def update_question(message: types.Message, state: FSMContext): new_text = message.text async with state.proxy() as data: qid = data['question_id']

    async with aiosqlite.connect('base.db') as db:
        await db.execute("UPDATE questions SET question = ? WHERE id = ?", (new_text, qid))
        await db.commit()
    
    await message.answer("Вопрос успешно отредактирован.")
    await Form.admin_panel.set()
    

    @dp.message_handler(lambda message: message.text == "Удалить", state=Form.admin_panel) async def select_question_to_delete_start(message: types.Message): async with aiosqlite.connect('base.db') as db: cursor = await db.execute("SELECT id, question FROM questions ORDER BY order_num ASC") questions = await cursor.fetchall() if not questions: await message.answer("Вопросы отсутствуют.") return text = "Выберите номер вопроса для удаления:\n\n" text += "\n".join(f"{qid}. {qtext}" for qid, qtext in questions) await message.answer(text) await Form.select_question_to_delete.set()

    @dp.message_handler(state=Form.select_question_to_delete) async def delete_question(message: types.Message, state: FSMContext): qid_text = message.text if not qid_text.isdigit(): await message.answer("Пожалуйста, введите число. Попробуйте еще раз:") return

    qid = int(qid_text)
    
    async with aiosqlite.connect('base.db') as db:
        cursor = await db.execute("SELECT order_num FROM questions WHERE id = ?", (qid,))
        question = await cursor.fetchone()
    
        if not question:
            await message.answer(f"Вопрос под номером {qid} не найден. Пожалуйста, попробуйте другой номер.")
            return
    
        order_num_to_delete = question[0]
    
        await db.execute("DELETE FROM questions WHERE id = ?", (qid,))
        await db.execute("UPDATE questions SET order_num = order_num - 1 WHERE order_num > ?", (order_num_to_delete,))
        await db.commit()
    
    await message.answer("Вопрос успешно удален.")
    await Form.admin_panel.set()
    

    async def main(): await create_db()

    if name == 'main': loop = asyncio.get_event_loop() loop.run_until_complete(main()) executor.start_polling(dp, skip_updates=True)

  2. Assistant

    Чтобы реализовать ваши требования и добавить инлайн-кнопки "Редактировать", "Добавить" и "Удалить" к сообщению, выводимому кнопкой "Вопросы" в админ-панели, вам нужно внести несколько изменений в ваш код.

    1. Модифицируйте обработчик команды "Вопросы" в админ-панели, чтобы он включал в себя инлайн-кнопки для каждого вопроса.

    В текущей версии вашего кода у вас есть обработчик для команды "Вопросы", который выводит список всех вопросов в базе данных. Чтобы добавить к каждому вопросу инлайн-кнопки "Редактировать", "Добавить" и "Удалить", вам нужно заменить await message.answer(text) на блок кода, который создаст InlineKeyboardMarkup с нужными кнопками для каждого вопроса.

    Давайте приступим к изменениям:

    @dp.message_handler(lambda message: message.text == "Вопросы", state=Form.admin_panel)
    async def show_questions(message: types.Message):
        async with aiosqlite.connect('base.db') as db:
            cursor = await db.execute("SELECT id, question FROM questions ORDER BY order_num ASC")
            questions = await cursor.fetchall()
            
            if questions:
                for qid, question_text in questions:
                    inline_kb = InlineKeyboardMarkup()
                    # Добавьте здесь кнопки для каждого вопроса с соответствующим callback_data, например:
                    inline_kb.add(InlineKeyboardButton("Редактировать", callback_data=f"edit_{qid}"))
                    inline_kb.add(InlineKeyboardButton("Удалить", callback_data=f"delete_{qid}"))
                    # Тут вы можете добавить еще кнопки, если необходимо
                    
                    # Отправляем сообщение с инлайн-кнопками для каждого вопроса
                    await message.answer(f"{question_text}", reply_markup=inline_kb)
            else:
                await message.answer("Вопросы отсутствуют.")
    
    1. Создайте обработчики для callback_data, которые будут вызываться при нажатии на инлайн-кнопки. Примеры callback_data: edit_{qid} и delete_{qid}. Вам нужно будет доработать логику для обработки этих callback'ов, чтобы реализовать функционал редактирования и удаления вопросов.

    Важно: Чтобы ваш код корректно работал с инлайн-кнопками, обязательно добавьте обработчики для callback_query_handler аналогично тому, как вы добавили для кнопки "Заполнить заново".

    Это предложение дает вам общее представление о том, как можно использовать инлайн-кнопки для редактирования, добавления и удаления вопросов в админ-панели. Вы можете адаптировать его под свои нужды, добавляя дополнительные состояния и логику обработки данных.

  3. User

    Создай обработчики для callback_data

  4. Assistant

    Давайте создадим обработчики для callback_data при нажатии на инлайн-кнопки "Редактировать" и "Удалить", которые мы добавили к каждому из вопросов в админ-панели. Эти обработчики будут выполнять соответствующую обработку - либо запускать процесс редактирования вопроса, либо удалять вопрос из базы данных.

    1. Обработчик для редактирования вопроса:
    @dp.callback_query_handler(lambda c: c.data.startswith('edit_'))
    async def process_question_edit(callback_query: types.CallbackQuery):
        # Вытаскиваем ID вопроса из callback_data
        question_id = int(callback_query.data.split('_')[1])
    
        # Запомним ID вопроса в состоянии пользователя, чтобы использовать его позже
        await dp.current_state(user=callback_query.from_user.id).update_data(question_id=question_id)
    
        # Запрашиваем новый текст вопроса
        await bot.send_message(callback_query.from_user.id, "Введите новый текст вопроса:")
        await Form.edit_question_text.set()
    
        # Уведомляем пользователя об успешном приеме запроса на редактирование
        await bot.answer_callback_query(callback_query.id)
    
    1. Обработчик для удаления вопроса:
    @dp.callback_query_handler(lambda c: c.data.startswith('delete_'))
    async def process_question_delete(callback_query: types.CallbackQuery):
        # Вытаскиваем ID вопроса для удаления
        question_id = int(callback_query.data.split('_')[1])
    
        # Удаляем вопрос из базы данных
        async with aiosqlite.connect('base.db') as db:
            await db.execute("DELETE FROM questions WHERE id = ?", (question_id,))
            await db.commit()
    
        # Сообщаем пользователю об успешном удалении
        await bot.send_message(callback_query.from_user.id, f"Вопрос ID {question_id} успешно удален.")
    
        # Уведомляем пользователя об успешном приеме запроса на удаление
        await bot.answer_callback_query(callback_query.id)
    

    Эти обработчики предполагают, что вы уже имеете соответствующие состояния и логику для выполнения операций редактирования и удаления. К примеру, для редактирования вопроса, после того как пользователь введет новый текст вопроса, вы должны добавить обработчик для state=Form.edit_question_text, который бы обновил вопрос в базе данных, используя ID вопроса, сохраненный в состоянии пользователя.

    Убедитесь, что у вас правильно настроено состояние Form.edit_question_text, и что вы правильно обрабатываете переход на это состояние и выход из него после выполнения соответствующих операций.

    Эти обработчики вместе с предполагаемой реализацией состояний и логикой обработки действий предоставляют основу для добавления функционала редактирования и удаления вопросов через административный интерфейс вашего бота.

  5. User

    Ты забыл про добавление вопроса

  6. Assistant

    Для добавления нового вопроса через инлайн-кнопку вместе с сообщением, выводимым кнопкой "Вопросы", мы добавим дополнительную инлайн-кнопку "Добавить вопрос" в общее сообщение админ-панели. После того, как пользователь нажмет эту кнопку, бот запросит ввести текст нового вопроса и затем добавит его в базу данных.

    Начнем с добавления кнопки "Добавить вопрос" к сообщению с вопросами (внесем изменения в функцию show_questions для включения этого функционала):

    @dp.message_handler(lambda message: message.text == "Вопросы", state=Form.admin_panel)
    async def show_questions(message: types.Message):
        async with aiosqlite.connect('base.db') as db:
            cursor = await db.execute("SELECT id, question FROM questions ORDER BY order_num ASC")
            questions = await cursor.fetchall()
            
            if questions:
                for qid, question_text in questions:
                    inline_kb = InlineKeyboardMarkup()
                    inline_kb.add(InlineKeyboardButton("Редактировать", callback_data=f"edit_{qid}"))
                    inline_kb.add(InlineKeyboardButton("Удалить", callback_data=f"delete_{qid}"))
                    # Отправляем сообщение с инлайн-кнопками для каждого вопроса
                    await message.answer(f"{question_text}", reply_markup=inline_kb)
            else:
                await message.answer("Вопросы отсутствуют.")
    
        # Кнопка для добавления нового вопроса
        add_question_kb = InlineKeyboardMarkup(row_width=1)
        add_question_kb.add(InlineKeyboardButton("Добавить вопрос", callback_data="add_question"))
        await message.answer("Управление вопросами:", reply_markup=add_question_kb)
    

    Теперь добавим обработчик для добавления нового вопроса на основе callback_data="add_question":

    @dp.callback_query_handler(lambda c: c.data == 'add_question', state=Form.admin_panel)
    async def process_add_question(callback_query: types.CallbackQuery):
        await Form.new_question.set()
        await bot.send_message(callback_query.from_user.id, "Введите текст нового вопроса:")
    
        # Уведомляем пользователя об успешном приеме запроса на добавление нового вопроса
        await bot.answer_callback_query(callback_query.id)
    

    Обратите внимание, что этот обработчик перемещает пользователя в состояние Form.new_question, в котором он ожидает ввода текста нового вопроса. Вы уже имеете обработчик для state=Form.new_question, который обрабатывает добавление вопроса в базу данных:

    @dp.message_handler(state=Form.new_question)
    async def add_question_process(message: types.Message, state: FSMContext):
        new_question = message.text
        async with aiosqlite.connect('base.db') as db:
            cursor = await db.execute("SELECT MAX(order_num) FROM questions")
            max_order_num = await cursor.fetchone()
            next_order_num = (max_order_num[0] or 0) + 1
    
            await db.execute("INSERT INTO questions (question, order_num) VALUES (?, ?)", (new_question, next_order_num))
            await db.commit()
    
        await message.answer("Вопрос успешно добавлен.")
        await Form.admin_panel.set()  # Возвращаем пользователя в админ-панель
    

    Таким образом, когда администратор выберет "Добавить вопрос" из инлайн-меню, бот запросит текст нового вопроса и добавит его в базу данных, после чего сообщит об успешном добавлении и вернет пользователя в админ-панель.