redis

Reviewed-on: kodorvan/stcs#36

.gitignore

@@ -210,3 +210,6 @@ cython_debug/
 marimo/_static/
 marimo/_lsp/
 __marimo__/
+
+stcs_venv
+venv

README.md

@@ -1,6 +1,11 @@
-Crypto Trading Telegram Bot
+# Crypto Trading Telegram Bot by [KODORVAN](https://git.svoboda.works/kodorvan)
 
-Этот бот — автоматизированный торговый помощник для работы с криптовалютной биржей Bybit на основе стратегии мартингейла. Он позволяет торговать бессрочными контрактами с управлением рисками, тейк-профитами, стоп-лоссами и кредитным плечом.
+Автоматизированный торговый помощник для работы с криптовалютной биржей Bybit на основе стратегии мартингейла.<br>
+Он позволяет торговать бессрочными контрактами с управлением рисками, тейк-профитами, стоп-лоссами и кредитным плечом.
+
+
+**Разработано командой [КОДОРВАНЬ](https://git.svoboda.works/kodorvan)**<br>
+_Мы окажем полное содействие и поддержку, пишите в телеграм: https://t.me/kodorvan_
 
 ## Основные возможности
 
@@ -59,7 +64,12 @@ nvim .env
 alembic upgrade head
 ```
 
-5. Запустите бота:
+6. Убедитесь в том, что установлен redis и открыт порт 6789
+```bash
+sudo ufw allow 6789
+```
+
+7. Запустите бота:
 
 ```bash
 python run.py

alembic.ini

@@ -84,7 +84,7 @@ path_separator = os
 # database URL.  This is consumed by the user-maintained env.py script only.
 # other means of configuring database URLs may be customized within the env.py
 # file.
-sqlalchemy.url = sqlite+aiosqlite:///./database/db/stcs.db
+sqlalchemy.url = sqlite+aiosqlite:///./database/stcs.db
 
 
 [post_write_hooks]

alembic/versions/0ee52ab23e66_added_column_current_series.py

@@ -1,32 +0,0 @@
-"""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/adf3d2991896_added_column_commission_place.py

@@ -1,45 +0,0 @@
-"""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

@@ -1,34 +0,0 @@
-"""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 ###

alembic/versions/f6e7eb3f25c0_initial.py

@@ -1,8 +1,8 @@
-"""Added side_mode column
+"""initial
 
-Revision ID: fbf4e3658310
+Revision ID: f6e7eb3f25c0
 Revises: 
-Create Date: 2025-10-22 13:08:02.317419
+Create Date: 2025-11-12 22:53:02.189445
 
 """
 from typing import Sequence, Union
@@ -12,7 +12,7 @@ import sqlalchemy as sa
 
 
 # revision identifiers, used by Alembic.
-revision: str = 'fbf4e3658310'
+revision: str = 'f6e7eb3f25c0'
 down_revision: Union[str, Sequence[str], None] = None
 branch_labels: Union[str, Sequence[str], None] = None
 depends_on: Union[str, Sequence[str], None] = None
@@ -21,12 +21,12 @@ 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('side_mode', sa.String(), nullable=True))
+    pass
     # ### end Alembic commands ###
 
 
 def downgrade() -> None:
     """Downgrade schema."""
     # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_column('user_deals', 'side_mode')
+    pass
     # ### end Alembic commands ###

app/bybit/get_functions/get_positions.py

@@ -38,7 +38,7 @@ async def get_active_positions(tg_id: int) -> list | None:
         return None
 
 
-async def get_active_positions_by_symbol(tg_id: int, symbol: str) -> dict | None:
+async def get_active_positions_by_symbol(tg_id: int, symbol: str):
     """
     Get active positions for a user by symbol
     """
@@ -62,6 +62,10 @@ async def get_active_positions_by_symbol(tg_id: int, symbol: str) -> dict | None
             )
             return None
     except Exception as e:
+        errors = str(e)
+        if errors.startswith("Permission denied, please check your API key permissions"):
+            return "Invalid API key permissions"
+        else:
             logger.error("Error getting active positions for user %s: %s", tg_id, e)
             return None
 

app/bybit/open_positions.py

@@ -30,7 +30,7 @@ async def start_trading_cycle(
         risk_management_data = await rq.get_user_risk_management(tg_id=tg_id)
         trade_mode = additional_data.trade_mode
         switch_side = additional_data.switch_side
-        side= additional_data.side
+        side = additional_data.side
         margin_type = additional_data.margin_type
         leverage = additional_data.leverage
         order_quantity = additional_data.order_quantity
@@ -54,12 +54,6 @@ 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(
-            tg_id=tg_id,
-            symbol=symbol,
-            leverage=leverage,
-        )
 
         await rq.set_user_deal(
             tg_id=tg_id,
@@ -78,7 +72,14 @@ async def start_trading_cycle(
             stop_loss_percent=stop_loss_percent,
             base_quantity=order_quantity,
             commission_fee=commission_fee,
-            commission_place=commission_place
+            commission_place=commission_place,
+            pnl_series=0
+        )
+        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 open_positions(
@@ -87,10 +88,7 @@ async def start_trading_cycle(
             side=side,
             order_quantity=order_quantity,
             trigger_price=trigger_price,
-            margin_type=margin_type,
+            leverage=leverage
-            leverage=leverage,
-            take_profit_percent=take_profit_percent,
-            stop_loss_percent=stop_loss_percent,
         )
 
         if res == "OK":
@@ -109,7 +107,9 @@ 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",
+                   "Permission denied, please check your API key permissions"
                }
             else None
         )
@@ -171,7 +171,8 @@ async def trading_cycle_profit(
             stop_loss_percent=stop_loss_percent,
             base_quantity=base_quantity,
             commission_fee=commission_fee,
-            commission_place=commission_place
+            commission_place=commission_place,
+            pnl_series=0
         )
 
         res = await open_positions(
@@ -180,10 +181,7 @@ async def trading_cycle_profit(
             side=s_side,
             order_quantity=base_quantity,
             trigger_price=trigger_price,
-            margin_type=margin_type,
+            leverage=leverage
-            leverage=leverage,
-            take_profit_percent=take_profit_percent,
-            stop_loss_percent=stop_loss_percent,
         )
 
         if res == "OK":
@@ -197,6 +195,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
         )
@@ -227,15 +226,13 @@ async def trading_cycle(
         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)
         )
         current_step += 1
 
-        if max_bets_in_series < current_step:
-            return "Max bets in series"
-
         await set_margin_mode(tg_id=tg_id, margin_mode=margin_type)
         await set_leverage(
             tg_id=tg_id,
@@ -272,7 +269,8 @@ async def trading_cycle(
             stop_loss_percent=stop_loss_percent,
             base_quantity=base_quantity,
             commission_fee=commission_fee,
-            commission_place=commission_place
+            commission_place=commission_place,
+            pnl_series=pnl_series
         )
 
         res = await open_positions(
@@ -281,10 +279,7 @@ async def trading_cycle(
             side=r_side,
             order_quantity=total_quantity,
             trigger_price=trigger_price,
-            margin_type=margin_type,
+            leverage=leverage
-            leverage=leverage,
-            take_profit_percent=take_profit_percent,
-            stop_loss_percent=stop_loss_percent,
         )
 
         if res == "OK":
@@ -298,6 +293,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,20 +309,17 @@ async def open_positions(
         symbol: str,
         order_quantity: float,
         trigger_price: float,
-        margin_type: str,
+        leverage: str
-        leverage: str,
-        take_profit_percent: float,
-        stop_loss_percent: float
 ) -> str | None:
     try:
         client = await get_bybit_client(tg_id=tg_id)
-        user_deals_data = await rq.get_user_deal_by_symbol(tg_id=tg_id, symbol=symbol)
-        commission_fee = user_deals_data.commission_fee
-        commission_place = user_deals_data.commission_place
-        user_auto_trading_data = await rq.get_user_auto_trading(tg_id=tg_id, symbol=symbol)
-        total_fee = user_auto_trading_data.total_fee
         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)
@@ -342,38 +335,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"
-
-        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 = price_for_cals * (
-                        1 + take_profit_percent / 100) + total_commission
-                stop_loss_price = None
-            else:
-                take_profit_price = price_for_cals * (
-                        1 - take_profit_percent / 100) - total_commission
-                stop_loss_price = None
-        else:
-            if side == "Buy":
-                take_profit_price = price_for_cals * (
-                            1 + take_profit_percent / 100) + total_commission
-                stop_loss_price = price_for_cals * (1 - stop_loss_percent / 100)
-            else:
-                take_profit_price = price_for_cals * (
-                            1 - take_profit_percent / 100) - total_commission
-                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",
@@ -386,9 +347,6 @@ async def open_positions(
             "triggerBy": "LastPrice",
             "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)
@@ -410,6 +368,8 @@ 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",
+            "Permission denied, please check your API key permissions": "Permission denied, please check your API key permissions"
         }
         for key, msg in known_errors.items():
             if key in error_text:

app/bybit/profile_bybit.py

@@ -37,7 +37,7 @@ async def user_profile_bybit(tg_id: int, message: Message, state: FSMContext) ->
                 )
         else:
             await message.answer(
-                text="Ошибка при подключении, повторите попытку",
+                text="Ошибка при подключении к платформе. Проверьте корректность и разрешения API ключа и добавьте повторно.",
                 reply_markup=kbi.connect_the_platform,
             )
             logger.error("Error processing user profile for user %s", tg_id)

app/bybit/set_functions/set_tp_sl.py

@@ -13,7 +13,7 @@ async def set_tp_sl_for_position(
     take_profit_price: float,
     stop_loss_price: float,
     position_idx: int,
-) -> bool:
+) -> bool | str:
     """
     Set take profit and stop loss for a symbol.
     :param tg_id: Telegram user ID
@@ -21,15 +21,17 @@ async def set_tp_sl_for_position(
     :param take_profit_price: Take profit price
     :param stop_loss_price: Stop loss price
     :param position_idx: Position index
-    :return: bool
+    :return: bool or str
     """
     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)),
+            takeProfit=str(take_profit) if take_profit is not None else None,
-            stopLoss=str(round(stop_loss_price, 5)),
+            stopLoss=str(stop_loss) if stop_loss is not None else None,
             positionIdx=position_idx,
             tpslMode="Full",
         )
@@ -38,8 +40,18 @@ async def set_tp_sl_for_position(
             logger.info("TP/SL for %s has been set", symbol)
             return True
         else:
-            logger.error("Error setting TP/SL for %s: %s", symbol, resp.get("retMsg"))
+            error_msg = resp.get("retMsg")
+            if "not modified" in error_msg.lower():
+                logger.info("TP/SL for %s not modified: %s", symbol, error_msg)
+                return "not modified"
+            else:
+                logger.error("Error setting TP/SL for %s: %s", symbol, error_msg)
                 return False
     except Exception as e:
-        logger.error("Error setting TP/SL for %s: %s", symbol, e)
+        error_msg = str(e)
+        if "not modified" in error_msg.lower():
+            logger.info("TP/SL for %s not modified: %s", symbol, error_msg)
+            return "not modified"
+        else:
+            logger.error("Error set TP/SL for %s: %s", symbol, e)
             return False

app/bybit/telegram_message_handler.py

@@ -1,10 +1,13 @@
 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.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")
@@ -12,16 +15,18 @@ logger = logging.getLogger("telegram_message_handler")
 
 class TelegramMessageHandler:
     def __init__(self, telegram_bot):
+        """Initialize the TelegramMessageHandler class."""
         self.telegram_bot = telegram_bot
 
-    async def format_position_update(self, message):
-        pass
-
     async def format_order_update(self, message, tg_id):
+        """Handle order updates."""
         try:
+            # logger.info("Order update: %s", json.dumps(message))
+            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"))
-            qty = format_value(order_data.get("qty"))
                 side = format_value(order_data.get("side"))
                 side_rus = (
                     "Покупка"
@@ -29,10 +34,7 @@ class TelegramMessageHandler:
                     else "Продажа" if side == "Sell" else "Нет данных"
                 )
                 order_status = format_value(order_data.get("orderStatus"))
-            price = format_value(order_data.get("price"))
+                tr_price = format_value(order_data.get("triggerPrice"))
-            trigger_price = format_value(order_data.get("triggerPrice"))
-            take_profit = format_value(order_data.get("takeProfit"))
-            stop_loss = format_value(order_data.get("stopLoss"))
 
                 status_map = {
                     "Untriggered": "Условный ордер выставлен",
@@ -41,44 +43,27 @@ class TelegramMessageHandler:
                 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 != "Нет данных":
-            if user_deals_data is not None and auto_trading:
+                    text += f"Триггер цена: {tr_price}\n"
-                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 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):
+        """Handle execution updates without duplicate processing."""
         try:
+            # logger.info("Execution update: %s", json.dumps(message))
             execution = message.get("data", [{}])[0]
+            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"))
@@ -86,6 +71,18 @@ class TelegramMessageHandler:
                 exec_fees = format_value(execution.get("execFee"))
                 fee_rate = format_value(execution.get("feeRate"))
                 side = format_value(execution.get("side"))
+                exec_pnl = format_value(execution.get("execPnl"))
+                stop_order_type = format_value(execution.get("stopOrderType"))
+                create_type = format_value(execution.get("createType"))
+
+                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
+                )
+
+                if auto_trading:
                     side_rus = (
                         "Покупка"
                         if side == "Buy"
@@ -103,48 +100,51 @@ class TelegramMessageHandler:
                             tg_id=tg_id, symbol=symbol, fee=safe_float(exec_fee)
                         )
 
-            user_auto_trading = await rq.get_user_auto_trading(
+                    get_total_fee = 0
-                tg_id=tg_id, symbol=symbol
-            )
 
+                    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"))
+                    total_fee = safe_float(exec_fee) + safe_float(get_total_fee)
-            pnl = safe_float(exec_pnl)
+                    ex_pnl = safe_float(exec_pnl)
 
                     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
                     )
+
                     commission_fee = user_deals_data.commission_fee
                     commission_place = user_deals_data.commission_place
                     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
+                    take_profit_percent = user_deals_data.take_profit_percent
+                    stop_loss_percent = user_deals_data.stop_loss_percent
+                    leverage = safe_float(user_deals_data.leverage)
+                    fee = safe_float(user_auto_trading.fee)
+                    total_pnl = safe_float(exec_pnl) - safe_float(exec_fee) - fee
 
                     if commission_fee == "Yes_commission_fee":
                         if commission_place == "Commission_for_qty":
-                    total_quantity = safe_float(user_deals_data.order_quantity) + safe_float(
+                            total_quantity = safe_float(order_quantity) + safe_float(
                                 total_fee
-                    )
+                            ) * 2
                         else:
-                    total_quantity = safe_float(user_deals_data.order_quantity)
+                            total_quantity = safe_float(order_quantity)
                     else:
-                total_quantity = safe_float(user_deals_data.order_quantity)
+                        total_quantity = safe_float(order_quantity)
 
-            if user_deals_data is not None and auto_trading and safe_float(closed_size) == 0:
+                    if user_deals_data is not None 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"Серия №: {user_deals_data.current_series}\n"
+                        text += f"Серия №: {current_series}\n"
-                text += f"Сделка №: {user_deals_data.current_step}\n"
+                        text += f"Сделка №: {current_step}\n"
 
                     text += (
                         f"Цена исполнения: {exec_price}\n"
@@ -152,22 +152,57 @@ class TelegramMessageHandler:
                     )
 
                     if safe_float(closed_size) == 0:
-                text += f"Движение: {side_rus}\n"
+                        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 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:
-                text += f"\nПрибыль: {pnl:.7f}\n"
+                            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)
+
+                        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 or ress == "not modified":
+                            take_profit_truncated = await truncate_float(take_profit_price, 6)
+                            stop_loss_truncated = await truncate_float(stop_loss_price, 6)
+                            text += (f"Движение: {side_rus}\n"
+                                     f"Тейк-профит: {take_profit_truncated}\n"
+                                     f"Стоп-лосс: {stop_loss_truncated}\n"
+                                     )
+                        else:
+                            text += (f"Движение: {side_rus}\n"
+                                     "Не удалось установить ТП и СЛ\n")
+
+                    elif safe_float(closed_size) > 0 and 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"
 
                     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 stop_order_type == "TakeProfit":
-
-            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
@@ -186,6 +221,7 @@ class TelegramMessageHandler:
                         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
@@ -194,11 +230,69 @@ class TelegramMessageHandler:
                             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,
+                            )
+
+                    elif stop_order_type == "StopLoss" or exec_type == "BustTrade":
+                        current_step = user_deals_data.current_step
+                        max_bets_in_series = user_deals_data.max_bets_in_series
+                        current_step += 1
+
+                        if max_bets_in_series < current_step:
+                            text_series = ("\n❗️ Максимальное количество сделок в серии достигнуто.\n"
+                                           "📈 Начинаю новую серию с базовой ставки\n")
+                            await self.telegram_bot.send_message(
+                                chat_id=tg_id, text=text_series
+                            )
+                            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 = {
+                                    "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, "❗️ Не удалось открыть новую сделку"
@@ -237,11 +331,11 @@ class TelegramMessageHandler:
                                 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, "❗️ Не удалось открыть новую сделку"
@@ -261,6 +355,25 @@ class TelegramMessageHandler:
                                     text=error_text,
                                     reply_markup=kbi.profile_bybit,
                                 )
+                    elif create_type == "CreateByClosing":
+                        await self.telegram_bot.send_message(
+                            chat_id=tg_id,
+                            text=f"❗️ Торговля для {symbol} остановлена",
+                            reply_markup=kbi.profile_bybit,
+                        )
+                        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
+                        )
+                        logger.info("Stop trading for symbol: %s, create_type: %s, stop_order_type: %s: %s",
+                                    symbol, create_type, stop_order_type, tg_id)
+            else:
+                logger.info("Execution update: %s", json.dumps(message))
         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

@@ -1,4 +1,5 @@
 import asyncio
+from collections import deque
 import logging.config
 
 from pybit.unified_trading import WebSocket
@@ -11,25 +12,49 @@ logging.config.dictConfig(LOGGING_CONFIG)
 logger = logging.getLogger("web_socket")
 
 
+class CustomWebSocket(WebSocket):
+    """Custom WebSocket wrapper with enhanced error handling."""
+
+    def _on_error(self, error):
+        logger.error(f"WebSocket error: {error}")
+        return super()._on_error(error)
+
+    def _on_close(self):
+        logger.warning("WebSocket connection closed")
+        super()._on_close()
+
+
 class WebSocketBot:
     """
-    Class to handle WebSocket connections and messages.
+    Manages multiple Bybit private WebSocket connections for Telegram users.
+    Uses queue-based message processing to handle thread-safe async calls.
     """
 
     def __init__(self, telegram_bot):
-        """Initialize the TradingBot class."""
+        """
+        Initialize WebSocketBot.
+
+        Args:
+            telegram_bot: Telegram bot instance for message handling
+        """
         self.telegram_bot = telegram_bot
-        self.ws_private = None
-        self.user_messages = {}
         self.user_sockets = {}
+        self.user_messages = {}
         self.user_keys = {}
         self.loop = None
         self.message_handler = TelegramMessageHandler(telegram_bot)
 
+        self.order_queues = {}  # {tg_id: deque}
+        self.execution_queues = {}  # {tg_id: deque}
+        self.processing_tasks = {}  # {tg_id: task}
+
     async def run_user_check_loop(self):
-        """Run a loop to check for users and connect them to the WebSocket."""
+        """Main loop that continuously checks users and maintains connections."""
         self.loop = asyncio.get_running_loop()
+        logger.info("Starting WebSocket user check loop")
+
         while True:
+            try:
                 users = await WebSocketBot.get_users_from_db()
                 for user in users:
                     tg_id = user.tg_id
@@ -39,16 +64,13 @@ class WebSocketBot:
                         continue
 
                     keys_stored = self.user_keys.get(tg_id)
-                if tg_id in self.user_sockets and keys_stored == (api_key, api_secret):
+                    socket_exists = tg_id in self.user_sockets
+
+                    if socket_exists and keys_stored == (api_key, api_secret):
                         continue
 
-                if tg_id in self.user_sockets:
+                    if socket_exists:
-                    self.user_sockets.clear()
+                        await self.close_user_socket(tg_id)
-                    self.user_messages.clear()
-                    self.user_keys.clear()
-                    logger.info(
-                        "Closed old websocket for user %s due to key change", tg_id
-                    )
 
                     success = await self.try_connect_user(api_key, api_secret, tg_id)
                     if success:
@@ -56,69 +78,112 @@ class WebSocketBot:
                         self.user_messages.setdefault(
                             tg_id, {"position": None, "order": None, "execution": None}
                         )
-                    logger.info("User %s connected to WebSocket", tg_id)
+                        logger.info("User %s successfully connected", tg_id)
-                else:
+
-                    await asyncio.sleep(5)
+            except Exception as e:
-                    await self.try_connect_user(api_key, api_secret, tg_id)
+                logger.error("Error in user check loop: %s", e)
 
             await asyncio.sleep(10)
 
-    async def clear_user_sockets(self):
-        """Clear the user_sockets and user_messages dictionaries."""
-        self.user_sockets.clear()
-        self.user_messages.clear()
-        self.user_keys.clear()
-        logger.info("Cleared user_sockets")
-
     async def try_connect_user(self, api_key, api_secret, tg_id):
-        """Try to connect a user to the WebSocket."""
+        """
+        Create and setup WebSocket streams with thread-safe queues.
+        """
         try:
-            self.ws_private = WebSocket(
+            ws = CustomWebSocket(
                 demo=True,
                 testnet=False,
                 channel_type="private",
                 api_key=api_key,
-                api_secret=api_secret,
+                api_secret=api_secret
             )
 
-            self.user_sockets[tg_id] = self.ws_private
+            self.user_sockets[tg_id] = ws
-            # Connect to the WebSocket private channel
+
-            # Handle position updates
+            self.order_queues[tg_id] = deque()
-            self.ws_private.position_stream(
+            self.execution_queues[tg_id] = deque()
-                lambda msg: self.loop.call_soon_threadsafe(
+
-                    asyncio.create_task, self.handle_position_update(msg)
+            self.processing_tasks[tg_id] = asyncio.create_task(
-                )
+                self._process_order_queue(tg_id)
-            )
-            # Handle order updates
-            self.ws_private.order_stream(
-                lambda msg: self.loop.call_soon_threadsafe(
-                    asyncio.create_task, self.handle_order_update(msg, tg_id)
-                )
-            )
-            # Handle execution updates
-            self.ws_private.execution_stream(
-                lambda msg: self.loop.call_soon_threadsafe(
-                    asyncio.create_task, self.handle_execution_update(msg, tg_id)
             )
+            self.processing_tasks[tg_id + 1] = asyncio.create_task(
+                self._process_execution_queue(tg_id)
             )
+
+            def order_callback(msg):
+                self.order_queues[tg_id].append(msg)
+
+            def execution_callback(msg):
+                self.execution_queues[tg_id].append(msg)
+
+            ws.order_stream(order_callback)
+            ws.execution_stream(execution_callback)
+
+            logger.info("WebSocket streams configured for user %s", tg_id)
             return True
+
         except Exception as e:
             logger.error("Error connecting user %s: %s", tg_id, e)
+            self.user_sockets.pop(tg_id, None)
             return False
 
-    async def handle_position_update(self, message):
+    async def _process_order_queue(self, tg_id):
-        """Handle position updates."""
+        """Continuously process order queue for user."""
-        await self.message_handler.format_position_update(message)
+        while tg_id in self.user_sockets:
+            try:
+                if self.order_queues[tg_id]:
+                    msg = self.order_queues[tg_id].popleft()
+                    await self.handle_order_update(msg, tg_id)
+            except Exception as e:
+                logger.error("Error processing order queue %s: %s", tg_id, e)
+            await asyncio.sleep(0.01)
+
+    async def _process_execution_queue(self, tg_id):
+        """Continuously process execution queue for user."""
+        while tg_id in self.user_sockets:
+            try:
+                if self.execution_queues[tg_id]:
+                    msg = self.execution_queues[tg_id].popleft()
+                    await self.handle_execution_update(msg, tg_id)
+            except Exception as e:
+                logger.error("Error processing execution queue %s: %s", tg_id, e)
+            await asyncio.sleep(0.01)
+
+    async def close_user_socket(self, tg_id):
+        """Gracefully close user connection."""
+        if tg_id in self.user_sockets:
+            self.user_sockets.pop(tg_id, None)
+
+            for key in (tg_id, tg_id + 1):
+                task = self.processing_tasks.pop(key, None)
+                if task and not task.done():
+                    task.cancel()
+
+            self.order_queues.pop(tg_id, None)
+            self.execution_queues.pop(tg_id, None)
+            self.user_messages.pop(tg_id, None)
+            self.user_keys.pop(tg_id, None)
+            logger.info("Cleaned up user %s", tg_id)
 
     async def handle_order_update(self, message, tg_id):
-        """Handle order updates."""
+        """Process order updates."""
+        try:
             await self.message_handler.format_order_update(message, tg_id)
+        except Exception as e:
+            logger.error("Error handling order update for %s: %s", tg_id, e)
 
     async def handle_execution_update(self, message, tg_id):
-        """Handle execution updates."""
+        """Process execution updates."""
+        try:
             await self.message_handler.format_execution_update(message, tg_id)
+        except Exception as e:
+            logger.error("Error handling execution update for %s: %s", tg_id, e)
 
     @staticmethod
     async def get_users_from_db():
-        """Get all users from the database."""
+        """Fetch all users from database."""
+        try:
             return await rq.get_users()
+        except Exception as e:
+            logger.error("Error getting users from DB: %s", e)
+            return []

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/handlers_main.py

@@ -85,6 +85,18 @@ async def cmd_to_main(message: Message, state: FSMContext) -> None:
         None: Exceptions are caught and logged internally.
     """
     try:
+        await state.clear()
+        user = await rq.get_user(tg_id=message.from_user.id)
+        if user:
+            await user_profile_tg(tg_id=message.from_user.id, message=message)
+        else:
+            await rq.create_user(
+                tg_id=message.from_user.id, username=message.from_user.username
+            )
+            await rq.set_user_symbol(tg_id=message.from_user.id, symbol="BTCUSDT")
+            await rq.create_user_additional_settings(tg_id=message.from_user.id)
+            await rq.create_user_risk_management(tg_id=message.from_user.id)
+            await rq.create_user_conditional_settings(tg_id=message.from_user.id)
             await user_profile_tg(tg_id=message.from_user.id, message=message)
         logger.debug(
             "Command to_profile_tg processed successfully for user: %s",
@@ -117,9 +129,21 @@ async def profile_bybit(message: Message, state: FSMContext) -> None:
     """
     try:
         await state.clear()
+        user = await rq.get_user(tg_id=message.from_user.id)
+        if user:
             await user_profile_bybit(
                 tg_id=message.from_user.id, message=message, state=state
             )
+        else:
+            await rq.create_user(
+                tg_id=message.from_user.id, username=message.from_user.username
+            )
+            await rq.set_user_symbol(tg_id=message.from_user.id, symbol="BTCUSDT")
+            await rq.create_user_additional_settings(tg_id=message.from_user.id)
+            await rq.create_user_risk_management(tg_id=message.from_user.id)
+            await rq.create_user_conditional_settings(tg_id=message.from_user.id)
+            await user_profile_bybit(
+                tg_id=message.from_user.id, message=message, state=state)
         logger.debug(
             "Command to_profile_bybit processed successfully for user: %s",
             message.from_user.id,
@@ -150,6 +174,9 @@ async def profile_bybit_callback(
     """
     try:
         await state.clear()
+        user = await rq.get_user(tg_id=callback_query.from_user.id)
+
+        if user:
             await user_profile_bybit(
                 tg_id=callback_query.from_user.id,
                 message=callback_query.message,
@@ -159,6 +186,19 @@ async def profile_bybit_callback(
                 "Callback profile_bybit processed successfully for user: %s",
                 callback_query.from_user.id,
             )
+        else:
+            await rq.create_user(
+                tg_id=callback_query.from_user.id, username=callback_query.from_user.username
+            )
+            await rq.set_user_symbol(tg_id=callback_query.from_user.id, symbol="BTCUSDT")
+            await rq.create_user_additional_settings(tg_id=callback_query.from_user.id)
+            await rq.create_user_risk_management(tg_id=callback_query.from_user.id)
+            await rq.create_user_conditional_settings(tg_id=callback_query.from_user.id)
+            await user_profile_bybit(
+                tg_id=callback_query.from_user.id,
+                message=callback_query.message,
+                state=state,
+            )
         await callback_query.answer()
     except Exception as e:
         logger.error(

app/telegram/handlers/main_settings/additional_settings.py

@@ -299,6 +299,12 @@ async def settings_for_margin_type(
         deals = await get_active_positions_by_symbol(
             tg_id=callback_query.from_user.id, symbol=symbol
         )
+        if deals == "Invalid API key permissions":
+            await callback_query.answer(
+                text="API ключ не имеет достаточных прав для смены маржи",
+            )
+            return
+
         position = next((d for d in deals if d.get("symbol") == symbol), None)
 
         if position:
@@ -660,7 +666,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(
@@ -676,6 +682,15 @@ async def set_leverage_handler(message: Message, state: FSMContext) -> None:
 
         await state.clear()
     except Exception as e:
+        errors_text = str(e)
+        known_errors = {
+            "Permission denied, please check your API key permissions": "API ключ не имеет достаточных прав для установки кредитного плеча"
+
+        }
+        for key, msg in known_errors.items():
+            if key in errors_text:
+                await message.answer(msg, reply_markup=kbi.back_to_additional_settings)
+            else:
                 await message.answer(
                     text="Произошла ошибка при установке кредитного плеча. Пожалуйста, попробуйте позже.",
                     reply_markup=kbi.back_to_additional_settings,

app/telegram/handlers/start_trading.py

@@ -38,6 +38,12 @@ async def start_trading(callback_query: CallbackQuery, state: FSMContext) -> Non
         deals = await get_active_positions_by_symbol(
             tg_id=callback_query.from_user.id, symbol=symbol
         )
+        if deals == "Invalid API key permissions":
+            await callback_query.answer(
+                text="API ключ не имеет достаточных прав для запуска торговли",
+            )
+            return
+
         position = next((d for d in deals if d.get("symbol") == symbol), None)
 
         if position:
@@ -97,7 +103,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 +113,11 @@ 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":
+                    "Не удалось разместить ордер, так как ваша позиция может превышать максимальный лимит."
+                    "Пожалуйста, уменьшите кредитное плечо, чтобы увеличить максимальное значение",
+                "Permission denied, please check your API key permissions": "API ключ не имеет достаточных прав для запуска торговли"
+
             }
 
             if res == "OK":
@@ -127,6 +139,15 @@ async def start_trading(callback_query: CallbackQuery, state: FSMContext) -> Non
         await add_start_task_merged(user_id=callback_query.from_user.id, task=task)
 
     except Exception as e:
+        error_text = str(e)
+        known_errors = {
+                "Permission denied, please check your API key permissions": "API ключ не имеет достаточных прав для запуска торговли"
+
+        }
+        for key, msg in known_errors.items():
+            if key in error_text:
+                await callback_query.answer(msg)
+            else:
                 await callback_query.answer(text="Произошла ошибка при запуске торговли")
         logger.error(
             "Error processing command start_trading for user %s: %s",

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(
+            await close_position_by_symbol(
-                tg_id=callback_query.from_user.id, symbol=symbol
+                tg_id=callback_query.from_user.id, symbol=symbol)
-            )
-
-            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)

database/__init__.py

@@ -10,10 +10,9 @@ logging.config.dictConfig(LOGGING_CONFIG)
 logger = logging.getLogger("database")
 
 BASE_DIR = Path(__file__).parent.resolve()
-DATA_DIR = BASE_DIR / "db"
+BASE_DIR.mkdir(parents=True, exist_ok=True)
-DATA_DIR.mkdir(parents=True, exist_ok=True)
 
-DATABASE_URL = f"sqlite+aiosqlite:///{DATA_DIR / 'stcs.db'}"
+DATABASE_URL = f"sqlite+aiosqlite:///{BASE_DIR / 'stcs.db'}"
 
 async_engine = create_async_engine(
     DATABASE_URL,
@@ -39,7 +38,7 @@ async_session = async_sessionmaker(
 async def init_db():
     try:
         async with async_engine.begin() as conn:
-            await conn.run_sync(Base.metadata.create_all)
+            await conn.run_sync(lambda sync_conn: Base.metadata.create_all(bind=sync_conn, checkfirst=True))
         logger.info("Database initialized.")
     except Exception as e:
         logger.error("Database initialization failed: %s", e)

database/models.py

@@ -154,12 +154,15 @@ class UserDeals(Base):
     order_quantity = Column(Float, nullable=True)
     martingale_factor = Column(Float, nullable=True)
     max_bets_in_series = Column(Integer, nullable=True)
-    take_profit_percent = Column(Integer, nullable=True)
+    take_profit_percent = Column(Float, nullable=True)
-    stop_loss_percent = Column(Integer, nullable=True)
+    stop_loss_percent = Column(Float, 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

@@ -86,7 +86,7 @@ async def set_user_api(tg_id: int, api_key: str, api_secret: str) -> bool:
                 else:
                     # Creating new record
                     user_api = UserApi(
-                        user=user, api_key=api_key, api_secret=api_secret
+                        user_id=user.id, api_key=api_key, api_secret=api_secret
                     )
                     session.add(user_api)
 
@@ -141,7 +141,7 @@ async def set_user_symbol(tg_id: int, symbol: str) -> bool:
                     # Creating new record
                     user_symbol = UserSymbol(
                         symbol=symbol,
-                        user=user,
+                        user_id=user.id,
                     )
                     session.add(user_symbol)
 
@@ -197,9 +197,11 @@ async def create_user_additional_settings(tg_id: int) -> None:
 
             # Create the user additional settings
             user_additional_settings = UserAdditionalSettings(
-                user=user,
+                user_id=user.id,
                 trade_mode="Long",  # Default value
                 switch_side="По направлению",
+                side="Buy",
+                trigger_price=0.0,
                 margin_type="ISOLATED_MARGIN",
                 leverage="10",
                 order_quantity=1.0,
@@ -265,7 +267,7 @@ async def set_trade_mode(tg_id: int, trade_mode: str) -> bool:
                     # Creating new record
                     user_additional_settings = UserAdditionalSettings(
                         trade_mode=trade_mode,
-                        user=user,
+                        user_id=user.id,
                     )
                     session.add(user_additional_settings)
 
@@ -304,7 +306,7 @@ async def set_margin_type(tg_id: int, margin_type: str) -> bool:
                     # Creating new record
                     user_additional_settings = UserAdditionalSettings(
                         margin_type=margin_type,
-                        user=user,
+                        user_id=user.id,
                     )
                     session.add(user_additional_settings)
 
@@ -343,7 +345,7 @@ async def set_switch_side(tg_id: int, switch_side: str) -> bool:
                     # Creating new record
                     user_additional_settings = UserAdditionalSettings(
                         switch_side=switch_side,
-                        user=user,
+                        user_id=user.id,
                     )
                     session.add(user_additional_settings)
 
@@ -382,7 +384,7 @@ async def set_side(tg_id: int, side: str) -> bool:
                     # Creating new record
                     user_additional_settings = UserAdditionalSettings(
                         side=side,
-                        user=user,
+                        user_id=user.id,
                     )
                     session.add(user_additional_settings)
 
@@ -421,7 +423,7 @@ async def set_leverage(tg_id: int, leverage: str) -> bool:
                     # Creating new record
                     user_additional_settings = UserAdditionalSettings(
                         leverage=leverage,
-                        user=user,
+                        user_id=user.id,
                     )
                     session.add(user_additional_settings)
 
@@ -460,7 +462,7 @@ async def set_order_quantity(tg_id: int, order_quantity: float) -> bool:
                     # Creating new record
                     user_additional_settings = UserAdditionalSettings(
                         order_quantity=order_quantity,
-                        user=user,
+                        user_id=user.id,
                     )
                     session.add(user_additional_settings)
 
@@ -501,7 +503,7 @@ async def set_martingale_factor(tg_id: int, martingale_factor: float) -> bool:
                     # Creating new record
                     user_additional_settings = UserAdditionalSettings(
                         martingale_factor=martingale_factor,
-                        user=user,
+                        user_id=user.id,
                     )
                     session.add(user_additional_settings)
 
@@ -544,7 +546,7 @@ async def set_max_bets_in_series(tg_id: int, max_bets_in_series: int) -> bool:
                     # Creating new record
                     user_additional_settings = UserAdditionalSettings(
                         max_bets_in_series=max_bets_in_series,
-                        user=user,
+                        user_id=user.id,
                     )
                     session.add(user_additional_settings)
 
@@ -585,7 +587,7 @@ async def set_trigger_price(tg_id: int, trigger_price: float) -> bool:
                     # Creating new record
                     user_additional_settings = UserAdditionalSettings(
                         trigger_price=trigger_price,
-                        user=user,
+                        user_id=user.id,
                     )
                     session.add(user_additional_settings)
 
@@ -625,7 +627,7 @@ async def create_user_risk_management(tg_id: int) -> None:
 
             # Create the user risk management
             user_risk_management = UserRiskManagement(
-                user=user,
+                user_id=user.id,
                 take_profit_percent=1.0,
                 stop_loss_percent=1.0,
                 commission_fee="Yes_commission_fee",
@@ -690,7 +692,7 @@ async def set_take_profit_percent(tg_id: int, take_profit_percent: float) -> boo
                     # Creating new record
                     user_risk_management = UserRiskManagement(
                         take_profit_percent=take_profit_percent,
-                        user=user,
+                        user_id=user.id,
                     )
                     session.add(user_risk_management)
 
@@ -731,7 +733,7 @@ async def set_stop_loss_percent(tg_id: int, stop_loss_percent: float) -> bool:
                     # Creating new record
                     user_risk_management = UserRiskManagement(
                         stop_loss_percent=stop_loss_percent,
-                        user=user,
+                        user_id=user.id,
                     )
                     session.add(user_risk_management)
 
@@ -772,7 +774,7 @@ async def set_commission_fee(tg_id: int, commission_fee: str) -> bool:
                     # Creating new record
                     user_risk_management = UserRiskManagement(
                         commission_fee=commission_fee,
-                        user=user,
+                        user_id=user.id,
                     )
                     session.add(user_risk_management)
 
@@ -813,7 +815,7 @@ async def set_commission_place(tg_id: int, commission_place: str) -> bool:
                     # Creating new record
                     user_risk_management = UserRiskManagement(
                         commission_place=commission_place,
-                        user=user,
+                        user_id=user.id,
                     )
                     session.add(user_risk_management)
 
@@ -853,7 +855,7 @@ async def create_user_conditional_settings(tg_id: int) -> None:
 
             # Create the user conditional settings
             user_conditional_settings = UserConditionalSettings(
-                user=user,
+                user_id=user.id,
                 timer_start=0,
                 timer_end=0,
             )
@@ -918,7 +920,7 @@ async def set_start_timer(tg_id: int, timer_start: int) -> bool:
                     # Creating new record
                     user_conditional_settings = UserConditionalSettings(
                         timer_start=timer_start,
-                        user=user,
+                        user_id=user.id,
                     )
                     session.add(user_conditional_settings)
 
@@ -957,7 +959,7 @@ async def set_stop_timer(tg_id: int, timer_end: int) -> bool:
                     # Creating new record
                     user_conditional_settings = UserConditionalSettings(
                         timer_end=timer_end,
-                        user=user,
+                        user_id=user.id,
                     )
                     session.add(user_conditional_settings)
 
@@ -990,7 +992,8 @@ async def set_user_deal(
         stop_loss_percent: int,
         base_quantity: float,
         commission_fee: str,
-        commission_place: str
+        commission_place: str,
+        pnl_series: float
 ):
     """
     Set the user deal in the database.
@@ -1011,6 +1014,7 @@ async def set_user_deal(
     :param base_quantity: Base quantity
     :param commission_fee: Commission fee
     :param commission_place: Commission place
+    :param pnl_series: PNL series
     :return: bool
     """
     try:
@@ -1043,10 +1047,11 @@ async def set_user_deal(
                 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,
+                    user_id=user.id,
                     symbol=symbol,
                     current_step=current_step,
                     current_series=current_series,
@@ -1062,7 +1067,8 @@ async def set_user_deal(
                     stop_loss_percent=stop_loss_percent,
                     base_quantity=base_quantity,
                     commission_fee=commission_fee,
-                    commission_place=commission_place
+                    commission_place=commission_place,
+                    pnl_series=pnl_series
                 )
                 session.add(new_deal)
 
@@ -1199,6 +1205,63 @@ async def set_current_series(tg_id: int, symbol: str, current_series: int):
         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):

examples/systemd/stcs.service

@@ -8,7 +8,7 @@ After=syslog.target network-online.target
 ExecStart=sudo -u www-data /usr/bin/python3 /var/www/stcs/BybitBot_API.py
 PIDFile=/var/run/python/stcs.pid
 RemainAfterExit=no
-RuntimeMaxSec=3600s
+RuntimeMaxSec=604800s
 Restart=always
 RestartSec=5s
 

run.py

@@ -31,7 +31,6 @@ async def main():
         dp = Dispatcher(storage=storage)
         dp.include_router(router)
         web_socket = WebSocketBot(telegram_bot=bot)
-        await web_socket.clear_user_sockets()
         ws_task = asyncio.create_task(web_socket.run_user_check_loop())
         tg_task = asyncio.create_task(dp.start_polling(bot))