diff --git a/app/services/Bybit/functions/Futures.py b/app/services/Bybit/functions/Futures.py index 360c7ca..11d15b4 100644 --- a/app/services/Bybit/functions/Futures.py +++ b/app/services/Bybit/functions/Futures.py @@ -1,13 +1,15 @@ import asyncio import time -import logging +import logging.config from pybit import exceptions from pybit.unified_trading import HTTP - +from logger_helper.logger_helper import LOGGING_CONFIG import app.services.Bybit.functions.price_symbol as price_symbol import app.services.Bybit.functions.balance as balance_g import app.telegram.database.requests as rq +logging.config.dictConfig(LOGGING_CONFIG) +logger = logging.getLogger("futures") async def info_access_open_deal(message, symbol, trade_mode, margin_mode, leverage, qty): human_margin_mode = 'Isolated' if margin_mode == 'ISOLATED_MARGIN' else 'Cross' @@ -44,6 +46,10 @@ async def open_position(tg_id, message, side: str, margin_mode: str): symbol = await rq.get_symbol(tg_id) data_main_stgs = await rq.get_user_main_settings(tg_id) + order_type = data_main_stgs.get('entry_order_type', 'Market') + limit_price = None + if order_type == 'Limit': + limit_price = await rq.get_limit_price(tg_id) data_risk_stgs = await rq.get_user_risk_management_settings(tg_id) bybit_margin_mode = 'ISOLATED_MARGIN' if margin_mode == 'Isolated' else 'REGULAR_MARGIN' @@ -51,8 +57,8 @@ async def open_position(tg_id, message, side: str, margin_mode: str): client = HTTP(api_key=api_key, api_secret=secret_key) try: - balance = await balance_g.get_balance(tg_id) - price = await price_symbol.get_price(tg_id, message) + balance = await balance_g.get_balance(tg_id, message) + price = await price_symbol.get_price(tg_id) # Установка маржинального режима client.set_margin_mode(setMarginMode=bybit_margin_mode) @@ -109,9 +115,10 @@ async def open_position(tg_id, message, side: str, margin_mode: str): category='linear', symbol=symbol, side=side, - orderType="Market", + orderType=order_type, qty=next_quantity, leverage=int(data_main_stgs['size_leverage']), + price=limit_price if order_type == 'Limit' else None, takeProfit=takeProfit, stopLoss=loss_profit, orderLinkId=f"deal_{symbol}_{int(time.time())}" @@ -125,11 +132,11 @@ async def open_position(tg_id, message, side: str, margin_mode: str): await message.answer(f"Ошибка открытия ордера: {response.get('ret_msg', 'неизвестная ошибка')}") except exceptions.InvalidRequestError as e: - logging.error(f"InvalidRequestError: {e}") + logger.error(f"InvalidRequestError: {e}") await message.answer('Ошибка: неверно указана торговая пара или параметры.') except Exception as e: - logging.error(f"Ошибка при совершении сделки: {e}") - await message.answer('⚠️ Ошибка при совершении сделки') + logger.error(f"Ошибка при совершении сделки: {e}") + async def trading_cycle(tg_id, message): @@ -179,7 +186,7 @@ async def get_active_positions(message, api_key, secret_key, symbol): if pos.get('size') and float(pos['size']) > 0: active_positions.append(pos) except Exception as e: - logging.error(f"Ошибка при получении позиций: {e}") + logger.error(f"Ошибка при получении позиций: {e}") await message.answer('⚠️ Ошибка при получении позиций') for sym in symbols: @@ -228,7 +235,7 @@ async def close_user_trade(tg_id: int, symbol: str) -> bool: ) return response['ret_code'] == 0 except Exception as e: - logging.error(f"Ошибка закрытия сделки {symbol} для пользователя {tg_id}: {e}") + logger.error(f"Ошибка закрытия сделки {symbol} для пользователя {tg_id}: {e}") return False diff --git a/app/services/Bybit/functions/functions.py b/app/services/Bybit/functions/functions.py index b5c315c..021d411 100644 --- a/app/services/Bybit/functions/functions.py +++ b/app/services/Bybit/functions/functions.py @@ -1,8 +1,8 @@ import asyncio - +import logging.config from aiogram import F, Router - -from app.services.Bybit.functions import Futures, func_min_qty +from logger_helper.logger_helper import LOGGING_CONFIG +from app.services.Bybit.functions import Futures, min_qty from app.services.Bybit.functions.Futures import open_position, close_user_trade, get_active_positions, trading_cycle from app.services.Bybit.functions.balance import get_balance import app.telegram.Keyboards.inline_keyboards as inline_markup @@ -15,6 +15,11 @@ from aiogram.types import Message, CallbackQuery from aiogram.fsm.state import State, StatesGroup from aiogram.fsm.context import FSMContext +from app.services.Bybit.functions.get_valid_symbol import get_valid_symbols + +logging.config.dictConfig(LOGGING_CONFIG) +logger = logging.getLogger("functions") + router_functions_bybit_trade = Router() @@ -30,6 +35,10 @@ class TradeSetup(StatesGroup): waiting_for_timer = State() waiting_for_positive_percent = State() +class state_limit_price(StatesGroup): + price = State() + + @router_functions_bybit_trade.callback_query(F.data.in_(['clb_start_trading', 'clb_back_to_main', 'back_to_main'])) async def clb_start_bybit_trade_message(callback: CallbackQuery, state: FSMContext): @@ -48,7 +57,8 @@ async def clb_start_bybit_trade_message(callback: CallbackQuery, state: FSMConte Как начать торговлю? 1️⃣ Проверьте и тщательно настройте все параметры в вашем профиле. -2️⃣ Нажмите ниже кнопку 'Указать торговую пару' и введите торговую пару заглавными буквами, без лишних символов (например: BTCUSDT). +2️⃣ Нажмите ниже кнопку 'Указать торговую пару' и введите торговую пару, без лишних символов (например: BTCUSDT). +3️⃣ Нажмите кнопку 'Выбрать тип входа' и после нажмите начать торговлю. ''' await callback.message.edit_text(text=text, parse_mode='html', reply_markup=inline_markup.trading_markup) @@ -69,7 +79,8 @@ async def start_bybit_trade_message(message, state): Как начать торговлю? 1️⃣ Проверьте и тщательно настройте все параметры в вашем профиле. -2️⃣ Нажмите ниже кнопку 'Указать торговую пару' и введите торговую пару заглавными буквами, без лишних символов (например: BTCUSDT). +2️⃣ Нажмите ниже кнопку 'Указать торговую пару' и введите торговую пару, без лишних символов (например: BTCUSDT). +3️⃣ Нажмите кнопку 'Выбрать тип входа' и после нажмите начать торговлю. ''' await message.answer(text=text, parse_mode='html', reply_markup=inline_markup.trading_markup) @@ -80,17 +91,23 @@ async def update_symbol_for_trade_message(callback: CallbackQuery, state: FSMCon await state.set_state(state_update_symbol.symbol) await callback.message.answer( - text='Укажите торговую пару заглавными буквами без пробелов и лишних символов (пример: BTCUSDT): ') + text='Укажите торговую пару заглавными буквами без пробелов и лишних символов (пример: BTCUSDT): ', + reply_markup=inline_markup.cancel) @router_functions_bybit_trade.message(state_update_symbol.symbol) async def update_symbol_for_trade(message: Message, state: FSMContext): + user_input = message.text.strip().upper() + + exists = await get_valid_symbols(message.from_user.id, user_input) + + if not exists: + await message.answer("Введена некорректная торговая пара или такой пары нет в списке. Попробуйте снова.") + return + await state.update_data(symbol=message.text) - - data = await state.get_data() - await message.answer('Пара была успешно обновлена') - await rq.update_symbol(message.from_user.id, data['symbol']) + await rq.update_symbol(message.from_user.id, user_input) await start_bybit_trade_message(message, state) await state.clear() @@ -111,15 +128,47 @@ async def entry_order_type_callback(callback: CallbackQuery, state: FSMContext): await callback.answer("Ошибка выбора", show_alert=True) return + if order_type == 'Limit': + await state.set_state(state_limit_price.price) + await callback.message.answer("Введите цену лимитного ордера:", reply_markup=inline_markup.cancel) + await callback.answer() + return + try: await state.update_data(entry_order_type=order_type) await rq.update_entry_order_type(callback.from_user.id, order_type) - await callback.answer("Тип входа в позицию был успешно обновлен") + await callback.message.answer(f"Выбран тип входа в позицию: {order_type}", + reply_markup=inline_markup.start_trading_markup) + await callback.answer() except Exception as e: - await callback.message.answer("Произошла ошибка при обновлении типа входа в позицию") + logger.error(f"Произошла ошибка при обновлении типа входа в позицию: {e}") + await callback.message.answer("Произошла ошибка при обновлении типа входа в позицию", + reply_markup=inline_markup.back_to_main) await state.clear() +@router_functions_bybit_trade.message(state_limit_price.price) +async def set_limit_price(message: Message, state: FSMContext): + try: + price = float(message.text) + if price <= 0: + await message.answer("Цена должна быть положительным числом. Попробуйте снова.", reply_markup=inline_markup.cancel) + return + except ValueError: + await message.answer("Некорректный формат цены. Введите число.", reply_markup=inline_markup.cancel) + return + + await state.update_data(entry_order_type='Limit', limit_price=price) + data = await state.get_data() + + await rq.update_entry_order_type(message.from_user.id, 'Limit') + await rq.update_limit_price(message.from_user.id, price) + + await message.answer(f"Цена лимитного ордера установлена: {price}", reply_markup=inline_markup.start_trading_markup) + await state.clear() + + + @router_functions_bybit_trade.callback_query(F.data == "clb_my_deals") async def show_my_trades_callback(callback: CallbackQuery): tg_id = callback.from_user.id @@ -227,7 +276,8 @@ async def start_trading_process(callback: CallbackQuery, state: FSMContext): try: positions_resp = client.get_positions(category='linear', symbol=symbol) positions = positions_resp.get('result', {}).get('list', []) - except Exception: + except Exception as e: + logger.error(f"Ошибка при получении позиций: {e}") positions = [] for pos in positions: @@ -253,7 +303,10 @@ async def start_trading_process(callback: CallbackQuery, state: FSMContext): await message.answer("Начинаю торговлю с использованием текущих настроек...") # Открываем позицию (вызывает Futures.open_position) - await open_position(tg_id, message, side=side, margin_mode=margin_mode) + success = await open_position(tg_id, message, side=side, margin_mode=margin_mode) + if not success: + await message.answer('⚠️ Ошибка при совершении сделки', reply_markup=inline_markup.back_to_main) + return # Проверяем таймер и информируем пользователя @@ -271,3 +324,9 @@ async def start_trading_process(callback: CallbackQuery, state: FSMContext): await callback.answer() + +@router_functions_bybit_trade.callback_query(F.data == "clb_cancel") +async def cancel(callback: CallbackQuery, state: FSMContext): + await state.clear() + await callback.message.answer("Отменено!", reply_markup=inline_markup.back_to_main) + await callback.answer() \ No newline at end of file diff --git a/app/telegram/database/models.py b/app/telegram/database/models.py index 0db91ef..789a1a9 100644 --- a/app/telegram/database/models.py +++ b/app/telegram/database/models.py @@ -80,6 +80,7 @@ class User_Main_Settings(Base): martingale_step = mapped_column(Integer(), default=1) maximal_quantity = mapped_column(Integer(), default=10) entry_order_type = mapped_column(String(10), default='Market') + limit_order_price = mapped_column(String(20), nullable=True) class User_Risk_Management_Settings(Base): diff --git a/app/telegram/database/requests.py b/app/telegram/database/requests.py index 8e30589..142d281 100644 --- a/app/telegram/database/requests.py +++ b/app/telegram/database/requests.py @@ -1,8 +1,10 @@ -import logging +import logging.config +from logger_helper.logger_helper import LOGGING_CONFIG from datetime import datetime, timedelta from typing import Any -logger = logging.getLogger(__name__) +logging.config.dictConfig(LOGGING_CONFIG) +logger = logging.getLogger("requests") from app.telegram.database.models import async_session from app.telegram.database.models import User_Telegram_Id as UTi @@ -10,17 +12,18 @@ from app.telegram.database.models import User_Main_Settings as UMS from app.telegram.database.models import User_Bybit_API as UBA from app.telegram.database.models import User_Symbol from app.telegram.database.models import User_Risk_Management_Settings as URMS -from app.telegram.database.models import User_Condition_Settings as UCS -from app.telegram.database.models import User_Additional_Settings as UAS +from app.telegram.database.models import User_Condition_Settings as UCS +from app.telegram.database.models import User_Additional_Settings as UAS from app.telegram.database.models import Trading_Mode from app.telegram.database.models import Margin_type from app.telegram.database.models import Trigger from app.telegram.database.models import USER_DEALS, UserTimer -import app.telegram.functions.functions as func # functions +import app.telegram.functions.functions as func # functions from sqlalchemy import select, delete, update + # SET_DB async def save_tg_id_new_user(tg_id): async with async_session() as session: @@ -29,10 +32,11 @@ async def save_tg_id_new_user(tg_id): if not user: session.add(UTi(tg_id=tg_id)) - logger.info("Новый пользователь был добавлен в бд") + logger.info("Новый пользователь был добавлен в бд %s", tg_id) await session.commit() + async def set_new_user_bybit_api(tg_id): async with async_session() as session: user = await session.scalar(select(UBA).where(UBA.tg_id == tg_id)) @@ -42,23 +46,23 @@ async def set_new_user_bybit_api(tg_id): tg_id=tg_id, )) - logger.info(f"Bybit был успешно подключен") - await session.commit() + async def set_new_user_symbol(tg_id): async with async_session() as session: user = await session.scalar(select(User_Symbol).where(User_Symbol.tg_id == tg_id)) if not user: session.add(User_Symbol( - tg_id=tg_id + tg_id=tg_id )) - logger.info(f"Symbol был успешно добавлен") + logger.info(f"Symbol был успешно добавлен %s", tg_id) await session.commit() + async def set_new_user_default_main_settings(tg_id, trading_mode, margin_type) -> None: async with async_session() as session: settings = await session.scalar(select(UMS).where(UMS.tg_id == tg_id)) @@ -67,13 +71,14 @@ async def set_new_user_default_main_settings(tg_id, trading_mode, margin_type) - session.add(UMS( tg_id=tg_id, trading_mode=trading_mode, - margin_type=margin_type, + margin_type=margin_type, )) - logger.info("Основные настройки нового пользователя были заполнены") + logger.info("Основные настройки нового пользователя были заполнены%s", tg_id) await session.commit() + async def set_new_user_default_risk_management_settings(tg_id) -> None: async with async_session() as session: settings = await session.scalar(select(URMS).where(URMS.tg_id == tg_id)) @@ -83,10 +88,11 @@ async def set_new_user_default_risk_management_settings(tg_id) -> None: tg_id=tg_id )) - logger.info("Риск-Менеджмент настройки нового пользователя были заполнены") + logger.info("Риск-Менеджмент настройки нового пользователя были заполнены %s", tg_id) await session.commit() + async def set_new_user_default_condition_settings(tg_id, trigger) -> None: async with async_session() as session: settings = await session.scalar(select(UCS).where(UCS.tg_id == tg_id)) @@ -94,13 +100,14 @@ async def set_new_user_default_condition_settings(tg_id, trigger) -> None: if not settings: session.add(UCS( tg_id=tg_id, - trigger=trigger + trigger=trigger )) - logger.info("Условные настройки нового пользователя были заполнены") + logger.info("Условные настройки нового пользователя были заполнены %s", tg_id) await session.commit() + async def set_new_user_default_additional_settings(tg_id) -> None: async with async_session() as session: settings = await session.scalar(select(UAS).where(UAS.tg_id == tg_id)) @@ -110,30 +117,35 @@ async def set_new_user_default_additional_settings(tg_id) -> None: tg_id=tg_id, )) - logger.info("Дополнительные настройки нового пользователя были заполнены") + logger.info("Дополнительные настройки нового пользователя были заполнены %s", tg_id) await session.commit() + # GET_DB async def check_user(tg_id): async with async_session() as session: user = await session.scalar(select(UTi).where(UTi.tg_id == tg_id)) - return user - + return user + + async def get_bybit_api_key(tg_id): async with async_session() as session: api_key = await session.scalar(select(UBA.api_key).where(UBA.tg_id == tg_id)) return api_key - + + async def get_bybit_secret_key(tg_id): async with async_session() as session: secret_key = await session.scalar(select(UBA.secret_key).where(UBA.tg_id == tg_id)) return secret_key - + + async def get_symbol(tg_id): async with async_session() as session: symbol = await session.scalar(select(User_Symbol.symbol).where(User_Symbol.tg_id == tg_id)) - return symbol + return symbol + async def get_user_trades(tg_id): async with async_session() as session: @@ -149,6 +161,7 @@ async def update_user_trades(tg_id, **kwargs): await session.execute(query) await session.commit() + async def delete_user_trade(tg_id: int, symbol: str): async with async_session() as session: await session.execute( @@ -158,34 +171,38 @@ async def delete_user_trade(tg_id: int, symbol: str): ) await session.commit() + async def get_for_registration_trading_mode(): async with async_session() as session: mode = await session.scalar(select(Trading_Mode.mode).where(Trading_Mode.id == 1)) return mode + async def get_for_registration_margin_type(): async with async_session() as session: type = await session.scalar(select(Margin_type.type).where(Margin_type.id == 1)) return type + async def get_for_registration_trigger(): async with async_session() as session: trigger = await session.scalar(select(Trigger.trigger).where(Trigger.id == 1)) return trigger + async def get_user_main_settings(tg_id): async with async_session() as session: user = await session.scalar(select(UMS).where(UMS.tg_id == tg_id)) - - if user: - logger.info("Получение основных настроек пользователя") - trading_mode = await session.scalar(select(UMS.trading_mode).where(UMS.tg_id == tg_id)) - margin_mode = await session.scalar(select(UMS.margin_type).where(UMS.tg_id == tg_id)) - size_leverage = await session.scalar(select(UMS.size_leverage).where(UMS.tg_id == tg_id)) - starting_quantity = await session.scalar(select(UMS.starting_quantity).where(UMS.tg_id == tg_id)) - martingale_factor = await session.scalar(select(UMS.martingale_factor).where(UMS.tg_id == tg_id)) - maximal_quantity = await session.scalar(select(UMS.maximal_quantity).where(UMS.tg_id == tg_id)) + if user: + logger.info("Получение основных настроек пользователя %s", tg_id) + + trading_mode = await session.scalar(select(UMS.trading_mode).where(UMS.tg_id == tg_id)) + margin_mode = await session.scalar(select(UMS.margin_type).where(UMS.tg_id == tg_id)) + size_leverage = await session.scalar(select(UMS.size_leverage).where(UMS.tg_id == tg_id)) + starting_quantity = await session.scalar(select(UMS.starting_quantity).where(UMS.tg_id == tg_id)) + martingale_factor = await session.scalar(select(UMS.martingale_factor).where(UMS.tg_id == tg_id)) + maximal_quantity = await session.scalar(select(UMS.maximal_quantity).where(UMS.tg_id == tg_id)) data = { 'trading_mode': trading_mode, @@ -198,12 +215,13 @@ async def get_user_main_settings(tg_id): return data + async def get_user_risk_management_settings(tg_id): async with async_session() as session: user = await session.scalar(select(URMS).where(URMS.tg_id == tg_id)) if user: - logger.info("Получение риск-менеджмента настроек пользователя") + logger.info("Получение риск-менеджмента настроек пользователя %s", tg_id) price_profit = await session.scalar(select(URMS.price_profit).where(URMS.tg_id == tg_id)) price_loss = await session.scalar(select(URMS.price_loss).where(URMS.tg_id == tg_id)) @@ -219,88 +237,100 @@ async def get_user_risk_management_settings(tg_id): return data -#UPDATE_SYMBOL + +# UPDATE_SYMBOL async def update_symbol(tg_id, symbol) -> None: async with async_session() as session: - await session.execute(update(User_Symbol).where(User_Symbol.tg_id == tg_id).values(symbol = symbol)) - + await session.execute(update(User_Symbol).where(User_Symbol.tg_id == tg_id).values(symbol=symbol)) + await session.commit() + async def update_api_key(tg_id, api): async with async_session() as session: - api_key = await session.execute(update(UBA).where(UBA.tg_id == tg_id).values(api_key = api)) + api_key = await session.execute(update(UBA).where(UBA.tg_id == tg_id).values(api_key=api)) await session.commit() + async def update_secret_key(tg_id, api): async with async_session() as session: - secret_key = await session.execute(update(UBA).where(UBA.tg_id == tg_id).values(secret_key = api)) + secret_key = await session.execute(update(UBA).where(UBA.tg_id == tg_id).values(secret_key=api)) await session.commit() + # UPDATE_MAIN_SETTINGS_DB async def update_trade_mode_user(tg_id, trading_mode) -> None: async with async_session() as session: mode = await session.scalar(select(Trading_Mode.mode).where(Trading_Mode.mode == trading_mode)) if mode: - logger.info("Изменен трейд мод") - await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(trading_mode = mode)) + logger.info("Изменен трейд мод %s", tg_id) + await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(trading_mode=mode)) await session.commit() + async def update_margin_type(tg_id, margin_type) -> None: async with async_session() as session: type = await session.scalar(select(Margin_type.type).where(Margin_type.type == margin_type)) if type: - logger.info("Изменен тип маржи") - await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(margin_type = type)) + logger.info("Изменен тип маржи %s", tg_id) + await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(margin_type=type)) await session.commit() + async def update_size_leverange(tg_id, num): async with async_session() as session: - await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(size_leverage = num)) - + await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(size_leverage=num)) + await session.commit() + async def update_starting_quantity(tg_id, num): async with async_session() as session: - await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(starting_quantity = num)) - + await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(starting_quantity=num)) + await session.commit() + async def update_martingale_factor(tg_id, num): async with async_session() as session: - await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(martingale_factor = num)) - + await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(martingale_factor=num)) + await session.commit() + async def update_maximal_quantity(tg_id, num): async with async_session() as session: - await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(maximal_quantity = num)) - + await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(maximal_quantity=num)) + await session.commit() + # UPDATE_RISK_MANAGEMENT_SETTINGS_DB async def update_price_profit(tg_id, num): async with async_session() as session: - await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(price_profit = num)) - + await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(price_profit=num)) + await session.commit() + async def update_price_loss(tg_id, num): async with async_session() as session: - await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(price_loss = num)) - + await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(price_loss=num)) + await session.commit() + async def update_max_risk_deal(tg_id, num): async with async_session() as session: - await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(max_risk_deal = num)) - + await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(max_risk_deal=num)) + await session.commit() @@ -323,40 +353,66 @@ async def get_entry_order_type(tg_id: object) -> str | None | Any: return order_type or 'Market' +async def get_limit_price(tg_id): + async with async_session() as session: + result = await session.execute( + select(UMS.limit_order_price) + .where(UMS.tg_id == tg_id) + ) + price = result.scalar_one_or_none() + if price: + try: + return float(price) + except ValueError: + return None + return None + + +async def update_limit_price(tg_id, price): + async with async_session() as session: + await session.execute( + update(UMS) + .where(UMS.tg_id == tg_id) + .values(limit_order_price=str(price)) + ) + await session.commit() + + async def update_commission_fee(tg_id, num): async with async_session() as session: - await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(commission_fee = num)) + await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(commission_fee=num)) await session.commit() + async def get_user_timer(tg_id): - async with async_session() as session: - result = await session.execute(select(UserTimer).where(UserTimer.tg_id == tg_id)) - user_timer = result.scalars().first() + async with async_session() as session: + result = await session.execute(select(UserTimer).where(UserTimer.tg_id == tg_id)) + user_timer = result.scalars().first() - if not user_timer: - logging.info(f"No timer found for user {tg_id}") - return None + if not user_timer: + logging.info(f"No timer found for user {tg_id}") + return None - timer_minutes = user_timer.timer_minutes - timer_start = user_timer.timer_start - timer_end = user_timer.timer_end + timer_minutes = user_timer.timer_minutes + timer_start = user_timer.timer_start + timer_end = user_timer.timer_end - logging.info(f"Timer data for tg_id={tg_id}: " - f"timer_minutes={timer_minutes}, " - f"timer_start={timer_start}, " - f"timer_end={timer_end}") + logging.info(f"Timer data for tg_id={tg_id}: " + f"timer_minutes={timer_minutes}, " + f"timer_start={timer_start}, " + f"timer_end={timer_end}") - remaining = None - if timer_end: - remaining = max(0, int((timer_end - datetime.utcnow()).total_seconds() // 60)) + remaining = None + if timer_end: + remaining = max(0, int((timer_end - datetime.utcnow()).total_seconds() // 60)) - return { - "timer_minutes": timer_minutes, - "timer_start": timer_start, - "timer_end": timer_end, - "remaining_minutes": remaining - } + return { + "timer_minutes": timer_minutes, + "timer_start": timer_start, + "timer_end": timer_end, + "remaining_minutes": remaining + } async def update_user_timer(tg_id, minutes: int): @@ -397,8 +453,9 @@ async def get_martingale_step(tg_id): user_settings = result.scalars().first() return user_settings.martingale_step + async def update_martingale_step(tg_id, step): async with async_session() as session: - await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(martingale_step = step)) + await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(martingale_step=step)) - await session.commit() \ No newline at end of file + await session.commit() diff --git a/app/telegram/functions/functions.py b/app/telegram/functions/functions.py index 0a1b5fe..28e9134 100644 --- a/app/telegram/functions/functions.py +++ b/app/telegram/functions/functions.py @@ -27,6 +27,4 @@ async def check_profile_message(message, username): await message.answer(f'С возвращением, {username}!', reply_markup=reply_markup.base_buttons_markup) async def settings_message(message): - await message.edit_text("Выберите что настроить", reply_markup=inline_markup.special_settings_markup) - - + await message.edit_text("Выберите что настроить", reply_markup=inline_markup.special_settings_markup) \ No newline at end of file diff --git a/app/telegram/handlers/handlers.py b/app/telegram/handlers/handlers.py index e1cb05f..fcdea72 100644 --- a/app/telegram/handlers/handlers.py +++ b/app/telegram/handlers/handlers.py @@ -1,4 +1,4 @@ -import logging +import logging.config from aiogram import F, Router from aiogram.filters import CommandStart, Command @@ -14,6 +14,11 @@ import app.telegram.functions.additional_settings.settings as func_additional_se 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 +from logger_helper.logger_helper import LOGGING_CONFIG + +logging.config.dictConfig(LOGGING_CONFIG) +logger = logging.getLogger("handlers") + router = Router() @@ -143,7 +148,7 @@ async def clb_main_settings_msg(callback: CallbackQuery, state: FSMContext): 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}") + logger.error(f"Error callback in main_settings match-case: {e}") list_risk_management_settings = ['clb_change_price_profit', @@ -168,7 +173,7 @@ async def clb_risk_management_settings_msg(callback: CallbackQuery, state: FSMCo case 'commission_fee': await func_rmanagement_settings.commission_fee_message(callback.message, state) except Exception as e: - logging.error(f"Error callback in risk_management match-case: {e}") + logger.error(f"Error callback in risk_management match-case: {e}") list_condition_settings = ['clb_change_trigger', @@ -202,7 +207,7 @@ async def clb_condition_settings_msg(callback: CallbackQuery, state: FSMContext) 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}") + logger.error(f"Error callback in main_settings match-case: {e}") list_additional_settings = ['clb_change_save_pattern', @@ -224,4 +229,4 @@ async def clb_additional_settings_msg(callback: CallbackQuery, state: FSMContext 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}") + logger.error(f"Error callback in additional_settings match-case: {e}")