Merge pull request 'dev' (#8) from Alex/stcs:dev into stable

Reviewed-on: kodorvan/stcs#8

app/services/Bybit/functions/Futures.py

@@ -1,7 +1,6 @@
 import asyncio
 import logging.config
 import time
-
 import app.services.Bybit.functions.balance as balance_g
 import app.services.Bybit.functions.price_symbol as price_symbol
 import app.telegram.database.requests as rq
@@ -47,11 +46,10 @@ def format_trade_details_position(data, commission_fee):
     Форматирует информацию о сделке в виде строки.
     """
     msg = data.get("data", [{}])[0]
-
     closed_size = safe_float(msg.get("closedSize", 0))
     symbol = msg.get("symbol", "N/A")
     entry_price = safe_float(msg.get("execPrice", 0))
-    qty = safe_float(msg.get("execQty", 0))
+    qty = safe_float(msg.get("orderQty", 0))
     order_type = msg.get("orderType", "N/A")
     side = msg.get("side", "")
     commission = safe_float(msg.get("execFee", 0))
@@ -69,7 +67,7 @@ def format_trade_details_position(data, commission_fee):
         movement = side
 
     if closed_size > 0:
-        return (
+        text = (
             f"Сделка закрыта:\n"
             f"Торговая пара: {symbol}\n"
             f"Цена исполнения: {entry_price:.6f}\n"
@@ -80,8 +78,9 @@ def format_trade_details_position(data, commission_fee):
             f"Комиссия за сделку: {commission:.6f}\n"
             f"Реализованная прибыль: {pnl:.6f} USDT"
         )
+        return text
     if order_type == "Market":
-        return (
+        text = (
             f"Сделка открыта:\n"
             f"Торговая пара: {symbol}\n"
             f"Цена исполнения: {entry_price:.6f}\n"
@@ -90,6 +89,7 @@ def format_trade_details_position(data, commission_fee):
             f"Движение: {movement}\n"
             f"Комиссия за сделку: {commission:.6f}"
         )
+        return text
     return None
 
 
@@ -102,12 +102,11 @@ def format_order_details_position(data):
     qty = safe_float(msg.get("qty", 0))
     cum_exec_qty = safe_float(msg.get("cumExecQty", 0))
     cum_exec_fee = safe_float(msg.get("cumExecFee", 0))
-    take_profit = safe_float(msg.get("takeProfit", 0))
-    stop_loss = safe_float(msg.get("stopLoss", 0))
     order_status = msg.get("orderStatus", "N/A")
     symbol = msg.get("symbol", "N/A")
     order_type = msg.get("orderType", "N/A")
     side = msg.get("side", "")
+    trigger_price = msg.get("triggerPrice", "N/A")
 
     movement = ""
     if side.lower() == "buy":
@@ -126,8 +125,6 @@ def format_order_details_position(data):
             f"Исполнено позиций: {cum_exec_qty}\n"
             f"Тип ордера: {order_type}\n"
             f"Движение: {movement}\n"
-            f"Тейк-профит: {take_profit:.6f}\n"
-            f"Стоп-лосс: {stop_loss:.6f}\n"
             f"Комиссия за сделку: {cum_exec_fee:.6f}\n"
         )
         return text
@@ -140,8 +137,6 @@ def format_order_details_position(data):
             f"Количество: {qty}\n"
             f"Тип ордера: {order_type}\n"
             f"Движение: {movement}\n"
-            f"Тейк-профит: {take_profit:.6f}\n"
-            f"Стоп-лосс: {stop_loss:.6f}\n"
         )
         return text
 
@@ -153,8 +148,28 @@ def format_order_details_position(data):
             f"Количество: {qty}\n"
             f"Тип ордера: {order_type}\n"
             f"Движение: {movement}\n"
-            f"Тейк-профит: {take_profit:.6f}\n"
-            f"Стоп-лосс: {stop_loss:.6f}\n"
+        )
+        return text
+    elif order_status.lower() == "untriggered":
+        text = (
+            f"Условный ордер создан:\n"
+            f"Торговая пара: {symbol}\n"
+            f"Цена: {price:.6f}\n"
+            f"Триггер цена: {trigger_price}\n"
+            f"Количество: {qty}\n"
+            f"Тип ордера: {order_type}\n"
+            f"Движение: {movement}\n"
+        )
+        return text
+    elif order_status.lower() == "deactivated":
+        text = (
+            f"Условный ордер отменен:\n"
+            f"Торговая пара: {symbol}\n"
+            f"Цена: {price:.6f}\n"
+            f"Триггер цена: {trigger_price}\n"
+            f"Количество: {qty}\n"
+            f"Тип ордера: {order_type}\n"
+            f"Движение: {movement}\n"
         )
         return text
     return None
@@ -172,7 +187,7 @@ def parse_pnl_from_msg(msg) -> float:
         return 0.0
 
 
-async def calculate_total_budget(starting_quantity, martingale_factor, max_steps, commission_fee_percent, leverage, current_price):
+async def calculate_total_budget(starting_quantity, martingale_factor, max_steps, commission_fee_percent):
     """
     Вычисляет общий бюджет серии ставок с учётом цены пары, комиссии и кредитного плеча.
 
@@ -189,22 +204,16 @@ async def calculate_total_budget(starting_quantity, martingale_factor, max_steps
     """
     total = 0
     for step in range(max_steps):
-        quantity = starting_quantity * (martingale_factor ** step)  # размер ставки на текущем шаге в USDT
+        base_quantity = starting_quantity * (martingale_factor ** step)
+        if commission_fee_percent == 0:
+            # Комиссия уже включена в сумму ставки, поэтому реальный размер позиции меньше
+            quantity = base_quantity / (1 + commission_fee_percent)
+        else:
+            # Комиссию добавляем сверху
+            quantity = base_quantity * (1 + commission_fee_percent)
 
-        # Переводим ставку из USDT в количество актива по текущей цене
-        quantity_in_asset = quantity / current_price
-
-        # Учитываем комиссию за вход и выход (умножаем на 2)
-        quantity_with_fee = quantity * (1 + 2 * commission_fee_percent / 100)
-
-        # Учитываем кредитное плечо - реальные собственные вложения меньше
-        effective_quantity = quantity_with_fee / leverage
-
-        total += effective_quantity
-
-    # Возвращаем бюджет в USDT
-    total_usdt = total * current_price
-    return total_usdt
+        total += quantity
+    return total
 
 
 async def handle_execution_message(message, msg):
@@ -212,7 +221,6 @@ async def handle_execution_message(message, msg):
     Обработчик сообщений об исполнении сделки.
     Логирует событие и проверяет условия для мартингейла и TP.
     """
-
     tg_id = message.from_user.id
     data = msg.get("data", [{}])[0]
     data_main_risk_stgs = await rq.get_user_risk_management_settings(tg_id)
@@ -239,6 +247,9 @@ async def handle_execution_message(message, msg):
     if trade_info:
         await message.answer(f"{trade_info}", reply_markup=inline_markup.back_to_main)
 
+    if data is not None:
+        await rq.update_trigger_price(tg_id, 0.0)
+
     if closed_size == 0:
         side = data.get("side", "")
 
@@ -248,12 +259,12 @@ async def handle_execution_message(message, msg):
             await rq.set_last_series_info(tg_id, last_side="Sell")
 
     if trigger == "Автоматический" and closed_size > 0:
-        if pnl < 0:
+        if trading_mode == 'Switch':
+            side = data_main_stgs.get("last_side")
+        else:
+            side = "Buy" if trading_mode == "Long" else "Sell"
 
-            if trading_mode == 'Switch':
-                side = data_main_stgs.get("last_side")
-            else:
-                side = "Buy" if trading_mode == "Long" else "Sell"
+        if pnl < 0:
 
             current_martingale = await rq.get_martingale_step(tg_id)
             current_martingale_step = int(current_martingale)
@@ -262,6 +273,7 @@ async def handle_execution_message(message, msg):
                     float(martingale_factor) ** current_martingale_step
             )
             await rq.update_martingale_step(tg_id, current_martingale)
+            await rq.update_starting_quantity(tg_id=tg_id, num=next_quantity)
             await message.answer(
                 f"❗️ Сделка закрылась в минус, открываю новую сделку с увеличенной ставкой.\n"
             )
@@ -275,9 +287,12 @@ async def handle_execution_message(message, msg):
             )
 
         elif pnl > 0:
-            await rq.update_martingale_step(tg_id, 0)
+            await rq.update_martingale_step(tg_id, 1)
+            num = data_main_stgs.get("base_quantity")
+            await rq.update_starting_quantity(tg_id=tg_id, num=num)
             await message.answer(
-                "❗️ Прибыль достигнута, шаг мартингейла сброшен."
+                "❗️ Прибыль достигнута, шаг мартингейла сброшен. "
+                "Возврат к начальной ставке."
             )
 
 
@@ -287,7 +302,10 @@ async def handle_order_message(message, msg: dict) -> None:
     Логирует событие и проверяет условия для мартингейла и TP.
     """
     # logger.info(f"Исполнен ордер:\n{json.dumps(msg, indent=4, ensure_ascii=False)}")
-
+    data = msg.get("data", [{}])[0]
+    tg_id = message.from_user.id
+    if data is not None:
+        await rq.update_trigger_price(tg_id, 0.0)
     trade_info = format_order_details_position(msg)
 
     if trade_info:
@@ -333,7 +351,7 @@ async def open_position(
         bybit_margin_mode = (
             "ISOLATED_MARGIN" if margin_mode == "Isolated" else "REGULAR_MARGIN"
         )
-
+        trigger_price = await rq.get_trigger_price(tg_id)
         limit_price = None
         if order_type == "Limit":
             limit_price = await rq.get_limit_price(tg_id)
@@ -348,8 +366,6 @@ async def open_position(
         max_risk_percent = safe_float(data_risk_stgs.get("max_risk_deal"))
         loss_profit = safe_float(data_risk_stgs.get("price_loss"))
         commission_fee = data_risk_stgs.get("commission_fee")
-        starting_quantity = safe_float(data_main_stgs.get('starting_quantity'))
-        martingale_factor = safe_float(data_main_stgs.get('martingale_factor'))
         fee_info = client.get_fee_rates(category='linear', symbol=symbol)
         instruments_resp = client.get_instruments_info(category="linear", symbol=symbol)
         instrument = instruments_resp.get("result", {}).get("list", [])
@@ -359,33 +375,19 @@ async def open_position(
         else:
             commission_fee_percent = 0.0
 
-        total_budget = await calculate_total_budget(
-            starting_quantity=starting_quantity,
-            martingale_factor=martingale_factor,
-            max_steps=max_martingale_steps,
-            commission_fee_percent=commission_fee_percent,
-            leverage=leverage,
-            current_price=entry_price,
-        )
+        if commission_fee_percent > 0:
+            # Добавляем к тейк-профиту процент комиссии
+            tp_multiplier = 1 + (loss_profit / 100) + commission_fee_percent
+        else:
+            tp_multiplier = 1 + (loss_profit / 100)
 
-        balance = await balance_g.get_balance(tg_id, message)
-        if safe_float(balance) < total_budget:
-            logger.error(
-                f"Недостаточно средств для серии из {max_martingale_steps} шагов с текущими параметрами. "
-                f"Требуемый бюджет: {total_budget:.2f} USDT, доступно: {balance} USDT."
-            )
-            await message.answer(
-                f"Недостаточно средств для серии из {max_martingale_steps} шагов с текущими параметрами. "
-                f"Требуемый бюджет: {total_budget:.2f} USDT, доступно: {balance} USDT.",
-                reply_markup=inline_markup.back_to_main,
-            )
-            return
 
         if order_type == "Limit" and limit_price:
             price_for_calc = limit_price
         else:
             price_for_calc = entry_price
 
+        balance = await balance_g.get_balance(tg_id, message)
         potential_loss = safe_float(quantity) * price_for_calc * (loss_profit / 100)
         adjusted_loss = potential_loss / leverage
         allowed_loss = safe_float(balance) * (max_risk_percent / 100)
@@ -423,7 +425,7 @@ async def open_position(
             logger.info(f"Set leverage to {leverage_to_set} for {symbol}")
         except exceptions.InvalidRequestError as e:
             if "110043" in str(e):
-                logger.info(f"Leverage already set to {leverage} for {symbol}")
+                logger.info(f"Leverage already set to {leverage_to_set} for {symbol}")
             else:
                 raise e
 
@@ -453,18 +455,35 @@ async def open_position(
 
         if bybit_margin_mode == "ISOLATED_MARGIN":
             # Открываем позицию
-            response = client.place_order(
-                category="linear",
-                symbol=symbol,
-                side=side,
-                orderType=order_type,
-                qty=str(quantity),
-                price=(
-                    str(limit_price) if order_type == "Limit" and limit_price else None
-                ),
-                timeInForce="GTC",
-                orderLinkId=f"deal_{symbol}_{int(time.time())}",
-            )
+            if trigger_price and float(trigger_price) > 0:
+                response = client.place_order(
+                    category="linear",
+                    symbol=symbol,
+                    side=side,
+                    orderType="Stop" if order_type == "Conditional" else order_type,
+                    qty=str(quantity),
+                    price=(str(limit_price) if order_type == "Limit" and limit_price else None),
+                    triggerPrice=str(trigger_price),
+                    triggerBy="LastPrice",
+                    triggerDirection=2 if side == "Buy" else 1,
+                    timeInForce="GTC",
+                    orderLinkId=f"deal_{symbol}_{int(time.time())}",
+                )
+            else:
+                # Обычный ордер, без триггера
+                response = client.place_order(
+                    category="linear",
+                    symbol=symbol,
+                    side=side,
+                    orderType=order_type,
+                    qty=str(quantity),
+                    price=(str(limit_price) if order_type == "Limit" and limit_price else None),
+                    timeInForce="GTC",
+                    orderLinkId=f"deal_{symbol}_{int(time.time())}",
+                )
+
+            if response.get("retCode", -1) == 0:
+                return True
             if response.get("retCode", -1) != 0:
                 logger.error(f"Ошибка открытия ордера: {response}")
                 await message.answer(
@@ -480,9 +499,11 @@ async def open_position(
 
             if liq_price > 0 and avg_price > 0:
                 if side.lower() == "buy":
-                    take_profit_price = avg_price + (avg_price - liq_price)
+                    base_tp = avg_price + (avg_price - liq_price)
+                    take_profit_price = base_tp * (1 + commission_fee_percent)
                 else:
-                    take_profit_price = avg_price - (liq_price - avg_price)
+                    base_tp = avg_price - (liq_price - avg_price)
+                    take_profit_price = base_tp * (1 - commission_fee_percent)
 
                 take_profit_price = max(take_profit_price, 0)
 
@@ -496,7 +517,7 @@ async def open_position(
                             logger.info("Режим TP/SL уже установлен - пропускаем")
                         else:
                             raise
-                    resp = client.set_trading_stop(
+                    client.set_trading_stop(
                         category="linear",
                         symbol=symbol,
                         takeProfit=str(round(take_profit_price, 5)),
@@ -531,10 +552,10 @@ async def open_position(
                 base_price = limit_price
 
             if side.lower() == "buy":
-                take_profit_price = base_price * (1 + loss_profit / 100)
+                take_profit_price = base_price * tp_multiplier
                 stop_loss_price = base_price * (1 - loss_profit / 100)
             else:
-                take_profit_price = base_price * (1 - loss_profit / 100)
+                take_profit_price = base_price * (1 - (loss_profit / 100) - (commission_fee_percent))
                 stop_loss_price = base_price * (1 + loss_profit / 100)
 
             take_profit_price = max(take_profit_price, 0)
@@ -567,6 +588,9 @@ async def open_position(
                 slOrderType=sl_order_type,
                 slLimitPrice=str(sl_limit_price) if sl_limit_price else None,
                 tpslMode=tpsl_mode,
+                triggerPrice=str(trigger_price) if trigger_price and float(trigger_price) > 0 else None,
+                triggerBy="LastPrice" if trigger_price and float(trigger_price) > 0 else None,
+                triggerDirection=2 if side == "Buy" else 1 if trigger_price and float(trigger_price) > 0 else None,
                 timeInForce="GTC",
                 orderLinkId=f"deal_{symbol}_{int(time.time())}",
             )
@@ -747,20 +771,20 @@ async def get_active_orders(tg_id, message):
     """
     client = await get_bybit_client(tg_id)
     response = client.get_open_orders(
-        category="linear", settleCoin="USDT", orderType="Limit"
+        category="linear", settleCoin="USDT", orderType="Limit" and "Market"
     )
     orders = response.get("result", {}).get("list", [])
-    limit_orders = [order for order in orders if order.get("orderType") == "Limit"]
+    limit_orders = [order for order in orders]
 
     if limit_orders:
         symbols = [order["symbol"] for order in limit_orders]
         await message.answer(
-            "📈 Ваши активные лимитные ордера:",
+            "📈 Ваши активные ордера:",
             reply_markup=inline_markup.create_trades_inline_keyboard_limits(symbols),
         )
     else:
         await message.answer(
-            "❗️ У вас нет активных лимитных ордеров.",
+            "❗️ У вас нет активных ордеров.",
             reply_markup=inline_markup.back_to_main,
         )
         return
@@ -775,12 +799,11 @@ async def get_active_orders_by_symbol(tg_id, symbol, message):
     limit_orders = [
         order
         for order in active_orders.get("result", {}).get("list", [])
-        if order.get("orderType") == "Limit"
     ]
 
     if not limit_orders:
         await message.answer(
-            "Нет активных лимитных ордеров по данной торговой паре.",
+            "Нет активных ордеров по данной торговой паре.",
             reply_markup=inline_markup.back_to_main,
         )
         return
@@ -792,9 +815,8 @@ async def get_active_orders_by_symbol(tg_id, symbol, message):
             f"Тип ордера: {order.get('orderType')}\n"
             f"Сторона: {order.get('side')}\n"
             f"Цена: {order.get('price')}\n"
+            f"Триггер цена: {order.get('triggerPrice')}\n"
             f"Количество: {order.get('qty')}\n"
-            f"Тейк-профит: {order.get('takeProfit')}\n"
-            f"Стоп-лосс: {order.get('stopLoss')}\n"
         )
         texts.append(text)
 

app/services/Bybit/functions/bybit_ws.py

@@ -71,7 +71,7 @@ def on_order_callback(message, msg):
     if event_loop is not None:
         from app.services.Bybit.functions.Futures import handle_order_message
         asyncio.run_coroutine_threadsafe(handle_order_message(message, msg), event_loop)
-        logger.info("Callback выполнен.")
+        logger.info("Callback для ордера выполнен.")
     else:
         logger.error("Event loop не установлен, callback пропущен.")
 
@@ -80,7 +80,7 @@ def on_execution_callback(message, ws_msg):
     if event_loop is not None:
         from app.services.Bybit.functions.Futures import handle_execution_message
         asyncio.run_coroutine_threadsafe(handle_execution_message(message, ws_msg), event_loop)
-        logger.info("Callback выполнен.")
+        logger.info("Callback для маркета выполнен.")
     else:
         logger.error("Event loop не установлен, callback пропущен.")
 

app/services/Bybit/functions/functions.py

@@ -17,8 +17,9 @@ import app.telegram.Keyboards.inline_keyboards as inline_markup
 import app.telegram.database.requests as rq
 from aiogram.types import Message, CallbackQuery
 from app.services.Bybit.functions.price_symbol import get_price
+# import app.services.Bybit.functions.balance as balance_g
 
-from app.states.States import (state_update_entry_type, state_update_symbol, state_limit_price,
+from app.states.States import (state_update_symbol,
                                SetTP_SL_State, CloseTradeTimerState)
 from aiogram.fsm.context import FSMContext
 
@@ -119,72 +120,6 @@ async def update_symbol_for_trade(message: Message, state: FSMContext) -> None:
     await state.clear()
 
 
-@router_functions_bybit_trade.callback_query(F.data == 'clb_update_entry_type')
-async def update_entry_type_message(callback: CallbackQuery, state: FSMContext) -> None:
-    """
-    Запрашивает у пользователя тип входа в позицию (Market или Limit).
-    """
-    await state.set_state(state_update_entry_type.entry_type)
-    await callback.message.answer("Выберите тип входа в позицию:", reply_markup=inline_markup.entry_order_type_markup)
-    await callback.answer()
-
-
-@router_functions_bybit_trade.callback_query(lambda c: c.data and c.data.startswith('entry_order_type:'))
-async def entry_order_type_callback(callback: CallbackQuery, state: FSMContext) -> None:
-    """
-    Обработка выбора типа входа в позицию.
-    Если Limit, запрашивает цену лимитного ордера.
-    Если Market — обновляет настройки.
-    """
-    order_type = callback.data.split(':')[1]
-
-    if order_type not in ['Market', 'Limit']:
-        await callback.answer("Ошибка выбора", show_alert=True)
-        return
-
-    if order_type == 'Limit':
-        await state.set_state(state_limit_price.price)
-        await callback.message.answer("Введите цену лимитного ордера:", reply_markup=inline_markup.cancel)
-        await callback.answer()
-        return
-
-    try:
-        await state.update_data(entry_order_type=order_type)
-        await rq.update_entry_order_type(callback.from_user.id, order_type)
-        await callback.message.answer(f"Выбран тип входа в позицию: {order_type}",
-                                      reply_markup=inline_markup.start_trading_markup)
-        await callback.answer()
-    except Exception as e:
-        logger.error("Произошла ошибка при обновлении типа входа в позицию: %s", e)
-        await callback.message.answer("Произошла ошибка при обновлении типа входа в позицию",
-                                      reply_markup=inline_markup.back_to_main)
-    await state.clear()
-
-
-@router_functions_bybit_trade.message(state_limit_price.price)
-async def set_limit_price(message: Message, state: FSMContext) -> None:
-    """
-    Обрабатывает ввод цены лимитного ордера, проверяет формат и сохраняет настройки.
-    """
-    try:
-        price = float(message.text)
-        if price <= 0:
-            await message.answer("Цена должна быть положительным числом. Попробуйте снова.",
-                                 reply_markup=inline_markup.cancel)
-            return
-    except ValueError:
-        await message.answer("Некорректный формат цены. Введите число.", reply_markup=inline_markup.cancel)
-        return
-
-    await state.update_data(entry_order_type='Limit', limit_price=price)
-
-    await rq.update_entry_order_type(message.from_user.id, 'Limit')
-    await rq.update_limit_price(message.from_user.id, price)
-
-    await message.answer(f"Цена лимитного ордера установлена: {price}", reply_markup=inline_markup.start_trading_markup)
-    await state.clear()
-
-
 @router_functions_bybit_trade.callback_query(F.data == "clb_start_chatbot_trading")
 async def start_trading_process(callback: CallbackQuery) -> None:
     """
@@ -196,11 +131,18 @@ async def start_trading_process(callback: CallbackQuery) -> None:
     tg_id = callback.from_user.id
     message = callback.message
     data_main_stgs = await rq.get_user_main_settings(tg_id)
+    # data_risk_stgs = await rq.get_user_risk_management_settings(tg_id)
+    # client = await get_bybit_client(tg_id)
     symbol = await rq.get_symbol(tg_id)
     margin_mode = data_main_stgs.get('margin_type', 'Isolated')
     trading_mode = data_main_stgs.get('trading_mode')
     starting_quantity = safe_float(data_main_stgs.get('starting_quantity'))
     switch_state = data_main_stgs.get("switch_state", "По направлению")
+    # martingale_factor = safe_float(data_main_stgs.get('martingale_factor'))
+    # max_martingale_steps = int(data_main_stgs.get("maximal_quantity", 0))
+    # commission_fee = data_risk_stgs.get("commission_fee")
+    # fee_info = client.get_fee_rates(category='linear', symbol=symbol)
+
 
     if trading_mode == 'Switch':
         if switch_state == "По направлению":
@@ -221,7 +163,33 @@ async def start_trading_process(callback: CallbackQuery) -> None:
                                  reply_markup=inline_markup.back_to_main)
             return
 
+    # if commission_fee == "Да":
+    #     commission_fee_percent = safe_float(fee_info['result']['list'][0]['takerFeeRate'])
+    # else:
+    #     commission_fee_percent = 0.0
+
+    # total_budget = await calculate_total_budget(
+    #     starting_quantity=starting_quantity,
+    #     martingale_factor=martingale_factor,
+    #     max_steps=max_martingale_steps,
+    #     commission_fee_percent=commission_fee_percent,
+    # )
+
+    # balance = await balance_g.get_balance(tg_id, message)
+    # if safe_float(balance) < total_budget:
+    #     logger.error(
+    #         f"Недостаточно средств для серии из {max_martingale_steps} шагов с текущими параметрами. "
+    #         f"Требуемый бюджет: {total_budget:.2f} USDT, доступно: {balance} USDT."
+    #     )
+    #     await message.answer(
+    #         f"Недостаточно средств для серии из {max_martingale_steps} шагов с текущими параметрами. "
+    #         f"Требуемый бюджет: {total_budget:.2f} USDT, доступно: {balance} USDT.",
+    #         reply_markup=inline_markup.back_to_main,
+    #     )
+    #     return
+
     await message.answer("Начинаю торговлю с использованием текущих настроек...")
+    await rq.update_trigger(tg_id=tg_id, trigger="Автоматический")
 
     timer_data = await rq.get_user_timer(tg_id)
     if isinstance(timer_data, dict):
@@ -259,6 +227,7 @@ async def cancel_start_trading(callback: CallbackQuery):
             pass
         user_trade_tasks.pop(tg_id, None)
         await rq.update_user_timer(tg_id, minutes=0)
+        await rq.update_trigger(tg_id, "Ручной")
         await callback.message.answer("Запуск торговли отменён.", reply_markup=inline_markup.back_to_main)
         await callback.message.edit_reply_markup(reply_markup=None)
     else:
@@ -505,9 +474,13 @@ async def stop_immediately(callback: CallbackQuery):
     Останавливает торговлю немедленно.
     """
     tg_id = callback.from_user.id
+    symbol = await rq.get_symbol(tg_id)
 
+    await close_user_trade(tg_id, symbol)
     await rq.update_trigger(tg_id, "Ручной")
-    await callback.message.answer("Автоматическая торговля остановлена.", reply_markup=inline_markup.back_to_main)
+    await rq.update_martingale_step(tg_id, 1)
+
+    await callback.message.answer("Торговля остановлена.", reply_markup=inline_markup.back_to_main)
     await callback.answer()
 
 
@@ -543,8 +516,13 @@ async def process_stop_delay(message: Message, state: FSMContext):
     await message.answer(f"Торговля будет остановлена через {delay_minutes} минут.",
                          reply_markup=inline_markup.back_to_main)
     await asyncio.sleep(delay_seconds)
+
+    symbol = await rq.get_symbol(tg_id)
+
+    await close_user_trade(tg_id, symbol)
     await rq.update_trigger(tg_id, "Ручной")
-    await message.answer("Автоматическая торговля остановлена.", reply_markup=inline_markup.back_to_main)
+    await rq.update_martingale_step(tg_id, 1)
+    await message.answer("Торговля остановлена.", reply_markup=inline_markup.back_to_main)
 
     await state.clear()
 
@@ -559,4 +537,4 @@ async def cancel(callback: CallbackQuery, state: FSMContext) -> None:
         await callback.message.answer("Отменено!", reply_markup=inline_markup.back_to_main)
         await callback.answer()
     except Exception as e:
-        logger.error("Ошибка при обработке отмены: %s", e)
+        logger.error("Ошибка при обработке отмены: %s", e)

app/states/States.py

@@ -21,6 +21,9 @@ class state_limit_price(StatesGroup):
     """FSM состояние для установки лимита."""
     price = State()
 
+class state_trigger_price(StatesGroup):
+    """FSM состояние для установки лимита."""
+    price = State()
 
 class CloseTradeTimerState(StatesGroup):
     """FSM состояние ожидания задержки перед закрытием сделки."""

app/telegram/Keyboards/inline_keyboards.py

@@ -30,13 +30,11 @@ special_settings_markup = InlineKeyboardMarkup(inline_keyboard=[
      InlineKeyboardButton(text="Риск-менеджмент", callback_data='clb_change_risk_management_settings')],
 
     [InlineKeyboardButton(text="Условия запуска", callback_data='clb_change_condition_settings')],
-     # InlineKeyboardButton(text="Дополнительные параметры", callback_data='clb_change_additional_settings')],
+    # InlineKeyboardButton(text="Дополнительные параметры", callback_data='clb_change_additional_settings')],
     [InlineKeyboardButton(text="Подключить Bybit", callback_data='clb_new_user_connect_bybit_api_message')],
     back_btn_to_main
 ])
 
-
-
 connect_bybit_api_markup = InlineKeyboardMarkup(inline_keyboard=[
     [InlineKeyboardButton(text="Подключить Bybit", callback_data='clb_new_user_connect_bybit_api')]
 ])
@@ -45,7 +43,7 @@ trading_markup = InlineKeyboardMarkup(inline_keyboard=[
     [InlineKeyboardButton(text="Настройки", callback_data='clb_settings_message')],
     [InlineKeyboardButton(text="Мои сделки", callback_data='clb_my_deals')],
     [InlineKeyboardButton(text="Указать торговую пару", callback_data='clb_update_trading_pair')],
-    [InlineKeyboardButton(text="Начать торговать", callback_data='clb_update_entry_type')],
+    [InlineKeyboardButton(text="Начать торговать", callback_data='clb_start_chatbot_trading')],
     [InlineKeyboardButton(text="Остановить торговлю", callback_data='clb_stop_trading')],
 ])
 
@@ -61,14 +59,12 @@ cancel = InlineKeyboardMarkup(inline_keyboard=[
 entry_order_type_markup = InlineKeyboardMarkup(
     inline_keyboard=[
         [
-            InlineKeyboardButton(text="Market (текущая цена)", callback_data="entry_order_type:Market"),
-            InlineKeyboardButton(text="Limit (фиксированная цена)", callback_data="entry_order_type:Limit"),
+            InlineKeyboardButton(text="Маркет", callback_data="entry_order_type:Market"),
+            InlineKeyboardButton(text="Лимит", callback_data="entry_order_type:Limit"),
         ], back_btn_to_main
     ]
 )
 
-
-
 back_to_main = InlineKeyboardMarkup(inline_keyboard=[
     [InlineKeyboardButton(text="На главную", callback_data='back_to_main')],
 ])
@@ -79,11 +75,11 @@ main_settings_markup = InlineKeyboardMarkup(inline_keyboard=[
      InlineKeyboardButton(text='Тип маржи', callback_data='clb_change_margin_type')],
 
     [InlineKeyboardButton(text='Размер кредитного плеча', callback_data='clb_change_size_leverage'),
-     InlineKeyboardButton(text='Начальная ставка', callback_data='clb_change_starting_quantity')],
+     InlineKeyboardButton(text='Ставка', callback_data='clb_change_starting_quantity')],
 
     [InlineKeyboardButton(text='Коэффициент Мартингейла', callback_data='clb_change_martingale_factor'),
      InlineKeyboardButton(text='Сбросить шаги Мартингейла', callback_data='clb_change_martingale_reset')],
-     [InlineKeyboardButton(text='Максимальное кол-во ставок', callback_data='clb_change_maximum_quantity')],
+    [InlineKeyboardButton(text='Максимальное кол-во ставок', callback_data='clb_change_maximum_quantity')],
 
     back_btn_list_settings,
     back_btn_to_main
@@ -101,8 +97,10 @@ risk_management_settings_markup = InlineKeyboardMarkup(inline_keyboard=[
 ])
 
 condition_settings_markup = InlineKeyboardMarkup(inline_keyboard=[
-    [InlineKeyboardButton(text='Режим торговли', callback_data='clb_change_mode'),
-     InlineKeyboardButton(text='Таймер', callback_data='clb_change_timer')],
+    [InlineKeyboardButton(text='Таймер', callback_data='clb_change_timer'),
+     InlineKeyboardButton(text='Тип позиции', callback_data='clb_update_entry_type')],
+    [InlineKeyboardButton(text='Триггер цена', callback_data='clb_change_trigger_price'),
+     InlineKeyboardButton(text='Лимит цена', callback_data='clb_change_limit_price')],
     #
     # [InlineKeyboardButton(text='Фильтр волатильности', callback_data='clb_change_filter_volatility'),
     #  InlineKeyboardButton(text='Внешние сигналы', callback_data='clb_change_external_cues')],
@@ -116,6 +114,11 @@ condition_settings_markup = InlineKeyboardMarkup(inline_keyboard=[
     back_btn_to_main
 ])
 
+back_to_condition_settings = InlineKeyboardMarkup(inline_keyboard=[
+    [InlineKeyboardButton(text='Назад', callback_data='clb_change_condition_settings')],
+    back_btn_to_main
+])
+
 additional_settings_markup = InlineKeyboardMarkup(inline_keyboard=[
     [InlineKeyboardButton(text='Сохранить шаблон', callback_data='clb_change_save_pattern'),
      InlineKeyboardButton(text='Автозапуск', callback_data='clb_change_auto_start')],
@@ -130,7 +133,7 @@ trading_mode_markup = InlineKeyboardMarkup(inline_keyboard=[
     [InlineKeyboardButton(text="Лонг", callback_data="trade_mode_long"),
      InlineKeyboardButton(text="Шорт", callback_data="trade_mode_short"),
      InlineKeyboardButton(text="Свитч", callback_data="trade_mode_switch")],
-     # InlineKeyboardButton(text="Смарт", callback_data="trade_mode_smart")],
+    # InlineKeyboardButton(text="Смарт", callback_data="trade_mode_smart")],
 
     back_btn_list_settings,
     back_btn_to_main
@@ -145,7 +148,7 @@ margin_type_markup = InlineKeyboardMarkup(inline_keyboard=[
 
 trigger_markup = InlineKeyboardMarkup(inline_keyboard=[  # ИЗМЕНИТЬ НА INLINE
     [InlineKeyboardButton(text='Ручной', callback_data="clb_trigger_manual")],
-     # [InlineKeyboardButton(text='TradingView', callback_data="clb_trigger_tradingview")],
+    # [InlineKeyboardButton(text='TradingView', callback_data="clb_trigger_tradingview")],
     [InlineKeyboardButton(text="Автоматический", callback_data="clb_trigger_auto")],
     back_btn_list_settings,
     back_btn_to_main
@@ -162,11 +165,12 @@ buttons_on_off_markup = InlineKeyboardMarkup(inline_keyboard=[  # ИЗМЕНИТ
 ])
 
 my_deals_select_markup = InlineKeyboardMarkup(inline_keyboard=[
-    [InlineKeyboardButton(text='Открытые сделки', callback_data="clb_open_deals"),
-     InlineKeyboardButton(text='Лимитные ордера', callback_data="clb_open_orders")],
+    [InlineKeyboardButton(text='Позиции', callback_data="clb_open_deals"),
+     InlineKeyboardButton(text='Ордера', callback_data="clb_open_orders")],
     back_btn_to_main
 ])
 
+
 def create_trades_inline_keyboard(trades):
     builder = InlineKeyboardBuilder()
     for trade in trades:
@@ -174,6 +178,7 @@ def create_trades_inline_keyboard(trades):
     builder.adjust(2)
     return builder.as_markup()
 
+
 def create_trades_inline_keyboard_limits(trades):
     builder = InlineKeyboardBuilder()
     for trade in trades:
@@ -190,12 +195,14 @@ def create_close_deal_markup(symbol: str) -> InlineKeyboardMarkup:
         back_btn_to_main
     ])
 
+
 def create_close_limit_markup(symbol: str) -> InlineKeyboardMarkup:
     return InlineKeyboardMarkup(inline_keyboard=[
-        [InlineKeyboardButton(text="Закрыть лимитный ордер", callback_data=f"close_limit:{symbol}")],
+        [InlineKeyboardButton(text="Закрыть ордер", callback_data=f"close_limit:{symbol}")],
         back_btn_to_main
     ])
 
+
 timer_markup = InlineKeyboardMarkup(inline_keyboard=[
     [InlineKeyboardButton(text="Установить таймер", callback_data="clb_set_timer")],
     [InlineKeyboardButton(text="Удалить таймер", callback_data="clb_delete_timer")],
@@ -214,4 +221,4 @@ stop_choice_markup = InlineKeyboardMarkup(
 switch_state_markup = InlineKeyboardMarkup(inline_keyboard=[
     [InlineKeyboardButton(text='По направлению', callback_data="clb_long_switch"),
      InlineKeyboardButton(text='Против направления', callback_data="clb_short_switch")],
-])
+])

app/telegram/database/models.py

@@ -11,7 +11,7 @@ from sqlalchemy import select, insert
 logging.config.dictConfig(LOGGING_CONFIG)
 logger = logging.getLogger("models")
 
-engine = create_async_engine(url='sqlite+aiosqlite:///db.sqlite3')
+engine = create_async_engine(url='sqlite+aiosqlite:///data/db.sqlite3')
 
 async_session = async_sessionmaker(engine)
 
@@ -148,12 +148,15 @@ class User_Main_Settings(Base):
     switch_state = mapped_column(String(10), default='По направлению')
     size_leverage = mapped_column(Integer(), default=1)
     starting_quantity = mapped_column(Integer(), default=1)
+    base_quantity = mapped_column(Integer(), default=1)
     martingale_factor = mapped_column(Integer(), default=1)
     martingale_step = mapped_column(Integer(), default=1)
     maximal_quantity = mapped_column(Integer(), default=10)
     entry_order_type = mapped_column(String(10), default='Market')
-    limit_order_price = mapped_column(Numeric(18, 15), nullable=True)
+    limit_order_price = mapped_column(Numeric(18, 15), nullable=True, default=0)
+    trigger_price = mapped_column(Numeric(18, 15), nullable=True, default=0)
     last_side = mapped_column(String(10), default='Buy')
+    trading_start_stop = mapped_column(Integer(), default=0)
 
 
 class User_Risk_Management_Settings(Base):
@@ -304,3 +307,10 @@ async def async_main():
             if not result.first():
                 logger.info("Заполение таблицы последнего направления")
                 await conn.execute(User_Main_Settings.__table__.insert().values(last_side=side))
+
+        order_type = ['Limit', 'Market']
+        for typ in order_type:
+            result = await conn.execute(select(User_Main_Settings).where(User_Main_Settings.entry_order_type == typ))
+            if not result.first():
+                logger.info("Заполение таблицы типов ордеров")
+                await conn.execute(User_Main_Settings.__table__.insert().values(entry_order_type=typ))

app/telegram/database/requests.py

@@ -318,8 +318,11 @@ async def get_user_main_settings(tg_id):
                 'maximal_quantity': user.maximal_quantity,
                 'entry_order_type': user.entry_order_type,
                 'limit_order_price': user.limit_order_price,
+                'trigger_price': user.trigger_price,
                 'martingale_step': user.martingale_step,
                 'last_side': user.last_side,
+                'trading_start_stop': user.trading_start_stop,
+                'base_quantity': user.base_quantity,
             }
             return data
 
@@ -368,15 +371,23 @@ async def update_size_leverange(tg_id, num):
 
 
 async def update_starting_quantity(tg_id, num):
-    """Обновить размер левеража пользователя."""
+    """Обновить размер начальной ставки пользователя."""
     async with async_session() as session:
         await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(starting_quantity=num))
 
         await session.commit()
 
 
+async def update_base_quantity(tg_id, num):
+    """Обновить размер следующей ставки пользователя."""
+    async with async_session() as session:
+        await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(base_quantity=num))
+
+        await session.commit()
+
+
 async def update_martingale_factor(tg_id, num):
-    """Обновить размер левеража пользователя."""
+    """Обновить шаг мартингейла пользователя."""
     async with async_session() as session:
         await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(martingale_factor=num))
 
@@ -384,7 +395,7 @@ async def update_martingale_factor(tg_id, num):
 
 
 async def update_maximal_quantity(tg_id, num):
-    """Обновить размер левеража пользователя."""
+    """Обновить размер максимальной ставки пользователя."""
     async with async_session() as session:
         await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(maximal_quantity=num))
 
@@ -428,6 +439,31 @@ async def update_entry_order_type(tg_id, order_type):
         await session.commit()
 
 
+async def update_trigger_price(tg_id, price):
+    """Обновить условную цену пользователя."""
+    async with async_session() as session:
+        await session.execute(
+            update(UMS)
+            .where(UMS.tg_id == tg_id)
+            .values(trigger_price=str(price))
+        )
+        await session.commit()
+
+async def get_trigger_price(tg_id):
+    """Получить условную цену пользователя как float, либо None."""
+    async with async_session() as session:
+        result = await session.execute(
+            select(UMS.trigger_price)
+            .where(UMS.tg_id == tg_id)
+        )
+        price = result.scalar_one_or_none()
+        if price:
+            try:
+                return float(price)
+            except ValueError:
+                return None
+        return None
+
 async def get_limit_price(tg_id):
     """Получить лимитную цену пользователя как float, либо None."""
     async with async_session() as session:
@@ -582,4 +618,4 @@ async def set_last_series_info(tg_id: int, last_side: str):
                     last_side=last_side,
                 )
                 session.add(new_entry)
-        await session.commit()
+        await session.commit()

app/telegram/functions/condition_settings/settings.py

@@ -5,7 +5,7 @@ from aiogram.types import Message, CallbackQuery
 from aiogram.fsm.context import FSMContext
 import app.telegram.database.requests as rq
 from app.states.States import condition_settings
-
+from app.states.States import state_limit_price, state_update_entry_type, state_trigger_price
 from logger_helper.logger_helper import LOGGING_CONFIG
 
 logging.config.dictConfig(LOGGING_CONFIG)
@@ -23,42 +23,28 @@ async def reg_new_user_default_condition_settings(id):
 
 
 async def main_settings_message(id, message):
+    data = await rq.get_user_main_settings(id)
+    entry_order_type = data['entry_order_type']
+
+    if entry_order_type == "Market":
+        entry_order_type_rus = "Маркет"
+    elif entry_order_type == "Limit":
+        entry_order_type_rus = "Лимит"
+    else:
+        entry_order_type_rus = "Условный"
+
+    trigger_price = data['trigger_price'] or 0.0
+    limit_price = data['limit_order_price'] or 0.0
 
-    tg_id = id
-    trigger = await rq.get_for_registration_trigger(tg_id)
     text = f""" <b>Условия запуска</b>
-
-<b>- Режим торговли:</b>  {trigger}
 <b>- Таймер: </b> установить таймер / удалить таймер
+<b>- Тип позиции:</b> {entry_order_type_rus}
+<b>- Триггер цена: </b> {trigger_price:,.4f}
+<b>- Лимит цена: </b> {limit_price:,.4f}
 """
     await message.answer(text=text, parse_mode='html', reply_markup=inline_markup.condition_settings_markup)
 
 
-async def trigger_message(id, message, state: FSMContext):
-    await state.set_state(condition_settings.trigger)
-    text = '''
-<b>- Автоматический:</b> торговля будет происходить в рамках серии ставок.
-<b>- Ручной:</b> торговля будет происходить только в ручном режиме.
-<em>- Выберите тип триггера:</em>'''
-
-    await message.answer(text=text, parse_mode='html', reply_markup=inline_markup.trigger_markup)
-
-
-@condition_settings_router.callback_query(F.data == "clb_trigger_manual")
-async def trigger_manual_callback(callback: CallbackQuery, state: FSMContext):
-    await state.set_state(condition_settings.trigger)
-    await rq.update_trigger(tg_id=callback.from_user.id, trigger="Ручной")
-    await main_settings_message(callback.from_user.id, callback.message)
-    await callback.answer()
-
-
-@condition_settings_router.callback_query(F.data == "clb_trigger_auto")
-async def trigger_manual_callback(callback: CallbackQuery, state: FSMContext):
-    await state.set_state(condition_settings.trigger)
-    await rq.update_trigger(tg_id=callback.from_user.id, trigger="Автоматический")
-    await main_settings_message(callback.from_user.id, callback.message)
-    await callback.answer()
-
 async def timer_message(id, message: Message, state: FSMContext):
     await state.set_state(condition_settings.timer)
 
@@ -105,6 +91,85 @@ async def delete_timer_callback(callback: CallbackQuery, state: FSMContext):
     await callback.answer()
 
 
+@condition_settings_router.callback_query(F.data == 'clb_update_entry_type')
+async def update_entry_type_message(callback: CallbackQuery, state: FSMContext) -> None:
+    """
+    Запрашивает у пользователя тип входа в позицию (Market или Limit).
+    """
+    await state.set_state(state_update_entry_type.entry_type)
+    await callback.message.answer("Выберите тип входа в позицию:", reply_markup=inline_markup.entry_order_type_markup)
+    await callback.answer()
+
+
+@condition_settings_router.callback_query(lambda c: c.data and c.data.startswith('entry_order_type:'))
+async def entry_order_type_callback(callback: CallbackQuery, state: FSMContext) -> None:
+    """
+    Обработка выбора типа входа в позицию.
+    Если Limit, запрашивает цену лимитного ордера.
+    Если Market — обновляет настройки.
+    """
+    order_type = callback.data.split(':')[1]
+
+    if order_type not in ['Market', 'Limit']:
+        await callback.answer("Ошибка выбора", show_alert=True)
+        return
+
+    if order_type == 'Limit':
+        order_type_rus = 'Лимит'
+    else:
+        order_type_rus = 'Маркет'
+    try:
+        await state.update_data(entry_order_type=order_type)
+        await rq.update_entry_order_type(callback.from_user.id, order_type)
+        await callback.message.answer(f"Выбран тип входа {order_type_rus}",
+                                      reply_markup=inline_markup.back_to_condition_settings)
+        await callback.answer()
+    except Exception as e:
+        logger.error("Произошла ошибка при обновлении типа входа в позицию: %s", e)
+        await callback.message.answer("Произошла ошибка при обновлении типа входа в позицию",
+                                      reply_markup=inline_markup.back_to_condition_settings)
+    await state.clear()
+
+
+@condition_settings_router.callback_query(F.data == 'clb_change_limit_price')
+async def set_limit_price_callback(callback: CallbackQuery, state: FSMContext) -> None:
+    await state.set_state(state_limit_price.price)
+    await callback.message.answer("Введите цену лимитного ордера:", reply_markup=inline_markup.cancel)
+    await callback.answer()
+
+
+@condition_settings_router.message(state_limit_price.price)
+async def process_limit_price_input(message: Message, state: FSMContext) -> None:
+    try:
+        price = float(message.text)
+        await state.update_data(price=price)
+        await rq.update_limit_price(tg_id=message.from_user.id, price=price)
+        await message.answer(f"Цена лимитного ордера установлена: {price}", reply_markup=inline_markup.back_to_condition_settings)
+        await state.clear()
+    except ValueError:
+        await message.reply("Пожалуйста, введите корректную цену.")
+
+
+@condition_settings_router.callback_query(F.data == 'clb_change_trigger_price')
+async def change_trigger_price_callback(callback: CallbackQuery, state: FSMContext) -> None:
+    await state.set_state(state_trigger_price.price)
+    await callback.message.answer("Введите цену триггера:", reply_markup=inline_markup.cancel)
+    await callback.answer()
+
+
+@condition_settings_router.message(state_trigger_price.price)
+async def process_trigger_price_input(message: Message, state: FSMContext) -> None:
+    try:
+        price = float(message.text)
+        await state.update_data(price=price)
+        await rq.update_trigger_price(tg_id=message.from_user.id, price=price)
+        await message.answer(f"Цена триггера установлена: {price}", reply_markup=inline_markup.back_to_condition_settings)
+        await state.clear()
+    except ValueError:
+        await message.reply("Пожалуйста, введите корректную цену.")
+
+
+
 async def filter_volatility_message(message, state):
     text = '''Фильтр волатильности
 
@@ -140,4 +205,4 @@ async def ai_analytics_message(message, state):
 
     Описание... '''
 
-    await message.answer(text=text, parse_mode='html', reply_markup=inline_markup.buttons_yes_no_markup)
+    await message.answer(text=text, parse_mode='html', reply_markup=inline_markup.buttons_yes_no_markup)

app/telegram/functions/main_settings/settings.py

@@ -2,11 +2,9 @@
 import logging.config
 import app.telegram.Keyboards.inline_keyboards as inline_markup
 
-from pybit.unified_trading import HTTP
 import app.telegram.database.requests as rq
 from aiogram.types import Message, CallbackQuery
 
-from app.services.Bybit.functions.price_symbol import get_price
 from app.services.Bybit.functions.Futures import safe_float, calculate_total_budget, get_bybit_client
 from app.states.States import update_main_settings
 from logger_helper.logger_helper import LOGGING_CONFIG
@@ -40,9 +38,6 @@ async def main_settings_message(id, message):
         starting_quantity = safe_float((data_main_stgs or {}).get('starting_quantity'))
         martingale_factor = safe_float((data_main_stgs or {}).get('martingale_factor'))
         fee_info = client.get_fee_rates(category='linear', symbol=symbol)
-        leverage = safe_float((data_main_stgs or {}).get('size_leverage'))
-        price = await get_price(tg_id, symbol=symbol)
-        entry_price = safe_float(price)
 
         if commission_fee == "Да":
             commission_fee_percent = safe_float(fee_info['result']['list'][0]['takerFeeRate'])
@@ -54,8 +49,6 @@ async def main_settings_message(id, message):
             martingale_factor=martingale_factor,
             max_steps=max_martingale_steps,
             commission_fee_percent=commission_fee_percent,
-            leverage=leverage,
-            current_price=entry_price,
         )
 
         await message.answer(f"""<b>Основные настройки</b>
@@ -65,7 +58,7 @@ async def main_settings_message(id, message):
     <b>- Направление последней сделки:</b> {data['last_side']}
     <b>- Тип маржи:</b> {data['margin_type']}
     <b>- Размер кредитного плеча:</b> х{data['size_leverage']}
-    <b>- Начальная ставка:</b> {data['starting_quantity']}
+    <b>- Ставка:</b> {data['starting_quantity']}
     <b>- Коэффициент мартингейла:</b> {data['martingale_factor']}
     <b>- Текущий шаг:</b> {data['martingale_step']}
     <b>- Максимальное количество ставок в серии:</b> {data['maximal_quantity']}   
@@ -131,6 +124,7 @@ async def state_trading_mode(callback: CallbackQuery, state):
         logger.error("Ошибка при обновлении режима торговли: %s", e)
 
 
+
 async def switch_mode_enabled_message(message, state):
     await state.set_state(update_main_settings.switch_mode_enabled)
 
@@ -267,26 +261,7 @@ async def state_margin_type(callback: CallbackQuery, state):
     callback_data = callback.data
     if callback_data in ['margin_type_isolated', 'margin_type_cross']:
         tg_id = callback.from_user.id
-        api_key = await rq.get_bybit_api_key(tg_id)
-        secret_key = await rq.get_bybit_secret_key(tg_id)
         data_settings = await rq.get_user_main_settings(tg_id)
-        symbol = await rq.get_symbol(tg_id)
-        client = HTTP(api_key=api_key, api_secret=secret_key)
-        try:
-            active_positions = client.get_positions(category='linear', settleCoin="USDT")
-
-            positions = active_positions.get('result', {}).get('list', [])
-        except Exception as e:
-            logger.error("Ошибка при получении активных позиций: %s", e)
-            positions = []
-
-        for pos in positions:
-            size = pos.get('size')
-            if float(size) > 0:
-                await callback.answer(
-                    "⚠️ Маржинальный режим нельзя менять при открытой позиции"
-                )
-                return
 
         try:
             match callback.data:
@@ -318,7 +293,7 @@ async def state_margin_type(callback: CallbackQuery, state):
 async def starting_quantity_message(message, state):
     await state.set_state(update_main_settings.starting_quantity)
 
-    await message.edit_text("Введите <b>начальную ставку:</b>", parse_mode='html',
+    await message.edit_text("Введите <b>ставку:</b>", parse_mode='html',
                             reply_markup=inline_markup.back_btn_list_settings_markup)
 
 
@@ -333,6 +308,7 @@ async def state_starting_quantity(message: Message, state):
         await message.answer(f"✅ Изменено: {data_settings['starting_quantity']} → {data['starting_quantity']}")
 
         await rq.update_starting_quantity(message.from_user.id, data['starting_quantity'])
+        await rq.update_base_quantity(tg_id=message.from_user.id, num=data['starting_quantity'])
         await main_settings_message(message.from_user.id, message)
 
         await state.clear()

logger_helper/loggers/.gitignore

@@ -1 +0,0 @@
-*.log

requirements.txt

@@ -4,6 +4,7 @@ aiohappyeyeballs==2.6.1
 aiohttp==3.12.15
 aiosignal==1.4.0
 aiosqlite==0.21.0
+alembic==1.16.5
 annotated-types==0.7.0
 attrs==25.3.0
 black==25.1.0
@@ -20,7 +21,9 @@ greenlet==3.2.4
 idna==3.10
 isort==6.0.1
 magic-filter==1.0.12
+Mako==1.3.10
 mando==0.7.1
+MarkupSafe==3.0.2
 mccabe==0.7.0
 multidict==6.6.4
 mypy_extensions==1.1.0