Update

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):

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()
+        await session.commit()

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)

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}")