Проблемы с игровым ботом с валютой игровой

Помогите я пишу телеграмм бота с игровой валютой наподобия бфг и когда пишу баланс бот пишет что я не ещё не сменил ник однако когда я это делаю и снова пишу бот снова пишет что я не сменил ник

# Определяем состояния для FSM
class PromoStates(StatesGroup):
    NAME = State()
    AMOUNT = State()
    ACTIVATIONS = State()


async def create_tables(conn):
    try:
        cursor = await conn.cursor()

        await cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='balances'")
        balances_table_exists = await cursor.fetchone()

        if not balances_table_exists:
            await cursor.execute('''
                CREATE TABLE IF NOT EXISTS balances (
                    user_id INTEGER PRIMARY KEY,
                    nickname TEXT,
                    balance INTEGER DEFAULT 0
                )
            ''')
            await conn.commit()

        await cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='users'")
        users_table_exists = await cursor.fetchone()

        if not users_table_exists:
            await cursor.execute('''
                CREATE TABLE IF NOT EXISTS users (
                    user_id INTEGER PRIMARY KEY,
                    nickname TEXT
                )
            ''')
            await conn.commit()

    except aiosqlite.Error as e:
        print(f"Произошла ошибка при работе с базой данных: {e}")
        raise

async def check_balance(message, conn):
    user_id = message.from_user.id

    try:
        await create_tables(conn)

        cursor = await conn.cursor()

        await cursor.execute('SELECT nickname, balance FROM balances WHERE user_id = ?', (user_id,))
        result = await cursor.fetchone()

        if result:
            current_nickname, balance = result
            await message.reply(f" ™︎Ник: {current_nickname}\n ?Деньги: {balance}")
        else:
            await message.reply("Ваш никнейм не установлен. Используйте 'сменить ник <новый_ник>'.")

    except aiosqlite.Error as e:
        print(f"Произошла ошибка при выполнении операции с базой данных: {e}")

    finally:
        await cursor.close()  # Закрываем курсор после использования

# Добавляем этот блок кода, чтобы закрыть соединение с базой данных после использования
async def close_db_connection(conn):
    if conn and conn._conn:
        await conn.close()

@dp.message_handler(lambda message: message.text.lower() == 'баланс')
async def check_balance_command(message: types.Message):
    async with aiosqlite.connect('balances.db') as conn:
        await check_balance(message, conn)

    # Добавим этот блок кода, чтобы закрыть соединение с базой данных после использования
    await close_db_connection(conn)

async def change_nickname(conn, user_id, new_nickname):
    try:
        cursor = await conn.cursor()

        async with conn.execute('SELECT * FROM users WHERE user_id = ?', (user_id,)) as cursor:
            user_exists = await cursor.fetchone()

            print(f"user_exists: {user_exists}")

            if user_exists:
                await conn.execute('UPDATE users SET nickname = ? WHERE user_id = ?', (new_nickname, user_id))
            else:
                await conn.execute('INSERT INTO users (user_id, nickname) VALUES (?, ?)', (user_id, new_nickname))

            # Добавим коммит, чтобы сохранить изменения
            await conn.commit()

            return True, f"Ник успешно изменён на {new_nickname}."

    except aiosqlite.Error as e:
        print(f"aiosqlite.Error in change_nickname: {e}")
        return False, f"Произошла ошибка при изменении никнейма: {e}"

# Добавим await conn.commit() после вызова change_nickname
@dp.message_handler(lambda message: message.text.lower().startswith('сменить ник'))
async def handle_change_nickname(message: types.Message):
    async with aiosqlite.connect('balances.db') as conn:
        try:
            parts = message.text.split()
            if len(parts) == 3:
                new_nickname = parts[2]
                user_id = message.from_user.id

                print("Before calling change_nickname")
                success, response = await change_nickname(conn, user_id, new_nickname)
                print("After calling change_nickname")

                # Добавим коммит, чтобы сохранить изменения
                await conn.commit()

                await message.reply(response)

            else:
                await message.reply("Используйте команду в формате: 'сменить ник <ник>'.")
        except Exception as e:
            print(f"Exception in handle_change_nickname: {e}")
            await message.reply(f"An unknown error occurred: {e}")






# Функция для создания таблиц для промокодов
async def create_promocodes_table():
    try:
        async with aiosqlite.connect('promocodes.db') as conn:
            cursor = await conn.cursor()

            await cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='promocodes'")
            promocodes_table_exists = await cursor.fetchone()

            if not promocodes_table_exists:
                await cursor.execute('''
                    CREATE TABLE IF NOT EXISTS promocodes (
                        name TEXT PRIMARY KEY,
                        amount INTEGER,
                        activations INTEGER,
                        developer_id INTEGER,
                        currency_amount INTEGER
                    )
                ''')
                await conn.commit()
            else:
                print("Таблица 'promocodes' уже существует.")

    except aiosqlite.Error as e:
        print(f"Произошла ошибка при работе с базой данных (promocodes): {e}")
        raise

# 1

# Функция для добавления промокода в базу данных
async def add_promo_to_db(user_id, promo_name, promo_amount, promo_activations):
    try:
        async with aiosqlite.connect('promocodes.db') as conn:
            cursor = await conn.cursor()

            await cursor.execute('''
                INSERT INTO promocodes (name, amount, activations, developer_id, currency_amount)
                VALUES (?, ?, ?, ?, ?)
            ''', (promo_name, 0, promo_activations, user_id, promo_amount))

            await conn.commit()

    except aiosqlite.Error as e:
        print(f"An error occurred while adding a promo code to the database: {e}")

# Функция для проверки и активации промокода
async def check_and_activate_promo(user_id, promo_code):
    try:
        async with aiosqlite.connect('promocodes.db') as conn:
            cursor = await conn.cursor()

            await cursor.execute('SELECT * FROM promocodes WHERE name = ?', (promo_code,))
            promo_data = await cursor.fetchone()

            if promo_data:
                name, amount, activations, developer_id, currency_amount = promo_data

                if activations > 0:
                    await cursor.execute('UPDATE promocodes SET activations = activations - 1 WHERE name = ?', (promo_code,))
                    await conn.commit()

                    await cursor.execute('UPDATE balances SET balance = balance + ? WHERE user_id = ?', (currency_amount, user_id))
                    await conn.commit()

                    return True, f"Промокод '{promo_code}' успешно активирован! Вам начислено {currency_amount} валюты."
                else:
                    return False, f"Вы уже активировали {promo_code}"
            else:
                print(f"Промокод '{promo_code}' не найден.")

    except aiosqlite.Error as e:
        print(f"An error occurred while performing an operation on the database (promocodes): {e}")
        return False, "An error occurred while performing an operation on the database."

# Разрешенные пользователи
allowed_users = [5960231383]

async def close_db_connection(conn):
    if conn and conn._conn:
        await conn.close()

# Обработчик команды /add_promo
@dp.message_handler(commands=['add_promo'])
async def add_promo(message: types.Message):
    if message.from_user.id not in allowed_users:
        await message.reply("Вы не имеете права на эту команду.")
        return

    async with aiosqlite.connect('balances.db') as conn:
        markup = ReplyKeyboardMarkup(one_time_keyboard=True)
        markup.add(KeyboardButton('Отмена'))

        msg = await message.reply("Введите название промокода:", reply_markup=markup)
        await PromoStates.NAME.set()
        await msg.register_next_step_handler(process_name_step, user_id=message.from_user.id, conn=conn)

# Обработчик для ввода названия промокода
async def process_name_step(message: types.Message, state: FSMContext, user_id: int, conn):
    if message.text.lower() == 'отмена':
        await state.finish()
        await message.reply("Добавление промокода отменено.")
    else:
        promo_name = message.text
        await state.update_data(promo_name=promo_name)

        msg = await message.reply("Введите количество игровой валюты:", reply_markup=ReplyKeyboardRemove())
        await PromoStates.AMOUNT.set()
        await msg.register_next_step_handler(process_amount_step, user_id=user_id, conn=conn)

# Обработчик для ввода количества игровой валюты
async def process_amount_step(message: types.Message, state: FSMContext, user_id: int, conn):
    try:
        promo_amount = int(message.text)
        await state.update_data(promo_amount=promo_amount)

        msg = await message.reply("Введите количество активаций:")
        await PromoStates.ACTIVATIONS.set()
        await msg.register_next_step_handler(process_activations_step, user_id=user_id, conn=conn)
    except ValueError:
        await message.reply("Количество игровой валюты должно быть целым числом. Пожалуйста, попробуйте снова.")

# Обработчик для ввода количества активаций
async def process_activations_step(message: types.Message, state: FSMContext, user_id: int, conn):
    try:
        promo_activations = int(message.text)
        data = await state.get_data()
        await state.finish()

        await add_promo_to_db(user_id, data['promo_name'], data['promo_amount'], promo_activations)
        await message.reply(f"Промокод '{data['promo_name']}' успешно добавлен!")
    except ValueError:
        await message.reply("Количество активаций должно быть целым числом. Пожалуйста, попробуйте снова.")

@dp.message_handler(lambda message: message.text.lower().startswith('промо'))
async def check_promo(message: types.Message):
    user_id = message.from_user.id
    promo_code = message.text.lower().split(' ')[1]

    success, response_message = await check_and_activate_promo(user_id, promo_code)
    await message.reply(response_message)
    await close_db_connection(conn)