Merge pull request 'Fixed websocket' (#29) from Alex/stcs:devel into stable

Reviewed-on: #29

alembic/versions/0ee52ab23e66_added_column_current_series.py

@@ -0,0 +1,32 @@
+"""Added column current_series
+
+Revision ID: 0ee52ab23e66
+Revises: e5d612e44563
+Create Date: 2025-10-26 11:48:48.055031
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '0ee52ab23e66'
+down_revision: Union[str, Sequence[str], None] = 'e5d612e44563'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('user_deals', sa.Column('current_series', sa.Integer(), nullable=True))
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('user_deals', 'current_series')
+    # ### end Alembic commands ###

alembic/versions/3fca121b7554_added_tp_sl_and_pnl.py

@@ -0,0 +1,44 @@
+"""Added TP_SL and PNL
+
+Revision ID: 3fca121b7554
+Revises: adf3d2991896
+Create Date: 2025-10-29 11:07:45.350771
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy import inspect
+
+
+# revision identifiers, used by Alembic.
+revision: str = '3fca121b7554'
+down_revision: Union[str, Sequence[str], None] = 'adf3d2991896'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    conn = op.get_bind()
+    inspector = inspect(conn)
+
+    columns = [col['name'] for col in inspector.get_columns('user_deals')]
+
+    if 'pnl_series' not in columns:
+        op.add_column('user_deals', sa.Column('pnl_series', sa.Float(), nullable=True))
+    if 'take_profit' not in columns:
+        op.add_column('user_deals', sa.Column('take_profit', sa.Boolean(), nullable=False, server_default=sa.false()))
+    if 'stop_loss' not in columns:
+        op.add_column('user_deals', sa.Column('stop_loss', sa.Boolean(), nullable=False, server_default=sa.false()))
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('user_deals', 'stop_loss')
+    op.drop_column('user_deals', 'take_profit')
+    op.drop_column('user_deals', 'pnl_series')
+    # ### end Alembic commands ###

alembic/versions/8329c0994b26_fixed_tp_sl_type.py

@@ -0,0 +1,49 @@
+"""Fixed TP_SL type
+
+Revision ID: 8329c0994b26
+Revises: 3fca121b7554
+Create Date: 2025-10-29 13:07:52.161139
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = '8329c0994b26'
+down_revision: Union[str, Sequence[str], None] = '3fca121b7554'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade():
+    with op.batch_alter_table('user_deals', recreate='always') as batch_op:
+        # Добавляем новую колонку с нужным типом
+        batch_op.add_column(sa.Column('take_profit_new', sa.Float(), nullable=False, server_default='0'))
+
+    # После закрытия batch создается и переименовывается таблица.
+    # Теперь мы можем обновить данные.
+    op.execute(
+        "UPDATE user_deals SET take_profit_new = CAST(take_profit AS FLOAT)"
+    )
+
+    with op.batch_alter_table('user_deals', recreate='always') as batch_op:
+        # Удаляем старую колонку
+        batch_op.drop_column('take_profit')
+        # Меняем имя новой колонки на старое
+        batch_op.alter_column('take_profit_new', new_column_name='take_profit')
+
+def downgrade():
+    # Аналогично, но в обратном порядке и типе
+    with op.batch_alter_table('user_deals', recreate='always') as batch_op:
+        batch_op.add_column(sa.Column('take_profit_old', sa.Boolean(), nullable=False, server_default='0'))
+
+    op.execute(
+        "UPDATE user_deals SET take_profit_old = CAST(take_profit AS BOOLEAN)"
+    )
+
+    with op.batch_alter_table('user_deals', recreate='always') as batch_op:
+        batch_op.drop_column('take_profit')
+        batch_op.alter_column('take_profit_old', new_column_name='take_profit')

alembic/versions/adf3d2991896_added_column_commission_place.py

@@ -0,0 +1,45 @@
+"""Added column commission_place
+
+Revision ID: adf3d2991896
+Revises: 0ee52ab23e66
+Create Date: 2025-10-26 13:37:33.662318
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy import inspect
+
+
+# revision identifiers, used by Alembic.
+revision: str = 'adf3d2991896'
+down_revision: Union[str, Sequence[str], None] = '0ee52ab23e66'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    bind = op.get_bind()
+    inspector = inspect(bind)
+    columns_user_deals = [col['name'] for col in inspector.get_columns('user_deals')]
+    if 'commission_fee' not in columns_user_deals:
+        op.add_column('user_deals', sa.Column('commission_fee', sa.String(), server_default='', nullable=True))
+    if 'commission_place' not in columns_user_deals:
+        op.add_column('user_deals', sa.Column('commission_place', sa.String(), server_default='', nullable=True))
+
+    columns_user_risk_mgmt = [col['name'] for col in inspector.get_columns('user_risk_management')]
+    if 'commission_place' not in columns_user_risk_mgmt:
+        op.add_column('user_risk_management',
+                      sa.Column('commission_place', sa.String(), server_default='', nullable=False))
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('user_risk_management', 'commission_place')
+    op.drop_column('user_deals', 'commission_place')
+    op.drop_column('user_deals', 'commission_fee')
+    # ### end Alembic commands ###

alembic/versions/e5d612e44563_added_column_side_for_additional_.py

@@ -0,0 +1,34 @@
+"""Added column side for additional_setiings
+
+Revision ID: e5d612e44563
+Revises: fbf4e3658310
+Create Date: 2025-10-25 18:25:52.746250
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = 'e5d612e44563'
+down_revision: Union[str, Sequence[str], None] = 'fbf4e3658310'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column('user_additional_settings',
+                  sa.Column('side', sa.String(), nullable=False, server_default='')
+                  )
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column('user_additional_settings', 'side')
+    # ### end Alembic commands ###

app/bybit/__init__.py

@@ -15,7 +15,7 @@ async def get_bybit_client(tg_id: int) -> HTTP | None:
     """
     try:
         api_key, api_secret = await rq.get_user_api(tg_id=tg_id)
-        return HTTP(api_key=api_key, api_secret=api_secret)
+        return HTTP(demo=True, api_key=api_key, api_secret=api_secret)
     except Exception as e:
         logger.error("Error getting bybit client for user %s: %s", tg_id, e)
         return None

app/bybit/open_positions.py

@@ -28,11 +28,9 @@ async def start_trading_cycle(
         symbol = await rq.get_user_symbol(tg_id=tg_id)
         additional_data = await rq.get_user_additional_settings(tg_id=tg_id)
         risk_management_data = await rq.get_user_risk_management(tg_id=tg_id)
-        user_deals_data = await rq.get_user_deal_by_symbol(
-            tg_id=tg_id, symbol=symbol
-        )
         trade_mode = additional_data.trade_mode
         switch_side = additional_data.switch_side
+        side = additional_data.side
         margin_type = additional_data.margin_type
         leverage = additional_data.leverage
         order_quantity = additional_data.order_quantity
@@ -41,21 +39,11 @@ async def start_trading_cycle(
         max_bets_in_series = additional_data.max_bets_in_series
         take_profit_percent = risk_management_data.take_profit_percent
         stop_loss_percent = risk_management_data.stop_loss_percent
-        total_commission = 0
-
-        get_side = "Buy"
-
-        if user_deals_data:
-            get_side = user_deals_data.last_side or "Buy"
+        commission_fee = risk_management_data.commission_fee
+        commission_place = risk_management_data.commission_place
 
         if trade_mode == "Switch":
-            if switch_side == "По направлению":
-                side = get_side
-            else:
-                if get_side == "Buy":
-                    side = "Sell"
-                else:
-                    side = "Buy"
+            side = side
         else:
             if trade_mode == "Long":
                 side = "Buy"
@@ -66,11 +54,26 @@ async def start_trading_cycle(
             tg_id=tg_id,
             symbol=symbol,
             mode=0)
-        await set_margin_mode(tg_id=tg_id, margin_mode=margin_type)
-        await set_leverage(
+
+        await rq.set_user_deal(
             tg_id=tg_id,
             symbol=symbol,
+            current_step=1,
+            current_series=1,
+            trade_mode=trade_mode,
+            side_mode=switch_side,
+            margin_type=margin_type,
             leverage=leverage,
+            order_quantity=order_quantity,
+            trigger_price=trigger_price,
+            martingale_factor=martingale_factor,
+            max_bets_in_series=max_bets_in_series,
+            take_profit_percent=take_profit_percent,
+            stop_loss_percent=stop_loss_percent,
+            base_quantity=order_quantity,
+            commission_fee=commission_fee,
+            commission_place=commission_place,
+            pnl_series=0
         )
 
         res = await open_positions(
@@ -79,30 +82,10 @@ async def start_trading_cycle(
             side=side,
             order_quantity=order_quantity,
             trigger_price=trigger_price,
-            margin_type=margin_type,
-            leverage=leverage,
-            take_profit_percent=take_profit_percent,
-            stop_loss_percent=stop_loss_percent,
-            commission_fee_percent=total_commission
+            leverage=leverage
         )
 
         if res == "OK":
-            await rq.set_user_deal(
-                tg_id=tg_id,
-                symbol=symbol,
-                current_step=1,
-                trade_mode=trade_mode,
-                side_mode=switch_side,
-                margin_type=margin_type,
-                leverage=leverage,
-                order_quantity=order_quantity,
-                trigger_price=trigger_price,
-                martingale_factor=martingale_factor,
-                max_bets_in_series=max_bets_in_series,
-                take_profit_percent=take_profit_percent,
-                stop_loss_percent=stop_loss_percent,
-                base_quantity=order_quantity
-            )
             return "OK"
         return (
             res
@@ -118,7 +101,8 @@ async def start_trading_cycle(
                    "position idx not match position mode",
                    "Qty invalid",
                    "The number of contracts exceeds maximum limit allowed",
-                   "The number of contracts exceeds minimum limit allowed"
+                   "The number of contracts exceeds minimum limit allowed",
+                   "Order placement failed as your position may exceed the max",
                }
             else None
         )
@@ -132,8 +116,6 @@ async def trading_cycle_profit(
         tg_id: int, symbol: str, side: str) -> str | None:
     try:
         user_deals_data = await rq.get_user_deal_by_symbol(tg_id=tg_id, symbol=symbol)
-        user_auto_trading_data = await rq.get_user_auto_trading(tg_id=tg_id, symbol=symbol)
-        total_fee = user_auto_trading_data.total_fee
         trade_mode = user_deals_data.trade_mode
         margin_type = user_deals_data.margin_type
         leverage = user_deals_data.leverage
@@ -144,6 +126,9 @@ async def trading_cycle_profit(
         martingale_factor = user_deals_data.martingale_factor
         side_mode = user_deals_data.side_mode
         base_quantity = user_deals_data.base_quantity
+        current_series = user_deals_data.current_series
+        commission_fee = user_deals_data.commission_fee
+        commission_place = user_deals_data.commission_place
 
         await set_margin_mode(tg_id=tg_id, margin_mode=margin_type)
         await set_leverage(
@@ -152,7 +137,6 @@ async def trading_cycle_profit(
             leverage=leverage,
         )
 
-
         if trade_mode == "Switch":
             if side_mode == "Противоположно":
                 s_side = "Sell" if side == "Buy" else "Buy"
@@ -161,36 +145,39 @@ async def trading_cycle_profit(
         else:
             s_side = side
 
+        next_series = current_series + 1
+
+        await rq.set_user_deal(
+            tg_id=tg_id,
+            symbol=symbol,
+            current_step=1,
+            current_series=next_series,
+            trade_mode=trade_mode,
+            side_mode=side_mode,
+            margin_type=margin_type,
+            leverage=leverage,
+            order_quantity=base_quantity,
+            trigger_price=trigger_price,
+            martingale_factor=martingale_factor,
+            max_bets_in_series=max_bets_in_series,
+            take_profit_percent=take_profit_percent,
+            stop_loss_percent=stop_loss_percent,
+            base_quantity=base_quantity,
+            commission_fee=commission_fee,
+            commission_place=commission_place,
+            pnl_series=0
+        )
+
         res = await open_positions(
             tg_id=tg_id,
             symbol=symbol,
             side=s_side,
             order_quantity=base_quantity,
             trigger_price=trigger_price,
-            margin_type=margin_type,
-            leverage=leverage,
-            take_profit_percent=take_profit_percent,
-            stop_loss_percent=stop_loss_percent,
-            commission_fee_percent=total_fee
+            leverage=leverage
         )
 
         if res == "OK":
-            await rq.set_user_deal(
-                tg_id=tg_id,
-                symbol=symbol,
-                current_step=1,
-                trade_mode=trade_mode,
-                side_mode=side_mode,
-                margin_type=margin_type,
-                leverage=leverage,
-                order_quantity=base_quantity,
-                trigger_price=trigger_price,
-                martingale_factor=martingale_factor,
-                max_bets_in_series=max_bets_in_series,
-                take_profit_percent=take_profit_percent,
-                stop_loss_percent=stop_loss_percent,
-                base_quantity=base_quantity
-            )
             return "OK"
 
         return (
@@ -201,6 +188,7 @@ async def trading_cycle_profit(
                    "ab not enough for new order",
                    "InvalidRequestError",
                    "The number of contracts exceeds maximum limit allowed",
+                   "Order placement failed as your position may exceed the max",
                }
             else None
         )
@@ -215,8 +203,8 @@ async def trading_cycle(
     try:
         user_deals_data = await rq.get_user_deal_by_symbol(tg_id=tg_id, symbol=symbol)
         user_auto_trading_data = await rq.get_user_auto_trading(tg_id=tg_id, symbol=symbol)
-        user_risk_management_data = await rq.get_user_risk_management(tg_id=tg_id)
-        commission_fee = user_risk_management_data.commission_fee
+        commission_fee = user_deals_data.commission_fee
+        commission_place = user_deals_data.commission_place
         total_fee = user_auto_trading_data.total_fee
         trade_mode = user_deals_data.trade_mode
         margin_type = user_deals_data.margin_type
@@ -230,6 +218,8 @@ async def trading_cycle(
         order_quantity = user_deals_data.order_quantity
         base_quantity = user_deals_data.base_quantity
         side_mode = user_deals_data.side_mode
+        current_series = user_deals_data.current_series
+        pnl_series = user_deals_data.pnl_series
 
         next_quantity = safe_float(order_quantity) * (
             safe_float(martingale_factor)
@@ -245,10 +235,10 @@ async def trading_cycle(
             symbol=symbol,
             leverage=leverage,
         )
+        total_quantity = next_quantity
         if commission_fee == "Yes_commission_fee":
-            total_fee = total_fee
-        else:
-            total_fee = 0
+            if commission_place == "Commission_for_qty":
+                total_quantity = next_quantity + total_fee
 
         if trade_mode == "Switch":
             if side == "Buy":
@@ -258,36 +248,37 @@ async def trading_cycle(
         else:
             r_side = side
 
+        await rq.set_user_deal(
+            tg_id=tg_id,
+            symbol=symbol,
+            current_step=current_step,
+            current_series=current_series,
+            trade_mode=trade_mode,
+            side_mode=side_mode,
+            margin_type=margin_type,
+            leverage=leverage,
+            order_quantity=next_quantity,
+            trigger_price=trigger_price,
+            martingale_factor=martingale_factor,
+            max_bets_in_series=max_bets_in_series,
+            take_profit_percent=take_profit_percent,
+            stop_loss_percent=stop_loss_percent,
+            base_quantity=base_quantity,
+            commission_fee=commission_fee,
+            commission_place=commission_place,
+            pnl_series=pnl_series
+        )
+
         res = await open_positions(
             tg_id=tg_id,
             symbol=symbol,
             side=r_side,
-            order_quantity=next_quantity,
+            order_quantity=total_quantity,
             trigger_price=trigger_price,
-            margin_type=margin_type,
-            leverage=leverage,
-            take_profit_percent=take_profit_percent,
-            stop_loss_percent=stop_loss_percent,
-            commission_fee_percent=total_fee
+            leverage=leverage
         )
 
         if res == "OK":
-            await rq.set_user_deal(
-                tg_id=tg_id,
-                symbol=symbol,
-                current_step=current_step,
-                trade_mode=trade_mode,
-                side_mode=side_mode,
-                margin_type=margin_type,
-                leverage=leverage,
-                order_quantity=next_quantity,
-                trigger_price=trigger_price,
-                martingale_factor=martingale_factor,
-                max_bets_in_series=max_bets_in_series,
-                take_profit_percent=take_profit_percent,
-                stop_loss_percent=stop_loss_percent,
-                base_quantity=base_quantity
-            )
             return "OK"
 
         return (
@@ -298,6 +289,7 @@ async def trading_cycle(
                    "ab not enough for new order",
                    "InvalidRequestError",
                    "The number of contracts exceeds maximum limit allowed",
+                   "Order placement failed as your position may exceed the max",
                }
             else None
         )
@@ -313,23 +305,24 @@ async def open_positions(
         symbol: str,
         order_quantity: float,
         trigger_price: float,
-        margin_type: str,
-        leverage: str,
-        take_profit_percent: float,
-        stop_loss_percent: float,
-        commission_fee_percent: float
+        leverage: str
 ) -> str | None:
     try:
         client = await get_bybit_client(tg_id=tg_id)
         get_ticker = await get_tickers(tg_id, symbol=symbol)
-        price_symbol = safe_float(get_ticker.get("lastPrice")) or 0
+
+        if get_ticker is None:
+            price_symbol = 0
+        else:
+            price_symbol = safe_float(get_ticker.get("lastPrice"))
+
         instruments_info = await get_instruments_info(tg_id=tg_id, symbol=symbol)
         qty_step_str = instruments_info.get("lotSizeFilter").get("qtyStep")
         qty_step = safe_float(qty_step_str)
         qty = (safe_float(order_quantity) * safe_float(leverage)) / safe_float(price_symbol)
         decimals = abs(int(round(math.log10(qty_step))))
-        qty_formatted = math.floor(qty / qty_step) * qty_step
-        qty_formatted = round(qty_formatted, decimals)
+        qty_format = math.floor(qty / qty_step) * qty_step
+        qty_formatted = round(qty_format, decimals)
 
         if trigger_price > 0:
             po_trigger_price = str(trigger_price)
@@ -338,33 +331,6 @@ async def open_positions(
             po_trigger_price = None
             trigger_direction = None
 
-        price_for_cals = trigger_price if po_trigger_price is not None else price_symbol
-
-        if qty_formatted <= 0:
-            return "Order does not meet minimum order value"
-
-        if margin_type == "ISOLATED_MARGIN":
-            if side == "Buy":
-                take_profit_price = price_for_cals * (
-                        1 + take_profit_percent / 100) + commission_fee_percent / qty_formatted
-                stop_loss_price = None
-            else:
-                take_profit_price = price_for_cals * (
-                        1 - take_profit_percent / 100) - commission_fee_percent / qty_formatted
-                stop_loss_price = None
-        else:
-            if side == "Buy":
-                take_profit_price = price_for_cals * (
-                            1 + take_profit_percent / 100) + commission_fee_percent / qty_formatted
-                stop_loss_price = price_for_cals * (1 - stop_loss_percent / 100)
-            else:
-                take_profit_price = price_for_cals * (
-                            1 - take_profit_percent / 100) - commission_fee_percent / qty_formatted
-                stop_loss_price = price_for_cals * (1 + stop_loss_percent / 100)
-
-            take_profit_price = max(take_profit_price, 0)
-            stop_loss_price = max(stop_loss_price, 0)
-
         # Place order
         order_params = {
             "category": "linear",
@@ -378,8 +344,6 @@ async def open_positions(
             "timeInForce": "GTC",
             "positionIdx": 0,
             "tpslMode": "Full",
-            "takeProfit": str(take_profit_price) if take_profit_price else None,
-            "stopLoss": str(stop_loss_price) if stop_loss_price else None,
         }
 
         response = client.place_order(**order_params)
@@ -401,6 +365,7 @@ async def open_positions(
             "Qty invalid": "Qty invalid",
             "The number of contracts exceeds maximum limit allowed": "The number of contracts exceeds maximum limit allowed",
             "The number of contracts exceeds minimum limit allowed": "The number of contracts exceeds minimum limit allowed",
+            "Order placement failed as your position may exceed the max": "Order placement failed as your position may exceed the max",
         }
         for key, msg in known_errors.items():
             if key in error_text:

app/bybit/set_functions/set_tp_sl.py

@@ -25,11 +25,13 @@ async def set_tp_sl_for_position(
     """
     try:
         client = await get_bybit_client(tg_id)
+        take_profit = round(take_profit_price, 6) if take_profit_price is not None else None
+        stop_loss = round(stop_loss_price, 6) if stop_loss_price is not None else None
         resp = client.set_trading_stop(
             category="linear",
             symbol=symbol,
-            takeProfit=str(round(take_profit_price, 5)),
-            stopLoss=str(round(stop_loss_price, 5)),
+            takeProfit=str(take_profit) if take_profit is not None else None,
+            stopLoss=str(stop_loss) if stop_loss is not None else None,
             positionIdx=position_idx,
             tpslMode="Full",
         )

app/bybit/telegram_message_handler.py

@@ -1,10 +1,14 @@
 import logging.config
-
+import math
+# import json
 import app.telegram.keyboards.inline as kbi
 import database.request as rq
+from app.bybit.get_functions.get_instruments_info import get_instruments_info
+from app.bybit.get_functions.get_positions import get_active_positions_by_symbol
 from app.bybit.logger_bybit.logger_bybit import LOGGING_CONFIG
 from app.bybit.open_positions import trading_cycle, trading_cycle_profit
-from app.helper_functions import format_value, safe_float
+from app.bybit.set_functions.set_tp_sl import set_tp_sl_for_position
+from app.helper_functions import format_value, safe_float, truncate_float
 
 logging.config.dictConfig(LOGGING_CONFIG)
 logger = logging.getLogger("telegram_message_handler")
@@ -14,243 +18,328 @@ class TelegramMessageHandler:
     def __init__(self, telegram_bot):
         self.telegram_bot = telegram_bot
 
-    async def format_position_update(self, message):
-        pass
-
     async def format_order_update(self, message, tg_id):
         try:
-            order_data = message.get("data", [{}])[0]
-            symbol = format_value(order_data.get("symbol"))
-            qty = format_value(order_data.get("qty"))
-            side = format_value(order_data.get("side"))
-            side_rus = (
-                "Покупка"
-                if side == "Buy"
-                else "Продажа" if side == "Sell" else "Нет данных"
-            )
-            order_status = format_value(order_data.get("orderStatus"))
-            price = format_value(order_data.get("price"))
-            trigger_price = format_value(order_data.get("triggerPrice"))
-            take_profit = format_value(order_data.get("takeProfit"))
-            stop_loss = format_value(order_data.get("stopLoss"))
+            user_additional_data = await rq.get_user_additional_settings(tg_id=tg_id)
+            trigger_price = safe_float(user_additional_data.trigger_price)
+            if trigger_price > 0:
+                order_data = message.get("data", [{}])[0]
+                symbol = format_value(order_data.get("symbol"))
+                side = format_value(order_data.get("side"))
+                side_rus = (
+                    "Покупка"
+                    if side == "Buy"
+                    else "Продажа" if side == "Sell" else "Нет данных"
+                )
+                order_status = format_value(order_data.get("orderStatus"))
+                tr_price = format_value(order_data.get("triggerPrice"))
 
-            status_map = {
-                "Untriggered": "Условный ордер выставлен",
-            }
+                status_map = {
+                    "Untriggered": "Условный ордер выставлен",
+                }
 
-            if order_status == "Filled" or order_status not in status_map:
-                return None
+                if order_status == "Filled" or order_status not in status_map:
+                    return None
 
-            user_auto_trading = await rq.get_user_auto_trading(
-                tg_id=tg_id, symbol=symbol
-            )
-            auto_trading = (
-                user_auto_trading.auto_trading if user_auto_trading else False
-            )
-            user_deals_data = await rq.get_user_deal_by_symbol(
-                tg_id=tg_id, symbol=symbol
-            )
+                text = (
+                    f"Торговая пара: {symbol}\n"
+                    f"Движение: {side_rus}\n"
+                )
+                if tr_price and tr_price != "Нет данных":
+                    text += f"Триггер цена: {tr_price}\n"
 
-            text = (
-                f"Торговая пара: {symbol}\n"
-                f"Движение: {side_rus}\n"
-            )
-
-            if user_deals_data is not None and auto_trading:
-                text += f"Текущая ставка: {user_deals_data.order_quantity} USDT\n"
-            else:
-                text += f"Количество: {qty}\n"
-
-            if price and price != "0":
-                text += f"Цена: {price}\n"
-            if take_profit and take_profit != "Нет данных":
-                text += f"Тейк-профит: {take_profit}\n"
-            if stop_loss and stop_loss != "Нет данных":
-                text += f"Стоп-лосс: {stop_loss}\n"
-            if trigger_price and trigger_price != "Нет данных":
-                text += f"Триггер цена: {trigger_price}\n"
-
-            await self.telegram_bot.send_message(
-                chat_id=tg_id, text=text, reply_markup=kbi.profile_bybit
-            )
+                await self.telegram_bot.send_message(
+                    chat_id=tg_id, text=text, reply_markup=kbi.profile_bybit
+                )
+                await rq.set_trigger_price(tg_id=tg_id, trigger_price=0)
         except Exception as e:
             logger.error("Error in format_order_update: %s", e)
 
     async def format_execution_update(self, message, tg_id):
         try:
+            # logger.info("Execution update: %s", json.dumps(message))
             execution = message.get("data", [{}])[0]
-            closed_size = format_value(execution.get("closedSize"))
-            symbol = format_value(execution.get("symbol"))
-            exec_price = format_value(execution.get("execPrice"))
-            exec_qty = format_value(execution.get("execQty"))
-            exec_fees = format_value(execution.get("execFee"))
-            fee_rate = format_value(execution.get("feeRate"))
-            side = format_value(execution.get("side"))
-            side_rus = (
-                "Покупка"
-                if side == "Buy"
-                else "Продажа" if side == "Sell" else "Нет данных"
-            )
-            if safe_float(exec_fees) == 0:
-                exec_fee = safe_float(exec_price) * safe_float(exec_qty) * safe_float(
-                    fee_rate
-                )
-            else:
-                exec_fee = safe_float(exec_fees)
+            exec_type = format_value(execution.get("execType"))
+            if exec_type == "Trade" or exec_type == "BustTrade":
+                closed_size = format_value(execution.get("closedSize"))
+                symbol = format_value(execution.get("symbol"))
+                exec_price = format_value(execution.get("execPrice"))
+                exec_qty = format_value(execution.get("execQty"))
+                exec_fees = format_value(execution.get("execFee"))
+                fee_rate = format_value(execution.get("feeRate"))
+                side = format_value(execution.get("side"))
 
-            if safe_float(closed_size) == 0:
-                await rq.set_fee_user_auto_trading(
-                    tg_id=tg_id, symbol=symbol, fee=safe_float(exec_fee)
+                user_auto_trading = await rq.get_user_auto_trading(
+                    tg_id=tg_id, symbol=symbol
+                )
+                auto_trading = (
+                    user_auto_trading.auto_trading if user_auto_trading else False
                 )
 
-            user_auto_trading = await rq.get_user_auto_trading(
-                tg_id=tg_id, symbol=symbol
-            )
-
-            get_total_fee = user_auto_trading.total_fee
-            total_fee = safe_float(exec_fee) + safe_float(get_total_fee)
-
-
-            if user_auto_trading is not None and user_auto_trading.fee is not None:
-                fee = user_auto_trading.fee
-            else:
-                fee = 0
-
-            exec_pnl = format_value(execution.get("execPnl"))
-            total_pnl = safe_float(exec_pnl) - safe_float(exec_fee) - fee
-            header = (
-                "Сделка закрыта:" if safe_float(closed_size) > 0 else "Сделка открыта:"
-            )
-            text = f"{header}\n" f"Торговая пара: {symbol}\n"
-
-            auto_trading = (
-                user_auto_trading.auto_trading if user_auto_trading else False
-            )
-            user_deals_data = await rq.get_user_deal_by_symbol(
-                tg_id=tg_id, symbol=symbol
-            )
-            if user_deals_data is not None and auto_trading:
-                await rq.set_total_fee_user_auto_trading(
-                    tg_id=tg_id, symbol=symbol, total_fee=total_fee
+                side_rus = (
+                    "Покупка"
+                    if side == "Buy"
+                    else "Продажа" if side == "Sell" else "Нет данных"
                 )
-                text += f"Текущая ставка: {user_deals_data.order_quantity} USDT\n"
-
-            text += (
-                f"Цена исполнения: {exec_price}\n"
-                f"Комиссия: {exec_fee:.8f}\n"
-            )
-
-            if safe_float(closed_size) == 0:
-                text += f"Движение: {side_rus}\n"
-            else:
-                text += f"\nРеализованная прибыль: {total_pnl:.7f}\n"
-
-            await self.telegram_bot.send_message(
-                chat_id=tg_id, text=text, reply_markup=kbi.profile_bybit
-            )
-
-            user_symbols = user_auto_trading.symbol if user_auto_trading else None
-
-            if (
-                auto_trading
-                and safe_float(closed_size) > 0
-                and user_symbols is not None
-            ):
-                if safe_float(total_pnl) > 0:
-                    profit_text = "📈 Прибыль достигнута. Начинаем новую серию с базовой ставки\n"
-                    await self.telegram_bot.send_message(
-                        chat_id=tg_id, text=profit_text, reply_markup=kbi.profile_bybit
+                if safe_float(exec_fees) == 0:
+                    exec_fee = safe_float(exec_price) * safe_float(exec_qty) * safe_float(
+                        fee_rate
                     )
-
-                    if side == "Buy":
-                        r_side = "Sell"
-                    else:
-                        r_side = "Buy"
-
-                    await rq.set_last_side_by_symbol(
-                        tg_id=tg_id, symbol=symbol, last_side=r_side)
-                    await rq.set_total_fee_user_auto_trading(
-                        tg_id=tg_id, symbol=symbol, total_fee=0
-                    )
-                    await rq.set_fee_user_auto_trading(
-                        tg_id=tg_id, symbol=symbol, fee=0
-                    )
-
-                    res = await trading_cycle_profit(
-                        tg_id=tg_id, symbol=symbol, side=r_side
-                    )
-
-                    if res == "OK":
-                        pass
-                    else:
-                        errors = {
-                            "Max bets in series": "❗️ Максимальное количество сделок в серии достигнуто",
-                            "Risk is too high for this trade": "❗️ Риск сделки слишком высок для продолжения",
-                            "ab not enough for new order": "❗️ Недостаточно средств для продолжения торговли",
-                            "InvalidRequestError": "❗️ Недостаточно средств для размещения нового ордера с заданным количеством и плечом.",
-                            "The number of contracts exceeds maximum limit allowed": "❗️ Превышен максимальный лимит ставки",
-                        }
-                        error_text = errors.get(
-                            res, "❗️ Не удалось открыть новую сделку"
-                        )
-                        await rq.set_auto_trading(
-                            tg_id=tg_id, symbol=symbol, auto_trading=False
-                        )
-
-                        await rq.set_total_fee_user_auto_trading(
-                            tg_id=tg_id, symbol=symbol, total_fee=0
-                        )
-                        await rq.set_fee_user_auto_trading(
-                            tg_id=tg_id, symbol=symbol, fee=0
-                        )
-                        await self.telegram_bot.send_message(
-                            chat_id=tg_id,
-                            text=error_text,
-                            reply_markup=kbi.profile_bybit,
-                        )
                 else:
-                    open_order_text = "\n❗️ Сделка закрылась в минус, открываю новую сделку с увеличенной ставкой.\n"
-                    await self.telegram_bot.send_message(
-                        chat_id=tg_id, text=open_order_text
+                    exec_fee = safe_float(exec_fees)
+
+                if safe_float(closed_size) == 0:
+                    await rq.set_fee_user_auto_trading(
+                        tg_id=tg_id, symbol=symbol, fee=safe_float(exec_fee)
                     )
 
-                    if side == "Buy":
-                        r_side = "Sell"
-                    else:
-                        r_side = "Buy"
+                get_total_fee = 0
 
-                    res = await trading_cycle(
-                        tg_id=tg_id, symbol=symbol, side=r_side
+                if user_auto_trading is not None:
+                    get_total_fee = user_auto_trading.total_fee
+
+                total_fee = safe_float(exec_fee) + safe_float(get_total_fee)
+
+                exec_pnl = format_value(execution.get("execPnl"))
+                ex_pnl = safe_float(exec_pnl)
+                pnl = safe_float(exec_pnl)
+
+                header = (
+                    "Сделка закрыта:" if safe_float(closed_size) > 0 else "Сделка открыта:"
+                )
+                text = f"{header}\n" f"Торговая пара: {symbol}\n"
+                user_deals_data = await rq.get_user_deal_by_symbol(
+                    tg_id=tg_id, symbol=symbol
+                )
+                if user_deals_data is None:
+                    commission_fee = "Yes_commission_fee"
+                    commission_place = "Commission_for_qty"
+
+                else:
+                    commission_fee = user_deals_data.commission_fee or "Yes_commission_fee"
+                    commission_place = user_deals_data.commission_place or "Commission_for_qty"
+
+                current_series = user_deals_data.current_series
+                current_step = user_deals_data.current_step
+                order_quantity = user_deals_data.order_quantity
+                pnl_series = user_deals_data.pnl_series
+                margin_type = user_deals_data.margin_type
+                take_profit_percent = user_deals_data.take_profit_percent
+                stop_loss_percent = user_deals_data.stop_loss_percent
+                fee = safe_float(user_auto_trading.fee)
+                total_pnl = safe_float(exec_pnl) - safe_float(exec_fee) - fee
+                leverage = safe_float(user_deals_data.leverage)
+
+                if commission_fee == "Yes_commission_fee":
+                    if commission_place == "Commission_for_qty":
+                        total_quantity = safe_float(order_quantity) + safe_float(
+                            total_fee
+                        ) * 2
+                    else:
+                        total_quantity = safe_float(order_quantity)
+                else:
+                    total_quantity = safe_float(order_quantity)
+
+                if user_deals_data is not None and auto_trading and safe_float(closed_size) == 0:
+                    await rq.set_total_fee_user_auto_trading(
+                        tg_id=tg_id, symbol=symbol, total_fee=total_fee
                     )
+                    text += f"Текущая ставка: {total_quantity:.2f} USDT\n"
+                    text += f"Серия №: {current_series}\n"
+                    text += f"Сделка №: {current_step}\n"
 
-                    if res == "OK":
-                        pass
+                text += (
+                    f"Цена исполнения: {exec_price}\n"
+                    f"Комиссия: {exec_fee:.8f}\n"
+                )
+
+                if safe_float(closed_size) == 0:
+                    instruments_info = await get_instruments_info(tg_id=tg_id, symbol=symbol)
+                    qty_step_str = instruments_info.get("lotSizeFilter").get("qtyStep")
+                    qty_step = safe_float(qty_step_str)
+                    qty = (safe_float(order_quantity) * safe_float(leverage)) / safe_float(exec_price)
+                    decimals = abs(int(round(math.log10(qty_step))))
+                    qty_format = math.floor(qty / qty_step) * qty_step
+                    qty_formatted = round(qty_format, decimals)
+                    total_commission = 0
+
+                    if commission_fee == "Yes_commission_fee":
+                        if commission_place == "Commission_for_tp":
+                            total_commission = safe_float(total_fee) / qty_formatted
+
+                    if margin_type == "ISOLATED_MARGIN":
+                        if side == "Buy":
+                            take_profit_price = safe_float(exec_price) * (
+                                    1 + take_profit_percent / 100) + total_commission
+                            stop_loss_price = None
+                        else:
+                            take_profit_price = safe_float(exec_price) * (
+                                    1 - take_profit_percent / 100) - total_commission
+                            stop_loss_price = None
                     else:
-                        errors = {
-                            "Max bets in series": "❗️ Максимальное количество сделок в серии достигнуто",
-                            "Risk is too high for this trade": "❗️ Риск сделки слишком высок для продолжения",
-                            "ab not enough for new order": "❗️ Недостаточно средств для продолжения торговли",
-                            "InvalidRequestError": "❗️ Недостаточно средств для размещения нового ордера с заданным количеством и плечом.",
-                            "The number of contracts exceeds maximum limit allowed": "❗️ Превышен максимальный лимит ставки",
-                        }
-                        error_text = errors.get(
-                            res, "❗️ Не удалось открыть новую сделку"
-                        )
-                        await rq.set_auto_trading(
-                            tg_id=tg_id, symbol=symbol, auto_trading=False
+                        if side == "Buy":
+                            take_profit_price = safe_float(exec_price) * (
+                                    1 + take_profit_percent / 100) + total_commission
+                            stop_loss_price = safe_float(exec_price) * (1 - stop_loss_percent / 100)
+                        else:
+                            take_profit_price = safe_float(exec_price) * (
+                                    1 - take_profit_percent / 100) - total_commission
+                            stop_loss_price = safe_float(exec_price) * (1 + stop_loss_percent / 100)
+
+                        take_profit_price = max(take_profit_price, 0)
+                        stop_loss_price = max(stop_loss_price, 0)
+
+                    ress = await set_tp_sl_for_position(tg_id=tg_id,
+                                                        symbol=symbol,
+                                                        take_profit_price=take_profit_price,
+                                                        stop_loss_price=stop_loss_price,
+                                                        position_idx=0)
+                    if ress:
+                        take_profit_truncated = await truncate_float(take_profit_price, 6)
+                        text += (f"Движение: {side_rus}\n"
+                                 f"Тейк-профит: {take_profit_truncated}\n"
+                                 )
+                        if stop_loss_price is not None:
+                            stop_loss_truncated = await truncate_float(stop_loss_price, 6)
+                        else:
+                            stop_loss_truncated = None
+
+                        if stop_loss_truncated is not None:
+                            text += f"Стоп-лосс: {stop_loss_truncated}\n"
+                        else:
+                            deals = await get_active_positions_by_symbol(
+                                tg_id=tg_id, symbol=symbol
+                            )
+                            position = next((d for d in deals if d.get("symbol") == symbol), None)
+
+                            if position:
+                                liq_price = position.get("liqPrice", 0)
+                                text += f"Цена ликвидации: {liq_price}\n"
+
+
+                    else:
+                        text += (f"Движение: {side_rus}\n"
+                                 "Не удалось установить ТП и СЛ\n")
+
+                else:
+                    if auto_trading:
+                        new_pnl = safe_float(pnl_series) + total_pnl
+                        await rq.set_pnl_series_by_symbol(
+                            tg_id=tg_id, symbol=symbol, pnl_series=new_pnl)
+                        text += f"\nПрибыль без комиссии: {ex_pnl:.4f}\n"
+                        text += f"Реализованная прибыль: {total_pnl:.4f}\n"
+                        text += f"Прибыль серии: {safe_float(new_pnl):.4f}\n"
+                    else:
+                        text += f"\nПрибыль без комиссии: {ex_pnl:.4f}\n"
+                        text += f"Реализованная прибыль: {total_pnl:.4f}\n"
+
+                await self.telegram_bot.send_message(
+                    chat_id=tg_id, text=text, reply_markup=kbi.profile_bybit
+                )
+
+                user_symbols = user_auto_trading.symbol if user_auto_trading else None
+
+                if (
+                        auto_trading
+                        and safe_float(closed_size) > 0
+                        and user_symbols is not None
+                ):
+                    if safe_float(pnl) > 0:
+                        profit_text = "📈 Начинаю новую серию с базовой ставки\n"
+                        await self.telegram_bot.send_message(
+                            chat_id=tg_id, text=profit_text, reply_markup=kbi.profile_bybit
                         )
 
+                        if side == "Buy":
+                            r_side = "Sell"
+                        else:
+                            r_side = "Buy"
+
+                        await rq.set_last_side_by_symbol(
+                            tg_id=tg_id, symbol=symbol, last_side=r_side)
                         await rq.set_total_fee_user_auto_trading(
                             tg_id=tg_id, symbol=symbol, total_fee=0
                         )
                         await rq.set_fee_user_auto_trading(
                             tg_id=tg_id, symbol=symbol, fee=0
                         )
+                        await rq.set_pnl_series_by_symbol(tg_id=tg_id, symbol=symbol, pnl_series=0)
+
+                        res = await trading_cycle_profit(
+                            tg_id=tg_id, symbol=symbol, side=r_side
+                        )
+                        if res == "OK":
+                            pass
+                        else:
+                            errors = {
+                                "Max bets in series": "❗️ Максимальное количество сделок в серии достигнуто",
+                                "Risk is too high for this trade": "❗️ Риск сделки слишком высок для продолжения",
+                                "ab not enough for new order": "❗️ Недостаточно средств для продолжения торговли",
+                                "InvalidRequestError": "❗️ Недостаточно средств для размещения нового ордера с заданным количеством и плечом.",
+                                "The number of contracts exceeds maximum limit allowed": "❗️ Превышен максимальный лимит ставки",
+                                "Order placement failed as your position may exceed the max": "❗️ Превышен максимальный лимит ставки",
+                            }
+                            error_text = errors.get(
+                                res, "❗️ Не удалось открыть новую сделку"
+                            )
+                            await rq.set_auto_trading(
+                                tg_id=tg_id, symbol=symbol, auto_trading=False
+                            )
+
+                            await rq.set_total_fee_user_auto_trading(
+                                tg_id=tg_id, symbol=symbol, total_fee=0
+                            )
+                            await rq.set_fee_user_auto_trading(
+                                tg_id=tg_id, symbol=symbol, fee=0
+                            )
+                            await self.telegram_bot.send_message(
+                                chat_id=tg_id,
+                                text=error_text,
+                                reply_markup=kbi.profile_bybit,
+                            )
+                    else:
+                        open_order_text = "\n❗️ Открываю новую сделку с увеличенной ставкой.\n"
                         await self.telegram_bot.send_message(
-                            chat_id=tg_id,
-                            text=error_text,
-                            reply_markup=kbi.profile_bybit,
+                            chat_id=tg_id, text=open_order_text
                         )
 
+                        if side == "Buy":
+                            r_side = "Sell"
+                        else:
+                            r_side = "Buy"
+
+                        res = await trading_cycle(
+                            tg_id=tg_id, symbol=symbol, side=r_side
+                        )
+
+                        if res == "OK":
+                            pass
+                        else:
+                            errors = {
+                                "Max bets in series": "❗️ Максимальное количество сделок в серии достигнуто",
+                                "Risk is too high for this trade": "❗️ Риск сделки слишком высок для продолжения",
+                                "ab not enough for new order": "❗️ Недостаточно средств для продолжения торговли",
+                                "InvalidRequestError": "❗️ Недостаточно средств для размещения нового ордера с заданным количеством и плечом.",
+                                "The number of contracts exceeds maximum limit allowed": "❗️ Превышен максимальный лимит ставки",
+                                "Order placement failed as your position may exceed the max": "❗️ Превышен максимальный лимит ставки",
+                            }
+                            error_text = errors.get(
+                                res, "❗️ Не удалось открыть новую сделку"
+                            )
+                            await rq.set_auto_trading(
+                                tg_id=tg_id, symbol=symbol, auto_trading=False
+                            )
+
+                            await rq.set_total_fee_user_auto_trading(
+                                tg_id=tg_id, symbol=symbol, total_fee=0
+                            )
+                            await rq.set_fee_user_auto_trading(
+                                tg_id=tg_id, symbol=symbol, fee=0
+                            )
+                            await self.telegram_bot.send_message(
+                                chat_id=tg_id,
+                                text=error_text,
+                                reply_markup=kbi.profile_bybit,
+                            )
         except Exception as e:
-            logger.error("Error in telegram_message_handler: %s", e)
+            logger.error("Error in telegram_message_handler: %s", e, exc_info=True)

app/bybit/web_socket.py

@@ -58,7 +58,8 @@ class WebSocketBot:
                     )
                     logger.info("User %s connected to WebSocket", tg_id)
                 else:
-                    await asyncio.sleep(30)
+                    await asyncio.sleep(5)
+                    await self.try_connect_user(api_key, api_secret, tg_id)
 
             await asyncio.sleep(10)
 
@@ -73,6 +74,7 @@ class WebSocketBot:
         """Try to connect a user to the WebSocket."""
         try:
             self.ws_private = WebSocket(
+                demo=True,
                 testnet=False,
                 channel_type="private",
                 api_key=api_key,
@@ -81,12 +83,6 @@ class WebSocketBot:
 
             self.user_sockets[tg_id] = self.ws_private
             # Connect to the WebSocket private channel
-            # Handle position updates
-            self.ws_private.position_stream(
-                lambda msg: self.loop.call_soon_threadsafe(
-                    asyncio.create_task, self.handle_position_update(msg)
-                )
-            )
             # Handle order updates
             self.ws_private.order_stream(
                 lambda msg: self.loop.call_soon_threadsafe(
@@ -104,16 +100,12 @@ class WebSocketBot:
             logger.error("Error connecting user %s: %s", tg_id, e)
             return False
 
-    async def handle_position_update(self, message):
-        """Handle position updates."""
-        await self.message_handler.format_position_update(message)
-
     async def handle_order_update(self, message, tg_id):
         """Handle order updates."""
         await self.message_handler.format_order_update(message, tg_id)
 
     async def handle_execution_update(self, message, tg_id):
-        """Handle execution updates."""
+        """Handle execution updates without duplicate processing."""
         await self.message_handler.format_execution_update(message, tg_id)
 
     @staticmethod

app/helper_functions.py

@@ -179,3 +179,9 @@ async def calculate_total_budget(
 
         total += r_quantity
     return total
+
+
+
+async def truncate_float(f, decimals=4):
+    factor = 10 ** decimals
+    return int(f * factor) / factor

app/telegram/handlers/changing_the_symbol.py

@@ -121,7 +121,7 @@ async def set_symbol(message: Message, state: FSMContext) -> None:
         )
 
         await rq.set_leverage(tg_id=message.from_user.id, leverage=str(max_leverage))
-        risk_percent = 100 / safe_float(max_leverage)
+        risk_percent = 10 / safe_float(max_leverage)
         await rq.set_stop_loss_percent(
             tg_id=message.from_user.id, stop_loss_percent=risk_percent)
         await rq.set_take_profit_percent(

app/telegram/handlers/main_settings/additional_settings.py

@@ -105,10 +105,10 @@ async def trade_mode(callback_query: CallbackQuery, state: FSMContext) -> None:
         await state.clear()
 
 
-@router_additional_settings.callback_query(F.data == "switch_side_start")
-async def switch_side_start(callback_query: CallbackQuery, state: FSMContext) -> None:
+@router_additional_settings.callback_query(F.data == "switch_side_second")
+async def switch_side_second(callback_query: CallbackQuery, state: FSMContext) -> None:
     """
-    Handles the 'switch_side_start' callback query.
+    Handles the 'switch_side_second' callback query.
 
     Clears the current FSM state, edits the message text to display the switch side start message,
     and shows an inline keyboard for selection.
@@ -123,13 +123,13 @@ async def switch_side_start(callback_query: CallbackQuery, state: FSMContext) ->
     try:
         await state.clear()
         await callback_query.message.edit_text(
-            text="Выберите направление первой сделки серии:\n\n"
+            text="Выберите направление первой сделки последующих серии:\n\n"
                  "По направлению - сделка открывается в направлении последней сделки предыдущей серии.\n"
                  "Противоположно - сделка открывается в противоположном направлении последней сделки предыдущей серии.\n",
             reply_markup=kbi.switch_side,
         )
         logger.debug(
-            "Command switch_side_start processed successfully for user: %s",
+            "Command switch_side_second processed successfully for user: %s",
             callback_query.from_user.id,
         )
     except Exception as e:
@@ -137,7 +137,7 @@ async def switch_side_start(callback_query: CallbackQuery, state: FSMContext) ->
             text="Произошла ошибка. Пожалуйста, попробуйте позже."
         )
         logger.error(
-            "Error processing command switch_side_start for user %s: %s",
+            "Error processing command switch_side_second for user %s: %s",
             callback_query.from_user.id,
             e,
         )
@@ -193,6 +193,89 @@ async def switch_side_handler(callback_query: CallbackQuery, state: FSMContext)
         await state.clear()
 
 
+@router_additional_settings.callback_query(F.data == "switch_side_start")
+async def switch_side_start(callback_query: CallbackQuery, state: FSMContext) -> None:
+    """
+    Handles the 'switch_side_start' callback query.
+
+    Clears the current FSM state, edits the message text to display the switch side second message,
+    and shows an inline keyboard for selection.
+
+    Args:
+        callback_query (CallbackQuery): Incoming callback query from Telegram inline keyboard.
+        state (FSMContext): Finite State Machine context for the current user session.
+
+    Logs:
+        Success or error messages with user identification.
+    """
+    try:
+        await state.clear()
+        await callback_query.message.edit_text(
+            text="Выберите направление первой сделки:\n\n", reply_markup=kbi.side_for_switch
+        )
+        logger.debug(
+            "Command switch_side_start processed successfully for user: %s",
+            callback_query.from_user.id,
+        )
+    except Exception as e:
+        await callback_query.answer(
+            text="Произошла ошибка. Пожалуйста, попробуйте позже."
+        )
+        logger.error(
+            "Error processing command switch_side_start for user %s: %s",
+            callback_query.from_user.id,
+            e,
+        )
+
+
+@router_additional_settings.callback_query(lambda c: c.data == "buy_switch" or c.data == "sell_switch")
+async def switch_side_handler_2(callback_query: CallbackQuery, state: FSMContext) -> None:
+    """
+    Handles callback queries related to switch side selection.
+
+    Updates FSM context with selected switch side and persists the choice in database.
+    Sends an acknowledgement to user and clears FSM state afterward.
+
+    Args:
+        callback_query (CallbackQuery): Incoming callback query indicating selected switch side.
+        state (FSMContext): Finite State Machine context for the current user session.
+
+    Logs:
+        Success or error messages with user identification.
+    """
+    try:
+        if callback_query.data == "sell_switch":
+            side = "Sell"
+            side_rus = "Продажа"
+        else:
+            side = "Buy"
+            side_rus = "Покупка"
+
+        req = await rq.set_side(
+            tg_id=callback_query.from_user.id, side=side
+        )
+
+        if not req:
+            await callback_query.answer(
+                text="Произошла ошибка при смене направления. Пожалуйста, попробуйте позже."
+            )
+            return
+
+        await callback_query.answer(text=f"Выбрано: {side_rus}")
+        logger.debug(
+            "Switch side changed successfully for user: %s", callback_query.from_user.id
+        )
+    except Exception as e:
+        await callback_query.answer(text="Произошла ошибка при смене направления.")
+        logger.error(
+            "Error processing set switch_side for user %s: %s",
+            callback_query.from_user.id,
+            e,
+        )
+    finally:
+        await state.clear()
+
+
 @router_additional_settings.callback_query(F.data == "margin_type")
 async def settings_for_margin_type(
         callback_query: CallbackQuery, state: FSMContext
@@ -577,7 +660,7 @@ async def set_leverage_handler(message: Message, state: FSMContext) -> None:
                 text=f"Кредитное плечо успешно установлено на {leverage_float}",
                 reply_markup=kbi.back_to_additional_settings,
             )
-            risk_percent = 100 / safe_float(leverage_float)
+            risk_percent = 10 / safe_float(leverage_float)
             await rq.set_stop_loss_percent(
                 tg_id=message.from_user.id, stop_loss_percent=risk_percent)
             await rq.set_take_profit_percent(

app/telegram/handlers/main_settings/risk_management.py

@@ -98,7 +98,7 @@ async def set_take_profit_percent(message: Message, state: FSMContext) -> None:
             )
             return
 
-        if safe_float(take_profit_percent_value) < 1 or safe_float(take_profit_percent_value) > 100:
+        if safe_float(take_profit_percent_value) < 0.1 or safe_float(take_profit_percent_value) > 100:
             await message.answer(
                 text="Ошибка: введите число от 1 до 100.",
                 reply_markup=kbi.back_to_risk_management,
@@ -219,7 +219,7 @@ async def set_stop_loss_percent(message: Message, state: FSMContext) -> None:
             )
             return
 
-        if safe_float(stop_loss_percent_value) < 1 or safe_float(stop_loss_percent_value) > 100:
+        if safe_float(stop_loss_percent_value) < 0.1 or safe_float(stop_loss_percent_value) > 100:
             await message.answer(
                 text="Ошибка: введите число от 1 до 100.",
                 reply_markup=kbi.back_to_risk_management,
@@ -341,3 +341,83 @@ async def set_commission_fee(callback_query: CallbackQuery, state: FSMContext) -
         )
     finally:
         await state.clear()
+
+
+@router_risk_management.callback_query(F.data == "compensation_commission")
+async def compensation_commission(callback_query: CallbackQuery, state: FSMContext) -> None:
+    """
+    Handles the 'compensation_commission' callback query.
+
+    Clears the current FSM state, edits the message text to display the compensation commission options,
+    and shows an inline keyboard for selection.
+
+    Args:
+        callback_query (CallbackQuery): Incoming callback query from Telegram inline keyboard.
+        state (FSMContext): Finite State Machine context for the current user session.
+
+    Logs:
+        Success or error messages with user identification.
+    """
+    try:
+        await state.clear()
+        msg = await callback_query.message.edit_text(
+            text="Выберите за счет чего будет происходить компенсация комиссии: ",
+            reply_markup=kbi.commission_place,
+        )
+        await state.update_data(prompt_message_id=msg.message_id)
+        logger.debug(
+            "Command compensation_commission processed successfully for user: %s",
+            callback_query.from_user.id,
+        )
+    except Exception as e:
+        await callback_query.answer(
+            text="Произошла ошибка. Пожалуйста, попробуйте позже."
+        )
+        logger.error(
+            "Error processing command compensation_commission for user %s: %s",
+            callback_query.from_user.id,
+            e,
+        )
+
+
+@router_risk_management.callback_query(
+    lambda c: c.data in ["Commission_for_qty", "Commission_for_tp"]
+)
+async def set_compensation_commission(callback_query: CallbackQuery, state: FSMContext) -> None:
+    """
+    Handles user input for setting the compensation commission.
+
+    Updates FSM context with the selected option and persists the choice in database.
+    Sends an acknowledgement to user and clears FSM state afterward.
+
+    Args:
+        callback_query (CallbackQuery): Incoming callback query from Telegram inline keyboard.
+        state (FSMContext): Finite State Machine context for the current user session.
+
+    Logs:
+        Success or error messages with user identification.
+    """
+    try:
+
+        req = await rq.set_commission_place(
+            tg_id=callback_query.from_user.id, commission_place=callback_query.data
+        )
+
+        if not req:
+            await callback_query.answer(
+                text="Произошла ошибка при установке компенсации комиссии. Пожалуйста, попробуйте позже."
+            )
+            return
+
+        if callback_query.data == "Commission_for_qty":
+            await callback_query.answer(text="Комиссия компенсируется по ставке.")
+        else:
+            await callback_query.answer(text="Комиссия компенсируется по тейк-профиту.")
+    except Exception as e:
+        logger.error(
+            "Error processing command compensation_commission for user %s: %s",
+            callback_query.from_user.id,
+            e,
+        )
+    finally:
+        await state.clear()

app/telegram/handlers/settings.py

@@ -62,10 +62,19 @@ async def additional_settings(callback_query: CallbackQuery, state: FSMContext)
         max_bets = additional_data.max_bets_in_series
         quantity = f(additional_data.order_quantity)
         trigger_price = f(additional_data.trigger_price) or 0
+        side = additional_data.side
+
+        side_map = {
+            "Buy": "Лонг",
+            "Sell": "Шорт",
+        }
+        side_rus = side_map.get(side, side)
 
         switch_side_mode = ""
+        side = ""
         if trade_mode == "Switch":
-            switch_side_mode = f"- Направление первой сделки: {switch_side}\n"
+            side = f"- Направление первой сделки: {side_rus}\n"
+            switch_side_mode = f"- Направление первой сделки последующих серии: {switch_side}\n"
 
         total_budget = await calculate_total_budget(
             quantity=quantity,
@@ -75,6 +84,7 @@ async def additional_settings(callback_query: CallbackQuery, state: FSMContext)
         text = (
             f"Основные настройки:\n\n"
             f"- Режим торговли: {trade_mode_rus}\n"
+            f"{side}"
             f"{switch_side_mode}"
             f"- Тип маржи: {margin_type_rus}\n"
             f"- Размер кредитного плеча: {leverage:.2f}\n"
@@ -120,12 +130,17 @@ async def risk_management(callback_query: CallbackQuery, state: FSMContext) -> N
             commission_fee_rus = (
                 "Да" if commission_fee == "Yes_commission_fee" else "Нет"
             )
+            commission_place = risk_management_data.commission_place
+            commission_place_rus = (
+                "Ставке" if commission_place == "Commission_for_qty" else "Тейк-профиту"
+            )
 
             await callback_query.message.edit_text(
                 text=f"Риск-менеджмент:\n\n"
-                f"- Процент изменения цены для фиксации прибыли: {take_profit_percent:.2f}%\n"
-                f"- Процент изменения цены для фиксации убытка: {stop_loss_percent:.2f}%\n\n"
-                f"- Комиссия биржи для расчета прибыли: {commission_fee_rus}\n\n",
+                     f"- Процент изменения цены для фиксации прибыли: {take_profit_percent:.2f}%\n"
+                     f"- Процент изменения цены для фиксации убытка: {stop_loss_percent:.2f}%\n\n"
+                     f"- Комиссия биржи для расчета прибыли: {commission_fee_rus}\n\n"
+                     f"- Компенсация комиссии по: {commission_place_rus}",
                 reply_markup=kbi.risk_management,
             )
             logger.debug(
@@ -164,7 +179,7 @@ async def conditions(callback_query: CallbackQuery, state: FSMContext) -> None:
             start_timer = conditional_settings_data.timer_start or 0
             await callback_query.message.edit_text(
                 text="Условия торговли:\n\n"
-                f"- Таймер для старта: {start_timer} мин.\n",
+                     f"- Таймер для старта: {start_timer} мин.\n",
                 reply_markup=kbi.conditions,
             )
             logger.debug(

app/telegram/handlers/start_trading.py

@@ -97,7 +97,8 @@ async def start_trading(callback_query: CallbackQuery, state: FSMContext) -> Non
                 "Limit price is out min price": "Цена лимитного ордера меньше допустимого",
                 "Limit price is out max price": "Цена лимитного ордера больше допустимого",
                 "Risk is too high for this trade": "Риск сделки превышает допустимый убыток",
-                "estimated will trigger liq": "Лимитный ордер может вызвать мгновенную ликвидацию. Проверьте параметры ордера.",
+                "estimated will trigger liq": "Лимитный ордер может вызвать мгновенную ликвидацию. "
+                                              "Проверьте параметры ордера.",
                 "ab not enough for new order": "Недостаточно средств для создания нового ордера",
                 "InvalidRequestError": "Произошла ошибка при запуске торговли.",
                 "Order does not meet minimum order value": "Сумма ставки меньше допустимого для запуска торговли. "
@@ -106,6 +107,9 @@ async def start_trading(callback_query: CallbackQuery, state: FSMContext) -> Non
                 "Qty invalid": "Некорректное значение ставки для данного инструмента",
                 "The number of contracts exceeds maximum limit allowed": "️️Превышен максимальный лимит ставки",
                 "The number of contracts exceeds minimum limit allowed": "️️Лимит ставки меньше минимально допустимого",
+                "Order placement failed as your position may exceed the max":
+                    "Не удалось разместить ордер, так как ваша позиция может превышать максимальный лимит."
+                    "Пожалуйста, уменьшите кредитное плечо, чтобы увеличить максимальное значение"
             }
 
             if res == "OK":
@@ -141,7 +145,7 @@ async def start_trading(callback_query: CallbackQuery, state: FSMContext) -> Non
     lambda c: c.data == "cancel_timer_merged"
 )
 async def cancel_start_trading(
-    callback_query: CallbackQuery, state: FSMContext
+        callback_query: CallbackQuery, state: FSMContext
 ) -> None:
     """
     Handles the "cancel_timer" callback query.

app/telegram/handlers/stop_trading.py

@@ -39,21 +39,15 @@ async def stop_all_trading(callback_query: CallbackQuery, state: FSMContext):
                 await rq.set_stop_timer(tg_id=callback_query.from_user.id, timer_end=0)
                 await asyncio.sleep(timer_end * 60)
 
-            user_auto_trading = await rq.get_user_auto_trading(
-                tg_id=callback_query.from_user.id, symbol=symbol
+            await rq.set_auto_trading(
+                tg_id=callback_query.from_user.id,
+                symbol=symbol,
+                auto_trading=False,
             )
+            await close_position_by_symbol(
+                tg_id=callback_query.from_user.id, symbol=symbol)
+            await callback_query.message.edit_text(text=f"Торговля для {symbol} остановлена", reply_markup=kbi.profile_bybit)
 
-            if user_auto_trading and user_auto_trading.auto_trading:
-                await rq.set_auto_trading(
-                    tg_id=callback_query.from_user.id,
-                    symbol=symbol,
-                    auto_trading=False,
-                )
-                await close_position_by_symbol(
-                    tg_id=callback_query.from_user.id, symbol=symbol)
-                await callback_query.message.edit_text(text=f"Торговля для {symbol} остановлена", reply_markup=kbi.profile_bybit)
-            else:
-                await callback_query.message.edit_text(text=f"Нет активной торговли для {symbol}", reply_markup=kbi.profile_bybit)
 
         task = asyncio.create_task(delay_start())
         await add_stop_task(user_id=callback_query.from_user.id, task=task)

app/telegram/keyboards/inline.py

@@ -94,7 +94,10 @@ def get_additional_settings_keyboard(mode: str
 
     if mode == "Switch":
         buttons.append(
-            [InlineKeyboardButton(text="Направление первой сделки", callback_data="switch_side_start")]
+            [InlineKeyboardButton(text="Направление первой сделки первой серии", callback_data="switch_side_start")]
+        )
+        buttons.append(
+            [InlineKeyboardButton(text="Направление первой сделки последующих серии", callback_data="switch_side_second")]
         )
 
     buttons.append(
@@ -148,6 +151,19 @@ switch_side = InlineKeyboardMarkup(
     ]
 )
 
+side_for_switch = InlineKeyboardMarkup(
+    inline_keyboard=[
+        [
+            InlineKeyboardButton(text="Лонг", callback_data="buy_switch"),
+            InlineKeyboardButton(text="Шорт", callback_data="sell_switch"),
+        ],
+        [
+            InlineKeyboardButton(text="Назад", callback_data="additional_settings"),
+            InlineKeyboardButton(text="На главную", callback_data="profile_bybit"),
+        ],
+    ]
+)
+
 margin_type = InlineKeyboardMarkup(
     inline_keyboard=[
         [
@@ -194,6 +210,7 @@ risk_management = InlineKeyboardMarkup(
             ),
         ],
         [InlineKeyboardButton(text="Комиссия биржи", callback_data="commission_fee")],
+        [InlineKeyboardButton(text="Компенсация комиссии", callback_data="compensation_commission")],
         [
             InlineKeyboardButton(text="Назад", callback_data="main_settings"),
             InlineKeyboardButton(text="На главную", callback_data="profile_bybit"),
@@ -223,6 +240,20 @@ commission_fee = InlineKeyboardMarkup(
     ]
 )
 
+
+commission_place = InlineKeyboardMarkup(
+    inline_keyboard=[
+        [
+            InlineKeyboardButton(text="По ставке", callback_data="Commission_for_qty"),
+            InlineKeyboardButton(text="По тейк-профиту", callback_data="Commission_for_tp"),
+        ],
+        [
+            InlineKeyboardButton(text="Назад", callback_data="risk_management"),
+            InlineKeyboardButton(text="На главную", callback_data="profile_bybit"),
+        ],
+    ]
+)
+
 # conditions
 conditions = InlineKeyboardMarkup(
     inline_keyboard=[

database/models.py

@@ -92,6 +92,7 @@ class UserAdditionalSettings(Base):
                      nullable=False, unique=True)
     trade_mode = Column(String, nullable=False, default="Merged_Single")
     switch_side = Column(String, nullable=False, default="По направлению")
+    side = Column(String, nullable=False, default="Buy")
     trigger_price = Column(Float, nullable=False, default=0.0)
     margin_type = Column(String, nullable=False, default="ISOLATED_MARGIN")
     leverage = Column(String, nullable=False, default="10")
@@ -113,6 +114,7 @@ class UserRiskManagement(Base):
     take_profit_percent = Column(Float, nullable=False, default=1)
     stop_loss_percent = Column(Float, nullable=False, default=1)
     commission_fee = Column(String, nullable=False, default="Yes_commission_fee")
+    commission_place = Column(String, nullable=False, default="Commission_for_qty")
 
     user = relationship("User", back_populates="user_risk_management")
 
@@ -155,6 +157,12 @@ class UserDeals(Base):
     take_profit_percent = Column(Integer, nullable=True)
     stop_loss_percent = Column(Integer, nullable=True)
     trigger_price = Column(Float, nullable=True)
+    current_series = Column(Integer, nullable=True)
+    commission_fee = Column(String, nullable=True)
+    commission_place = Column(String, nullable=True)
+    pnl_series = Column(Float, nullable=True)
+    take_profit = Column(Float, nullable=False, default=0.0)
+    stop_loss = Column(Float, nullable=False, default=0.0)
 
     user = relationship("User", back_populates="user_deals")
 

database/request.py

@@ -200,6 +200,8 @@ async def create_user_additional_settings(tg_id: int) -> None:
                 user=user,
                 trade_mode="Long",  # Default value
                 switch_side="По направлению",
+                side="Buy",
+                trigger_price=0.0,
                 margin_type="ISOLATED_MARGIN",
                 leverage="10",
                 order_quantity=1.0,
@@ -358,6 +360,45 @@ async def set_switch_side(tg_id: int, switch_side: str) -> bool:
         return False
 
 
+async def set_side(tg_id: int, side: str) -> bool:
+    """
+    Set side for a user in the database.
+    :param tg_id: Telegram user ID
+    :param side: "BUY" or "SELL"
+    :return: True if successful, False otherwise
+    """
+    try:
+        async with async_session() as session:
+            result = await session.execute(
+                select(User)
+                .options(joinedload(User.user_additional_settings))
+                .filter_by(tg_id=tg_id)
+            )
+            user = result.scalars().first()
+
+            if user:
+                if user.user_additional_settings:
+                    # Updating existing record
+                    user.user_additional_settings.side = side
+                else:
+                    # Creating new record
+                    user_additional_settings = UserAdditionalSettings(
+                        side=side,
+                        user=user,
+                    )
+                    session.add(user_additional_settings)
+
+                await session.commit()
+                logger.info("User side updated for user: %s", tg_id)
+                return True
+            else:
+                logger.error("User not found with tg_id: %s", tg_id)
+                return False
+    except Exception as e:
+        logger.error("Error adding/updating user side for user %s: %s", tg_id, e)
+        return False
+
+
 async def set_leverage(tg_id: int, leverage: str) -> bool:
     """
     Set leverage for a user in the database.
@@ -590,6 +631,7 @@ async def create_user_risk_management(tg_id: int) -> None:
                 take_profit_percent=1.0,
                 stop_loss_percent=1.0,
                 commission_fee="Yes_commission_fee",
+                commission_place="Commission_for_qty"
             )
             session.add(user_risk_management)
             await session.commit()
@@ -749,6 +791,47 @@ async def set_commission_fee(tg_id: int, commission_fee: str) -> bool:
         return False
 
 
+async def set_commission_place(tg_id: int, commission_place: str) -> bool:
+    """
+    Set commission place for a user in the database.
+    :param tg_id: Telegram user ID
+    :param commission_place: Commission place
+    :return: True if successful, False otherwise
+    """
+    try:
+        async with async_session() as session:
+            result = await session.execute(
+                select(User)
+                .options(joinedload(User.user_risk_management))
+                .filter_by(tg_id=tg_id)
+            )
+            user = result.scalars().first()
+
+            if user:
+                if user.user_risk_management:
+                    # Updating existing record
+                    user.user_risk_management.commission_place = commission_place
+                else:
+                    # Creating new record
+                    user_risk_management = UserRiskManagement(
+                        commission_place=commission_place,
+                        user=user,
+                    )
+                    session.add(user_risk_management)
+
+                await session.commit()
+                logger.info("User commission place updated for user: %s", tg_id)
+                return True
+            else:
+                logger.error("User not found with tg_id: %s", tg_id)
+                return False
+    except Exception as e:
+        logger.error(
+            "Error adding/updating user commission place for user %s: %s", tg_id, e
+        )
+        return False
+
+
 # USER CONDITIONAL SETTINGS
 
 
@@ -896,6 +979,7 @@ async def set_user_deal(
         tg_id: int,
         symbol: str,
         current_step: int,
+        current_series: int,
         trade_mode: str,
         side_mode: str,
         margin_type: str,
@@ -906,13 +990,17 @@ async def set_user_deal(
         max_bets_in_series: int,
         take_profit_percent: int,
         stop_loss_percent: int,
-        base_quantity: float
+        base_quantity: float,
+        commission_fee: str,
+        commission_place: str,
+        pnl_series: float
 ):
     """
     Set the user deal in the database.
     :param tg_id: Telegram user ID
     :param symbol: Symbol
     :param current_step: Current step
+    :param current_series: Current series
     :param trade_mode: Trade mode
     :param side_mode: Side mode
     :param margin_type: Margin type
@@ -924,6 +1012,9 @@ async def set_user_deal(
     :param take_profit_percent: Take profit percent
     :param stop_loss_percent: Stop loss percent
     :param base_quantity: Base quantity
+    :param commission_fee: Commission fee
+    :param commission_place: Commission place
+    :param pnl_series: PNL series
     :return: bool
     """
     try:
@@ -942,6 +1033,7 @@ async def set_user_deal(
             if deal:
                 # Updating existing record
                 deal.current_step = current_step
+                deal.current_series = current_series
                 deal.trade_mode = trade_mode
                 deal.side_mode = side_mode
                 deal.margin_type = margin_type
@@ -953,12 +1045,16 @@ async def set_user_deal(
                 deal.take_profit_percent = take_profit_percent
                 deal.stop_loss_percent = stop_loss_percent
                 deal.base_quantity = base_quantity
+                deal.commission_fee = commission_fee
+                deal.commission_place = commission_place
+                deal.pnl_series = pnl_series
             else:
                 # Creating new record
                 new_deal = UserDeals(
                     user=user,
                     symbol=symbol,
                     current_step=current_step,
+                    current_series=current_series,
                     trade_mode=trade_mode,
                     side_mode=side_mode,
                     margin_type=margin_type,
@@ -969,7 +1065,10 @@ async def set_user_deal(
                     max_bets_in_series=max_bets_in_series,
                     take_profit_percent=take_profit_percent,
                     stop_loss_percent=stop_loss_percent,
-                    base_quantity=base_quantity
+                    base_quantity=base_quantity,
+                    commission_fee=commission_fee,
+                    commission_place=commission_place,
+                    pnl_series=pnl_series
                 )
                 session.add(new_deal)
 
@@ -1078,6 +1177,91 @@ async def set_last_side_by_symbol(tg_id: int, symbol: str, last_side: str):
         return False
 
 
+async def set_current_series(tg_id: int, symbol: str, current_series: int):
+    """Set current series for a user deal by symbol in the database."""
+    try:
+        async with async_session() as session:
+            result = await session.execute(select(User).filter_by(tg_id=tg_id))
+            user = result.scalars().first()
+            if user is None:
+                logger.error(f"User with tg_id={tg_id} not found")
+                return False
+
+            result = await session.execute(
+                select(UserDeals).filter_by(user_id=user.id, symbol=symbol)
+            )
+            record = result.scalars().first()
+
+            if record:
+                record.current_series = current_series
+            else:
+                logger.error(f"User deal with user_id={user.id} and symbol={symbol} not found")
+                return False
+            await session.commit()
+            logger.info("Set current series for user %s and symbol %s", tg_id, symbol)
+            return True
+    except Exception as e:
+        logger.error("Error setting user deal current series for user %s and symbol %s: %s", tg_id, symbol, e)
+        return False
+
+
+async def set_tp_sl_by_symbol(tg_id: int, symbol: str, tp: float, sl: float):
+    """Set tp and sl for a user deal by symbol in the database."""
+    try:
+        async with async_session() as session:
+            result = await session.execute(select(User).filter_by(tg_id=tg_id))
+            user = result.scalars().first()
+            if user is None:
+                logger.error(f"User with tg_id={tg_id} not found")
+                return False
+
+            result = await session.execute(
+                select(UserDeals).filter_by(user_id=user.id, symbol=symbol)
+            )
+            record = result.scalars().first()
+
+            if record:
+                record.take_profit = tp
+                record.stop_loss = sl
+            else:
+                logger.error(f"User deal with user_id={user.id} and symbol={symbol} not found")
+                return False
+            await session.commit()
+            logger.info("Set tp and sl for user %s and symbol %s", tg_id, symbol)
+            return True
+    except Exception as e:
+        logger.error("Error setting user deal tp and sl for user %s and symbol %s: %s", tg_id, symbol, e)
+        return False
+
+
+async def set_pnl_series_by_symbol(tg_id: int, symbol: str, pnl_series: float):
+    """Set pnl series for a user deal by symbol in the database."""
+    try:
+        async with async_session() as session:
+            result = await session.execute(select(User).filter_by(tg_id=tg_id))
+            user = result.scalars().first()
+            if user is None:
+                logger.error(f"User with tg_id={tg_id} not found")
+                return False
+
+            result = await session.execute(
+                select(UserDeals).filter_by(user_id=user.id, symbol=symbol)
+            )
+            record = result.scalars().first()
+
+            if record:
+                record.pnl_series = pnl_series
+            else:
+                logger.error(f"User deal with user_id={user.id} and symbol={symbol} not found")
+                return False
+            await session.commit()
+            logger.info("Set pnl series for user %s and symbol %s", tg_id, symbol)
+            return True
+    except Exception as e:
+        logger.error("Error setting user deal pnl series for user %s and symbol %s: %s", tg_id, symbol, e)
+        return False
+
+
 # USER AUTO TRADING
 
 async def get_all_user_auto_trading(tg_id: int):