app/bybit/open_positions.py

@@ -75,6 +75,12 @@ async def start_trading_cycle(
             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(
             tg_id=tg_id,
@@ -343,7 +349,6 @@ async def open_positions(
             "triggerBy": "LastPrice",
             "timeInForce": "GTC",
             "positionIdx": 0,
-            "tpslMode": "Full",
         }
 
         response = client.place_order(**order_params)

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="Ошибка при подключении к платформе. Проверьте ключи и повторите попытку.",
                 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,7 +21,7 @@ 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)
@@ -40,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

@@ -16,10 +16,13 @@ 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_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:
@@ -56,6 +59,7 @@ class TelegramMessageHandler:
             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]
@@ -68,6 +72,9 @@ 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
@@ -76,6 +83,7 @@ class TelegramMessageHandler:
                     user_auto_trading.auto_trading if user_auto_trading else False
                 )
 
+                if auto_trading:
                     side_rus = (
                         "Покупка"
                         if side == "Buy"
@@ -99,10 +107,7 @@ class TelegramMessageHandler:
                         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 "Сделка открыта:"
@@ -111,14 +116,9 @@ class TelegramMessageHandler:
                     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"
 
+                    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
@@ -126,9 +126,9 @@ class TelegramMessageHandler:
                     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
+                    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
-                leverage = safe_float(user_deals_data.leverage)
 
                     if commission_fee == "Yes_commission_fee":
                         if commission_place == "Commission_for_qty":
@@ -140,7 +140,7 @@ class TelegramMessageHandler:
                     else:
                         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
                         )
@@ -186,15 +186,12 @@ class TelegramMessageHandler:
                                         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:
+                        if ress or ress == "not modified":
                             take_profit_truncated = await truncate_float(take_profit_price, 6)
                             text += (f"Движение: {side_rus}\n"
                                      f"Тейк-профит: {take_profit_truncated}\n"
@@ -221,30 +218,19 @@ class TelegramMessageHandler:
                             text += (f"Движение: {side_rus}\n"
                                      "Не удалось установить ТП и СЛ\n")
 
-                else:
-                    if auto_trading:
+                    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"
-                    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:
+                    if stop_order_type == "TakeProfit":
                         profit_text = "📈 Начинаю новую серию с базовой ставки\n"
                         await self.telegram_bot.send_message(
                             chat_id=tg_id, text=profit_text, reply_markup=kbi.profile_bybit
@@ -297,7 +283,8 @@ class TelegramMessageHandler:
                                 text=error_text,
                                 reply_markup=kbi.profile_bybit,
                             )
-                    else:
+
+                    elif stop_order_type == "StopLoss" or exec_type == "BustTrade":
                         open_order_text = "\n❗️ Открываю новую сделку с увеличенной ставкой.\n"
                         await self.telegram_bot.send_message(
                             chat_id=tg_id, text=open_order_text
@@ -321,7 +308,7 @@ class TelegramMessageHandler:
                                 "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": "❗️ Превышен максимальный лимит ставки",
+                                "Order placement failed as your position may exceed the max": "❗️ Превышен максимальный лимит ставки с текущим плечом",
                             }
                             error_text = errors.get(
                                 res, "❗️ Не удалось открыть новую сделку"
@@ -341,5 +328,23 @@ 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)
         except Exception as e:
             logger.error("Error in telegram_message_handler: %s", e, exc_info=True)

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

@@ -39,13 +39,13 @@ 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)
 
+            await close_position_by_symbol(
+                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)