stcs/app/telegram/handlers/handlers.py

import logging

from aiogram import F, Router
from aiogram.filters import CommandStart, Command
from aiogram.types import Message, CallbackQuery
from aiogram.fsm.context import FSMContext

import app.telegram.functions.functions as func # functions
import app.telegram.functions.main_settings.settings as func_main_settings
import app.telegram.functions.risk_management_settings.settings as func_rmanagement_settings
import app.telegram.functions.condition_settings.settings as func_condition_settings
import app.telegram.functions.additional_settings.settings as func_additional_settings

import app.telegram.database.requests as rq
import app.telegram.Keyboards.inline_keyboards as inline_markup
import app.telegram.Keyboards.reply_keyboards as reply_markup

router = Router()

@router.message(CommandStart())
async def start_message(message: Message):
    await rq.set_new_user_bybit_api(message.from_user.id)

    await func.start_message(message)

@router.message(F.text == "👤 Профиль")
async def profile_message(message: Message):
    user = await rq.check_user(message.from_user.id)

    if user:
        await func.profile_message(message.from_user.username, message)

@router.message(F.text == "Настройки")
async def settings_msg(message: Message):
    user = await rq.check_user(message.from_user.id)

    if user:
        await func.settings_message(message)

@router.callback_query(F.data == "clb_start_chatbot_message")
async def clb_func_reg (callback: CallbackQuery):
    user = await rq.check_user(callback.from_user.id)

    if user:
        await callback.message.answer(f'С возвращением, {callback.from_user.username}!', reply_markup=reply_markup.base_buttons_markup)
        
        await func.profile_message(callback.from_user.username, callback.message)
    else:
        await rq.save_tg_id_new_user(callback.from_user.id)

        await func_main_settings.reg_new_user_default_main_settings(callback.from_user.id, callback.message)
        await func_rmanagement_settings.reg_new_user_default_risk_management_settings(callback.from_user.id, callback.message)
        await func_condition_settings.reg_new_user_default_condition_settings(callback.from_user.id, callback.message) 
        await func_additional_settings.reg_new_user_default_additional_settings(callback.from_user.id, callback.message)

        await callback.message.answer(f'Регистрация прошла успешно, перейдите в профиль нажав на кнопку!', reply_markup=reply_markup.base_buttons_markup)

        await func.profile_message(callback.from_user.username, callback.message)

    await callback.answer()
    
@router.callback_query(F.data == "callback_profile")
async def clb_profile_message (callback: CallbackQuery):
    user = await rq.check_user(callback.from_user.id)

    if user:
        await func.profile_message(callback.from_user.username, callback.message)

    await callback.answer()
    
 # Настройки торговли
@router.callback_query(F.data == "clb_settings_message")
async def clb_settings_msg (callback: CallbackQuery):
    await func.settings_message(callback.message)

    await callback.answer()

@router.callback_query(F.data == "clb_back_to_special_settings_message")
async def clb_back_to_settings_msg(callback: CallbackQuery):
    await func.settings_message(callback.message)

    await callback.answer()

@router.callback_query(F.data == "clb_change_main_settings")
async def clb_change_main_settings_message(callback: CallbackQuery, state: FSMContext):
    await func_main_settings.main_settings_message(callback.from_user.id, callback.message, state)

    await callback.answer() 

@router.callback_query(F.data == "clb_change_risk_management_settings")
async def clb_change_risk_management_message(callback: CallbackQuery, state: FSMContext):
    await func_rmanagement_settings.main_settings_message(callback.from_user.id, callback.message, state)

    await callback.answer()

@router.callback_query(F.data == "clb_change_condition_settings")
async def clb_change_condition_message(callback: CallbackQuery, state: FSMContext):
    await func_condition_settings.main_settings_message(callback.from_user.id, callback.message, state)

    await callback.answer()

@router.callback_query(F.data == "clb_change_additional_settings")
async def clb_change_additional_message(callback: CallbackQuery, state: FSMContext):
    await func_additional_settings.main_settings_message(callback.from_user.id, callback.message, state)

    await callback.answer()

 # Конкретные настройки каталогов   
list_main_settings = ['clb_change_trading_mode', 
                      'clb_change_margin_type', 
                      'clb_change_size_leverage', 
                      'clb_change_starting_quantity', 
                      'clb_change_martingale_factor', 
                      'clb_change_maximum_quantity'
]
@router.callback_query(F.data.in_(list_main_settings))
async def clb_main_settings_msg(callback: CallbackQuery, state: FSMContext):
    await callback.answer()

    try:
        match callback.data:
            case 'clb_change_trading_mode':
                await func_main_settings.trading_mode_message(callback.message, state)
            case 'clb_change_margin_type':
                await func_main_settings.margin_type_message(callback.message, state)
            case 'clb_change_size_leverage':
                await func_main_settings.size_leverage_message(callback.message, state)
            case 'clb_change_starting_quantity':
                await func_main_settings.starting_quantity_message(callback.message, state)
            case 'clb_change_martingale_factor':
                await func_main_settings.martingale_factor_message(callback.message, state)
            case 'clb_change_maximum_quantity':
                await func_main_settings.maximum_quantity_message(callback.message, state)
    except Exception as e:
        logging.error(f"Error callback in main_settings match-case: {e}")


list_risk_management_settings = ['clb_change_price_profit', 
                      'clb_change_price_loss', 
                      'clb_change_max_risk_deal', 
]
@router.callback_query(F.data.in_(list_risk_management_settings))
async def clb_risk_management_settings_msg(callback: CallbackQuery, state: FSMContext):
    await callback.answer()

    try:
        match callback.data:
            case 'clb_change_price_profit':
                await func_rmanagement_settings.price_profit_message(callback.message, state)
            case 'clb_change_price_loss':
                await func_rmanagement_settings.price_loss_message(callback.message, state)
            case 'clb_change_max_risk_deal':
                await func_rmanagement_settings.max_risk_deal_message(callback.message, state)
    except Exception as e:
        logging.error(f"Error callback in risk_management match-case: {e}")
  
        
list_condition_settings = ['clb_change_trigger',
                           'clb_change_filter_time',
                           'clb_change_filter_volatility',
                           'clb_change_external_cues',
                           'clb_change_tradingview_cues',
                           'clb_change_webhook',
                           'clb_change_ai_analytics'
]
@router.callback_query(F.data.in_(list_condition_settings))
async def clb_condition_settings_msg(callback: CallbackQuery, state: FSMContext):
    await callback.answer()
    
    try:
        match callback.data:
            case 'clb_change_trigger':
                await func_condition_settings.trigger_message(callback.message, state)
            case 'clb_change_filter_time':
                await func_condition_settings.filter_time_message(callback.message, state)
            case 'clb_change_filter_volatility':
                await func_condition_settings.filter_volatility_message(callback.message, state)
            case 'clb_change_external_cues':
                await func_condition_settings.external_cues_message(callback.message, state)
            case 'clb_change_tradingview_cues':
                await func_condition_settings.trading_cues_message(callback.message, state)
            case 'clb_change_webhook':
                await func_condition_settings.webhook_message(callback.message, state)
            case 'clb_change_ai_analytics':
                await func_condition_settings.ai_analytics_message(callback.message, state)
    except Exception as e:
        logging.error(f"Error callback in main_settings match-case: {e}")


list_additional_settings = ['clb_change_save_pattern', 
                      'clb_change_auto_start', 
                      'clb_change_notifications', 
]
@router.callback_query(F.data.in_(list_additional_settings))
async def clb_additional_settings_msg(callback: CallbackQuery, state: FSMContext):
    await callback.answer()

    try:
        match callback.data:
            case 'clb_change_save_pattern':
                await func_additional_settings.save_pattern_message(callback.message, state)
            case 'clb_change_auto_start':
                await func_additional_settings.auto_start_message(callback.message, state)
            case 'clb_change_notifications':
                await func_additional_settings.notifications_message(callback.message, state)
    except Exception as e:
        logging.error(f"Error callback in additional_settings match-case: {e}")