stcs/app/telegram/handlers/settings.py

import logging.config

from aiogram import F, Router
from aiogram.fsm.context import FSMContext
from aiogram.types import CallbackQuery

import app.telegram.keyboards.inline as kbi
import database.request as rq

from app.helper_functions import calculate_total_budget, safe_float
from logger_helper.logger_helper import LOGGING_CONFIG

logging.config.dictConfig(LOGGING_CONFIG)
logger = logging.getLogger("settings")

router_settings = Router(name="settings")


@router_settings.callback_query(F.data == "additional_settings")
async def additional_settings(callback_query: CallbackQuery, state: FSMContext) -> None:
    """
    Handler for the "additional_settings" command.
    Sends a message with additional settings options.
    """
    try:
        await state.clear()
        tg_id = callback_query.from_user.id
        additional_data = await rq.get_user_additional_settings(tg_id=tg_id)

        if not additional_data:
            await rq.create_user(
                tg_id=tg_id, username=callback_query.from_user.username
            )
            await rq.create_user_additional_settings(tg_id=tg_id)
            await rq.create_user_risk_management(tg_id=tg_id)
            await rq.create_user_conditional_settings(tg_id=tg_id)
            await additional_settings(callback_query=callback_query, state=state)
            return

        trade_mode_map = {
            "Long": "Лонг",
            "Short": "Шорт",
            "Switch": "Свитч",
        }
        margin_type_map = {
            "ISOLATED_MARGIN": "Изолированная",
            "REGULAR_MARGIN": "Кросс",
        }

        trade_mode = additional_data.trade_mode or ""
        margin_type = additional_data.margin_type or ""

        trade_mode_rus = trade_mode_map.get(trade_mode, trade_mode)
        margin_type_rus = margin_type_map.get(margin_type, margin_type)
        switch_side = additional_data.switch_side

        def f(x):
            return safe_float(x)

        leverage = f(additional_data.leverage)
        martingale = f(additional_data.martingale_factor)
        max_bets = additional_data.max_bets_in_series
        quantity = f(additional_data.order_quantity)
        trigger_price = f(additional_data.trigger_price) or 0

        switch_side_mode = ""
        if trade_mode == "Switch":
            switch_side_mode = f"- Направление первой сделки: {switch_side}\n"

        total_budget = await calculate_total_budget(
            quantity=quantity,
            martingale_factor=martingale,
            max_steps=max_bets,
        )
        text = (
            f"Основные настройки:\n\n"
            f"- Режим торговли: {trade_mode_rus}\n"
            f"{switch_side_mode}"
            f"- Тип маржи: {margin_type_rus}\n"
            f"- Размер кредитного плеча: {leverage:.2f}\n"
            f"- Базовая ставка: {quantity} USDT\n"
            f"- Коэффициент мартингейла: {martingale:.2f}\n"
            f"- Триггер цена: {trigger_price:.4f} USDT\n"
            f"- Максимальное кол-во ставок в серии: {max_bets}\n\n"
            f"- Бюджет серии: {total_budget:.2f} USDT\n"
        )

        keyboard = kbi.get_additional_settings_keyboard(mode=trade_mode)
        await callback_query.message.edit_text(text=text, reply_markup=keyboard)
        logger.debug(
            "Command additional_settings processed successfully for user: %s", tg_id
        )
    except Exception as e:
        await callback_query.message.edit_text(
            text="Произошла ошибка. Пожалуйста, попробуйте ещё раз.",
            reply_markup=kbi.profile_bybit,
        )
        logger.error(
            "Error processing command additional_settings for user %s: %s",
            callback_query.from_user.id,
            e,
        )


@router_settings.callback_query(F.data == "risk_management")
async def risk_management(callback_query: CallbackQuery, state: FSMContext) -> None:
    """
    Handler for the "risk_management" command.
    Sends a message with risk management options.
    """
    try:
        await state.clear()
        risk_management_data = await rq.get_user_risk_management(
            tg_id=callback_query.from_user.id
        )
        if risk_management_data:
            take_profit_percent = risk_management_data.take_profit_percent or ""
            stop_loss_percent = risk_management_data.stop_loss_percent or ""
            commission_fee = risk_management_data.commission_fee or ""
            commission_fee_rus = (
                "Да" if commission_fee == "Yes_commission_fee" else "Нет"
            )

            await callback_query.message.edit_text(
                text=f"Риск-менеджмент:\n\n"
                f"- Процент изменения цены для фиксации прибыли: {take_profit_percent}%\n"
                f"- Процент изменения цены для фиксации убытка: {stop_loss_percent}%\n\n"
                f"- Комиссия биржи для расчета прибыли: {commission_fee_rus}\n\n",
                reply_markup=kbi.risk_management,
            )
            logger.debug(
                "Command main_settings processed successfully for user: %s",
                callback_query.from_user.id,
            )
        else:
            await rq.create_user(
                tg_id=callback_query.from_user.id,
                username=callback_query.from_user.username,
            )
            await rq.create_user_additional_settings(tg_id=callback_query.from_user.id)
            await rq.create_user_risk_management(tg_id=callback_query.from_user.id)
            await rq.create_user_conditional_settings(tg_id=callback_query.from_user.id)
            await risk_management(callback_query=callback_query, state=state)
    except Exception as e:
        logger.error(
            "Error processing command main_settings for user %s: %s",
            callback_query.from_user.id,
            e,
        )


@router_settings.callback_query(F.data == "conditional_settings")
async def conditions(callback_query: CallbackQuery, state: FSMContext) -> None:
    """
    Handler for the "conditions" command.
    Sends a message with trading conditions options.
    """
    try:
        await state.clear()
        conditional_settings_data = await rq.get_user_conditional_settings(
            tg_id=callback_query.from_user.id
        )
        if conditional_settings_data:
            start_timer = conditional_settings_data.timer_start or 0
            stop_timer = conditional_settings_data.timer_end or 0
            await callback_query.message.edit_text(
                text="Условия торговли:\n\n"
                f"- Таймер для старта: {start_timer} мин.\n"
                f"- Таймер для остановки: {stop_timer} мин.\n",
                reply_markup=kbi.conditions,
            )
            logger.debug(
                "Command main_settings processed successfully for user: %s",
                callback_query.from_user.id,
            )
        else:
            await rq.create_user(
                tg_id=callback_query.from_user.id,
                username=callback_query.from_user.username,
            )
            await rq.create_user_additional_settings(tg_id=callback_query.from_user.id)
            await rq.create_user_risk_management(tg_id=callback_query.from_user.id)
            await rq.create_user_conditional_settings(tg_id=callback_query.from_user.id)
            await conditions(callback_query=callback_query, state=state)
    except Exception as e:
        logger.error(
            "Error processing command main_settings for user %s: %s",
            callback_query.from_user.id,
            e,
        )