The range of TP and SL settings has been changed

.gitignore

@@ -148,6 +148,7 @@ env.bak/
 venv.bak/
 /logger_helper/loggers
 /app/bybit/logger_bybit/loggers
+*.db
 # Spyder project settings
 .spyderproject
 .spyproject

README.md

@@ -54,6 +54,10 @@ sudo -u www-data /usr/bin/pip install -r requirements.txt
 cp .env.sample .env
 nvim .env
 ```
+5. Выполните миграции:
+```bash
+alembic upgrade head
+```
 
 5. Запустите бота:
 

alembic.ini

@@ -0,0 +1,147 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts.
+# this is typically a path given in POSIX (e.g. forward slashes)
+# format, relative to the token %(here)s which refers to the location of this
+# ini file
+script_location = %(here)s/alembic
+
+# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
+# Uncomment the line below if you want the files to be prepended with date and time
+# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
+# for all available tokens
+# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
+
+# sys.path path, will be prepended to sys.path if present.
+# defaults to the current working directory.  for multiple paths, the path separator
+# is defined by "path_separator" below.
+prepend_sys_path = .
+
+
+# timezone to use when rendering the date within the migration file
+# as well as the filename.
+# If specified, requires the python>=3.9 or backports.zoneinfo library and tzdata library.
+# Any required deps can installed by adding `alembic[tz]` to the pip requirements
+# string value is passed to ZoneInfo()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the "slug" field
+# truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; This defaults
+# to <script_location>/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path.
+# The path separator used here should be the separator specified by "path_separator"
+# below.
+# version_locations = %(here)s/bar:%(here)s/bat:%(here)s/alembic/versions
+
+# path_separator; This indicates what character is used to split lists of file
+# paths, including version_locations and prepend_sys_path within configparser
+# files such as alembic.ini.
+# The default rendered in new alembic.ini files is "os", which uses os.pathsep
+# to provide os-dependent path splitting.
+#
+# Note that in order to support legacy alembic.ini files, this default does NOT
+# take place if path_separator is not present in alembic.ini.  If this
+# option is omitted entirely, fallback logic is as follows:
+#
+# 1. Parsing of the version_locations option falls back to using the legacy
+#    "version_path_separator" key, which if absent then falls back to the legacy
+#    behavior of splitting on spaces and/or commas.
+# 2. Parsing of the prepend_sys_path option falls back to the legacy
+#    behavior of splitting on spaces, commas, or colons.
+#
+# Valid values for path_separator are:
+#
+# path_separator = :
+# path_separator = ;
+# path_separator = space
+# path_separator = newline
+#
+# Use os.pathsep. Default configuration used for new projects.
+path_separator = os
+
+# set to 'true' to search source files recursively
+# in each "version_locations" directory
+# new in Alembic version 1.10
+# recursive_version_locations = false
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+# 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
+
+
+[post_write_hooks]
+# post_write_hooks defines scripts or Python functions that are run
+# on newly generated revision scripts.  See the documentation for further
+# detail and examples
+
+# format using "black" - use the console_scripts runner, against the "black" entrypoint
+# hooks = black
+# black.type = console_scripts
+# black.entrypoint = black
+# black.options = -l 79 REVISION_SCRIPT_FILENAME
+
+# lint with attempts to fix using "ruff" - use the module runner, against the "ruff" module
+# hooks = ruff
+# ruff.type = module
+# ruff.module = ruff
+# ruff.options = check --fix REVISION_SCRIPT_FILENAME
+
+# Alternatively, use the exec runner to execute a binary found on your PATH
+# hooks = ruff
+# ruff.type = exec
+# ruff.executable = ruff
+# ruff.options = check --fix REVISION_SCRIPT_FILENAME
+
+# Logging configuration.  This is also consumed by the user-maintained
+# env.py script only.
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARNING
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARNING
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

alembic/README

@@ -0,0 +1 @@
+Generic single-database configuration.

alembic/env.py

@@ -0,0 +1,53 @@
+import asyncio
+from logging.config import fileConfig
+from sqlalchemy import pool
+from sqlalchemy.ext.asyncio import async_engine_from_config
+from alembic import context
+
+config = context.config
+
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+from database.models import Base
+target_metadata = Base.metadata
+
+def do_run_migrations(connection):
+    context.configure(
+        connection=connection,
+        target_metadata=target_metadata,
+        compare_type=True,
+    )
+    with context.begin_transaction():
+        context.run_migrations()
+
+async def run_async_migrations():
+    connectable = async_engine_from_config(
+        config.get_section(config.config_ini_section),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    async with connectable.connect() as connection:
+        await connection.run_sync(do_run_migrations)
+
+    await connectable.dispose()
+
+def run_migrations_offline():
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+    with context.begin_transaction():
+        context.run_migrations()
+
+def run_migrations_online():
+    asyncio.run(run_async_migrations())
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

alembic/script.py.mako

@@ -0,0 +1,28 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, Sequence[str], None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    ${downgrades if downgrades else "pass"}

alembic/versions/e5d612e44563_added_column_side_for_additional_.py

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

alembic/versions/fbf4e3658310_added_side_mode_column.py

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

app/bybit/close_positions.py

@@ -7,25 +7,25 @@ logging.config.dictConfig(LOGGING_CONFIG)
 logger = logging.getLogger("close_positions")
 
 
-async def close_position(
+async def close_position_by_symbol(
-    tg_id: int, symbol: str, side: str, position_idx: int, qty: float
+    tg_id: int, symbol: str
 ) -> bool:
     """
     Closes all positions
     :param tg_id: Telegram user ID
     :param symbol: symbol
-    :param side: side
-    :param position_idx: position index
-    :param qty: quantity
     :return: bool
     """
     try:
         client = await get_bybit_client(tg_id)
 
-        if side == "Buy":
+        response = client.get_positions(
-            r_side = "Sell"
+            category="linear", symbol=symbol
-        else:
+        )
-            r_side = "Buy"
+        positions = response.get("result", {}).get("list", [])
+        r_side = "Sell" if positions[0].get("side") == "Buy" else "Buy"
+        qty = positions[0].get("size")
+        position_idx = positions[0].get("positionIdx")
 
         response = client.place_order(
             category="linear",
@@ -37,16 +37,16 @@ async def close_position(
             positionIdx=position_idx,
         )
         if response["retCode"] == 0:
-            logger.info("All positions closed for %s for user %s", symbol, tg_id)
+            logger.info("Positions closed for %s for user %s", symbol, tg_id)
             return True
         else:
             logger.error(
-                "Error closing all positions for %s for user %s", symbol, tg_id
+                "Error closing position for %s for user %s", symbol, tg_id
             )
             return False
     except Exception as e:
         logger.error(
-            "Error closing all positions for %s for user %s: %s", symbol, tg_id, e
+            "Error closing positions for %s for user %s: %s", symbol, tg_id, e
         )
         return False
 

app/bybit/open_positions.py

@@ -10,7 +10,8 @@ from app.bybit.get_functions.get_tickers import get_tickers
 from app.bybit.logger_bybit.logger_bybit import LOGGING_CONFIG
 from app.bybit.set_functions.set_leverage import set_leverage
 from app.bybit.set_functions.set_margin_mode import set_margin_mode
-from app.helper_functions import get_liquidation_price, safe_float
+from app.bybit.set_functions.set_switch_position_mode import set_switch_position_mode
+from app.helper_functions import safe_float
 
 logging.config.dictConfig(LOGGING_CONFIG)
 logger = logging.getLogger("open_positions")
@@ -24,16 +25,12 @@ async def start_trading_cycle(
     :param tg_id: Telegram user ID
     """
     try:
-        client = await get_bybit_client(tg_id=tg_id)
         symbol = await rq.get_user_symbol(tg_id=tg_id)
         additional_data = await rq.get_user_additional_settings(tg_id=tg_id)
         risk_management_data = await rq.get_user_risk_management(tg_id=tg_id)
-        commission_fee = risk_management_data.commission_fee
-        user_deals_data = await rq.get_user_deal_by_symbol(
-            tg_id=tg_id, symbol=symbol
-        )
         trade_mode = additional_data.trade_mode
         switch_side = additional_data.switch_side
+        side= additional_data.side
         margin_type = additional_data.margin_type
         leverage = additional_data.leverage
         order_quantity = additional_data.order_quantity
@@ -42,54 +39,20 @@ async def start_trading_cycle(
         max_bets_in_series = additional_data.max_bets_in_series
         take_profit_percent = risk_management_data.take_profit_percent
         stop_loss_percent = risk_management_data.stop_loss_percent
-
+        total_commission = 0
-        get_side = "Buy"
-
-        if user_deals_data:
-            get_side = user_deals_data.last_side or "Buy"
 
         if trade_mode == "Switch":
-            if switch_side == "По направлению":
+            side = side
-                side = get_side
-            else:
-                if get_side == "Buy":
-                    side = "Sell"
-                else:
-                    side = "Buy"
         else:
             if trade_mode == "Long":
                 side = "Buy"
             else:
                 side = "Sell"
 
-        # Get fee rates
+        await set_switch_position_mode(
-        fee_info = client.get_fee_rates(category="linear", symbol=symbol)
+            tg_id=tg_id,
-
+            symbol=symbol,
-        # Check if commission fee is enabled
+            mode=0)
-        commission_fee_percent = 0.0
-        if commission_fee == "Yes_commission_fee":
-            commission_fee_percent = safe_float(
-                fee_info["result"]["list"][0]["takerFeeRate"]
-            )
-
-        get_ticker = await get_tickers(tg_id, symbol=symbol)
-        price_symbol = safe_float(get_ticker.get("lastPrice")) or 0
-        instruments_info = await get_instruments_info(tg_id=tg_id, symbol=symbol)
-        qty_step_str = instruments_info.get("lotSizeFilter").get("qtyStep")
-        qty_step = safe_float(qty_step_str)
-        qty = safe_float(order_quantity) / safe_float(price_symbol)
-        decimals = abs(int(round(math.log10(qty_step))))
-        qty_formatted = math.floor(qty / qty_step) * qty_step
-        qty_formatted = round(qty_formatted, decimals)
-
-        if trigger_price > 0:
-            po_trigger_price = str(trigger_price)
-        else:
-            po_trigger_price = None
-
-        price_for_cals = trigger_price if po_trigger_price is not None else price_symbol
-        total_commission = price_for_cals * qty_formatted * commission_fee_percent
-
         await set_margin_mode(tg_id=tg_id, margin_mode=margin_type)
         await set_leverage(
             tg_id=tg_id,
@@ -114,9 +77,9 @@ async def start_trading_cycle(
             await rq.set_user_deal(
                 tg_id=tg_id,
                 symbol=symbol,
-                last_side=side,
                 current_step=1,
                 trade_mode=trade_mode,
+                side_mode=switch_side,
                 margin_type=margin_type,
                 leverage=leverage,
                 order_quantity=order_quantity,
@@ -152,9 +115,8 @@ async def start_trading_cycle(
         return None
 
 
-async def trading_cycle(
+async def trading_cycle_profit(
-    tg_id: int, symbol: str, reverse_side: str
+        tg_id: int, symbol: str, side: str) -> str | None:
-) -> str | None:
     try:
         user_deals_data = await rq.get_user_deal_by_symbol(tg_id=tg_id, symbol=symbol)
         user_auto_trading_data = await rq.get_user_auto_trading(tg_id=tg_id, symbol=symbol)
@@ -167,8 +129,7 @@ async def trading_cycle(
         stop_loss_percent = user_deals_data.stop_loss_percent
         max_bets_in_series = user_deals_data.max_bets_in_series
         martingale_factor = user_deals_data.martingale_factor
-        current_step = user_deals_data.current_step
+        side_mode = user_deals_data.side_mode
-        order_quantity = user_deals_data.order_quantity
         base_quantity = user_deals_data.base_quantity
 
         await set_margin_mode(tg_id=tg_id, margin_mode=margin_type)
@@ -178,15 +139,84 @@ async def trading_cycle(
             leverage=leverage,
         )
 
-        if reverse_side == "Buy":
-            real_side = "Sell"
-        else:
-            real_side = "Buy"
-
-        side = real_side
 
         if trade_mode == "Switch":
-            side = "Sell" if real_side == "Buy" else "Buy"
+            if side_mode == "Противоположно":
+                s_side = "Sell" if side == "Buy" else "Buy"
+            else:
+                s_side = side
+        else:
+            s_side = side
+
+        res = await open_positions(
+            tg_id=tg_id,
+            symbol=symbol,
+            side=s_side,
+            order_quantity=base_quantity,
+            trigger_price=trigger_price,
+            margin_type=margin_type,
+            leverage=leverage,
+            take_profit_percent=take_profit_percent,
+            stop_loss_percent=stop_loss_percent,
+            commission_fee_percent=total_fee
+        )
+
+        if res == "OK":
+            await rq.set_user_deal(
+                tg_id=tg_id,
+                symbol=symbol,
+                current_step=1,
+                trade_mode=trade_mode,
+                side_mode=side_mode,
+                margin_type=margin_type,
+                leverage=leverage,
+                order_quantity=base_quantity,
+                trigger_price=trigger_price,
+                martingale_factor=martingale_factor,
+                max_bets_in_series=max_bets_in_series,
+                take_profit_percent=take_profit_percent,
+                stop_loss_percent=stop_loss_percent,
+                base_quantity=base_quantity
+            )
+            return "OK"
+
+        return (
+            res
+            if res
+               in {
+                   "Risk is too high for this trade",
+                   "ab not enough for new order",
+                   "InvalidRequestError",
+                   "The number of contracts exceeds maximum limit allowed",
+               }
+            else None
+        )
+    except Exception as e:
+        logger.error("Error in trading_cycle_profit: %s", e)
+        return None
+
+
+async def trading_cycle(
+        tg_id: int, symbol: str, side: str,
+) -> str | None:
+    try:
+        user_deals_data = await rq.get_user_deal_by_symbol(tg_id=tg_id, symbol=symbol)
+        user_auto_trading_data = await rq.get_user_auto_trading(tg_id=tg_id, symbol=symbol)
+        user_risk_management_data = await rq.get_user_risk_management(tg_id=tg_id)
+        commission_fee = user_risk_management_data.commission_fee
+        total_fee = user_auto_trading_data.total_fee
+        trade_mode = user_deals_data.trade_mode
+        margin_type = user_deals_data.margin_type
+        leverage = user_deals_data.leverage
+        trigger_price = 0
+        take_profit_percent = user_deals_data.take_profit_percent
+        stop_loss_percent = user_deals_data.stop_loss_percent
+        max_bets_in_series = user_deals_data.max_bets_in_series
+        martingale_factor = user_deals_data.martingale_factor
+        current_step = user_deals_data.current_step
+        order_quantity = user_deals_data.order_quantity
+        base_quantity = user_deals_data.base_quantity
+        side_mode = user_deals_data.side_mode
 
         next_quantity = safe_float(order_quantity) * (
             safe_float(martingale_factor)
@@ -196,10 +226,29 @@ async def trading_cycle(
         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,
+            symbol=symbol,
+            leverage=leverage,
+        )
+        if commission_fee == "Yes_commission_fee":
+            total_fee = total_fee
+        else:
+            total_fee = 0
+
+        if trade_mode == "Switch":
+            if side == "Buy":
+                r_side = "Sell"
+            else:
+                r_side = "Buy"
+        else:
+            r_side = side
+
         res = await open_positions(
             tg_id=tg_id,
             symbol=symbol,
-            side=side,
+            side=r_side,
             order_quantity=next_quantity,
             trigger_price=trigger_price,
             margin_type=margin_type,
@@ -213,9 +262,9 @@ async def trading_cycle(
             await rq.set_user_deal(
                 tg_id=tg_id,
                 symbol=symbol,
-                last_side=side,
                 current_step=current_step,
                 trade_mode=trade_mode,
+                side_mode=side_mode,
                 margin_type=margin_type,
                 leverage=leverage,
                 order_quantity=next_quantity,
@@ -264,7 +313,7 @@ async def open_positions(
         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(price_symbol)
+        qty = (safe_float(order_quantity) * safe_float(leverage)) / safe_float(price_symbol)
         decimals = abs(int(round(math.log10(qty_step))))
         qty_formatted = math.floor(qty / qty_step) * qty_step
         qty_formatted = round(qty_formatted, decimals)
@@ -276,37 +325,29 @@ async def open_positions(
             po_trigger_price = None
             trigger_direction = None
 
-        get_leverage = safe_float(leverage)
-
         price_for_cals = trigger_price if po_trigger_price is not None else price_symbol
 
+        if qty_formatted <= 0:
+            return "Order does not meet minimum order value"
+
         if margin_type == "ISOLATED_MARGIN":
-            liq_long, liq_short = await get_liquidation_price(
-                tg_id=tg_id,
-                entry_price=price_for_cals,
-                symbol=symbol,
-                leverage=get_leverage,
-            )
-
-            if (liq_long > 0 or liq_short > 0) and price_for_cals > 0:
             if side == "Buy":
-                    base_tp = price_for_cals + (price_for_cals - liq_long)
+                take_profit_price = price_for_cals * (
-                    take_profit_price = base_tp + commission_fee_percent
+                        1 + take_profit_percent / 100) + commission_fee_percent / qty_formatted
+                stop_loss_price = None
             else:
-                    base_tp = price_for_cals - (liq_short - price_for_cals)
+                take_profit_price = price_for_cals * (
-                    take_profit_price = base_tp - commission_fee_percent
+                        1 - take_profit_percent / 100) - commission_fee_percent / qty_formatted
-                take_profit_price = max(take_profit_price, 0)
-            else:
-                take_profit_price = None
-
                 stop_loss_price = None
         else:
             if side == "Buy":
-                take_profit_price = price_for_cals * (1 + take_profit_percent / 100) + commission_fee_percent
+                take_profit_price = price_for_cals * (
-                stop_loss_price = price_for_cals * (1 - stop_loss_percent / 100) - commission_fee_percent
+                            1 + take_profit_percent / 100) + commission_fee_percent / qty_formatted
+                stop_loss_price = price_for_cals * (1 - stop_loss_percent / 100)
             else:
-                take_profit_price = price_for_cals * (1 - take_profit_percent / 100) - commission_fee_percent
+                take_profit_price = price_for_cals * (
-                stop_loss_price = price_for_cals * (1 + stop_loss_percent / 100) + commission_fee_percent
+                            1 - take_profit_percent / 100) - commission_fee_percent / qty_formatted
+                stop_loss_price = price_for_cals * (1 + stop_loss_percent / 100)
 
             take_profit_price = max(take_profit_price, 0)
             stop_loss_price = max(stop_loss_price, 0)
@@ -356,5 +397,5 @@ async def open_positions(
         return "InvalidRequestError"
 
     except Exception as e:
-        logger.error("Error opening position for user %s: %s", tg_id, e)
+        logger.error("Error opening position for user %s: %s", tg_id, e, exc_info=True)
         return None

app/bybit/profile_bybit.py

@@ -21,6 +21,10 @@ async def user_profile_bybit(tg_id: int, message: Message, state: FSMContext) ->
         if wallet:
             balance = wallet.get("totalWalletBalance", "0")
             symbol = await rq.get_user_symbol(tg_id=tg_id)
+            if symbol is None:
+                await rq.set_user_symbol(tg_id=tg_id, symbol="BTCUSDT")
+                await user_profile_bybit(tg_id=tg_id, message=message, state=state)
+            else:
                 await message.answer(
                     text=f"💎Ваш профиль:\n\n"
                          f"⚖️ Баланс: {float(balance):,.2f} USD\n"

app/bybit/telegram_message_handler.py

@@ -3,7 +3,7 @@ import logging.config
 import app.telegram.keyboards.inline as kbi
 import database.request as rq
 from app.bybit.logger_bybit.logger_bybit import LOGGING_CONFIG
-from app.bybit.open_positions import trading_cycle
+from app.bybit.open_positions import trading_cycle, trading_cycle_profit
 from app.helper_functions import format_value, safe_float
 
 logging.config.dictConfig(LOGGING_CONFIG)
@@ -41,11 +41,26 @@ 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"Количество: {qty}\n"
                 f"Движение: {side_rus}\n"
             )
+
+            if user_deals_data is not None and auto_trading:
+                text += f"Текущая ставка: {user_deals_data.order_quantity} USDT\n"
+            else:
+                text += f"Количество: {qty}\n"
+
             if price and price != "0":
                 text += f"Цена: {price}\n"
             if take_profit and take_profit != "Нет данных":
@@ -67,13 +82,21 @@ class TelegramMessageHandler:
             closed_size = format_value(execution.get("closedSize"))
             symbol = format_value(execution.get("symbol"))
             exec_price = format_value(execution.get("execPrice"))
-            exec_fee = format_value(execution.get("execFee"))
+            exec_qty = format_value(execution.get("execQty"))
+            exec_fees = format_value(execution.get("execFee"))
+            fee_rate = format_value(execution.get("feeRate"))
             side = format_value(execution.get("side"))
             side_rus = (
                 "Покупка"
                 if side == "Buy"
                 else "Продажа" if side == "Sell" else "Нет данных"
             )
+            if safe_float(exec_fees) == 0:
+                exec_fee = safe_float(exec_price) * safe_float(exec_qty) * safe_float(
+                    fee_rate
+                )
+            else:
+                exec_fee = safe_float(exec_fees)
 
             if safe_float(closed_size) == 0:
                 await rq.set_fee_user_auto_trading(
@@ -86,9 +109,7 @@ class TelegramMessageHandler:
 
             get_total_fee = user_auto_trading.total_fee
             total_fee = safe_float(exec_fee) + safe_float(get_total_fee)
-            await rq.set_total_fee_user_auto_trading(
+
-                tg_id=tg_id, symbol=symbol, total_fee=total_fee
-            )
 
             if user_auto_trading is not None and user_auto_trading.fee is not None:
                 fee = user_auto_trading.fee
@@ -96,42 +117,38 @@ class TelegramMessageHandler:
                 fee = 0
 
             exec_pnl = format_value(execution.get("execPnl"))
-            risk_management_data = await rq.get_user_risk_management(tg_id=tg_id)
-            commission_fee = risk_management_data.commission_fee
-
-            if commission_fee == "Yes_commission_fee":
             total_pnl = safe_float(exec_pnl) - safe_float(exec_fee) - fee
-            else:
-                total_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
             )
-            exec_bet = user_deals_data.order_quantity
+            if user_deals_data is not None and auto_trading:
-            base_quantity = user_deals_data.base_quantity
+                await rq.set_total_fee_user_auto_trading(
+                    tg_id=tg_id, symbol=symbol, total_fee=total_fee
+                )
+                text += f"Текущая ставка: {user_deals_data.order_quantity} USDT\n"
 
             text += (
                 f"Цена исполнения: {exec_price}\n"
-                f"Текущая ставка: {exec_bet}\n"
+                f"Комиссия: {exec_fee:.8f}\n"
-                f"Движение: {side_rus}\n"
-                f"Комиссия за сделку: {exec_fee}\n"
             )
 
-            if safe_float(closed_size) > 0:
+            if safe_float(closed_size) == 0:
+                text += f"Движение: {side_rus}\n"
+            else:
                 text += f"\nРеализованная прибыль: {total_pnl:.7f}\n"
 
             await self.telegram_bot.send_message(
                 chat_id=tg_id, text=text, reply_markup=kbi.profile_bybit
             )
 
-            auto_trading = (
-                user_auto_trading.auto_trading if user_auto_trading else False
-            )
             user_symbols = user_auto_trading.symbol if user_auto_trading else None
 
             if (
@@ -140,10 +157,42 @@ class TelegramMessageHandler:
                 and user_symbols is not None
             ):
                 if safe_float(total_pnl) > 0:
-                    profit_text = "📈 Прибыль достигнута\n"
+                    profit_text = "📈 Прибыль достигнута. Начинаем новую серию с базовой ставки\n"
                     await self.telegram_bot.send_message(
                         chat_id=tg_id, text=profit_text, reply_markup=kbi.profile_bybit
                     )
+
+                    if side == "Buy":
+                        r_side = "Sell"
+                    else:
+                        r_side = "Buy"
+
+                    await rq.set_last_side_by_symbol(
+                        tg_id=tg_id, symbol=symbol, last_side=r_side)
+                    await rq.set_total_fee_user_auto_trading(
+                        tg_id=tg_id, symbol=symbol, total_fee=0
+                    )
+                    await rq.set_fee_user_auto_trading(
+                        tg_id=tg_id, symbol=symbol, fee=0
+                    )
+
+                    res = await trading_cycle_profit(
+                        tg_id=tg_id, symbol=symbol, side=r_side
+                    )
+
+                    if res == "OK":
+                        pass
+                    else:
+                        errors = {
+                            "Max bets in series": "❗️ Максимальное количество сделок в серии достигнуто",
+                            "Risk is too high for this trade": "❗️ Риск сделки слишком высок для продолжения",
+                            "ab not enough for new order": "❗️ Недостаточно средств для продолжения торговли",
+                            "InvalidRequestError": "❗️ Недостаточно средств для размещения нового ордера с заданным количеством и плечом.",
+                            "The number of contracts exceeds maximum limit allowed": "❗️ Превышен максимальный лимит ставки",
+                        }
+                        error_text = errors.get(
+                            res, "❗️ Не удалось открыть новую сделку"
+                        )
                         await rq.set_auto_trading(
                             tg_id=tg_id, symbol=symbol, auto_trading=False
                         )
@@ -154,16 +203,24 @@ class TelegramMessageHandler:
                         await rq.set_fee_user_auto_trading(
                             tg_id=tg_id, symbol=symbol, fee=0
                         )
-                    await rq.set_order_quantity(
+                        await self.telegram_bot.send_message(
-                        tg_id=tg_id, order_quantity=base_quantity
+                            chat_id=tg_id,
+                            text=error_text,
+                            reply_markup=kbi.profile_bybit,
                         )
                 else:
                     open_order_text = "\n❗️ Сделка закрылась в минус, открываю новую сделку с увеличенной ставкой.\n"
                     await self.telegram_bot.send_message(
                         chat_id=tg_id, text=open_order_text
                     )
+
+                    if side == "Buy":
+                        r_side = "Sell"
+                    else:
+                        r_side = "Buy"
+
                     res = await trading_cycle(
-                        tg_id=tg_id, symbol=symbol, reverse_side=side
+                        tg_id=tg_id, symbol=symbol, side=r_side
                     )
 
                     if res == "OK":
@@ -174,7 +231,7 @@ class TelegramMessageHandler:
                             "Risk is too high for this trade": "❗️ Риск сделки слишком высок для продолжения",
                             "ab not enough for new order": "❗️ Недостаточно средств для продолжения торговли",
                             "InvalidRequestError": "❗️ Недостаточно средств для размещения нового ордера с заданным количеством и плечом.",
-                            "The number of contracts exceeds maximum limit allowed": "❗️ Количество контрактов превышает допустимое максимальное количество контрактов",
+                            "The number of contracts exceeds maximum limit allowed": "❗️ Превышен максимальный лимит ставки",
                         }
                         error_text = errors.get(
                             res, "❗️ Не удалось открыть новую сделку"

app/telegram/handlers/changing_the_symbol.py

@@ -124,6 +124,8 @@ async def set_symbol(message: Message, state: FSMContext) -> None:
         risk_percent = 100 / 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(
+            tg_id=message.from_user.id, take_profit_percent=risk_percent)
         await rq.set_trigger_price(tg_id=message.from_user.id, trigger_price=0)
         await rq.set_order_quantity(tg_id=message.from_user.id, order_quantity=1.0)
 

app/telegram/handlers/close_orders.py

@@ -4,9 +4,6 @@ from aiogram import Router
 from aiogram.fsm.context import FSMContext
 from aiogram.types import CallbackQuery
 
-import database.request as rq
-from app.bybit.close_positions import cancel_order, close_position
-from app.helper_functions import safe_float
 from logger_helper.logger_helper import LOGGING_CONFIG
 
 logging.config.dictConfig(LOGGING_CONFIG)
@@ -28,31 +25,6 @@ async def close_position_handler(
     :return: None
     """
     try:
-        data = callback_query.data
-        parts = data.split("_")
-        symbol = parts[2]
-        side = parts[3]
-        position_idx = int(parts[4])
-        qty = safe_float(parts[5])
-        await rq.set_auto_trading(
-            tg_id=callback_query.from_user.id,
-            symbol=symbol,
-            auto_trading=False,
-            side=side,
-        )
-        res = await close_position(
-            tg_id=callback_query.from_user.id,
-            symbol=symbol,
-            side=side,
-            position_idx=position_idx,
-            qty=qty,
-        )
-
-        if not res:
-            await callback_query.answer(text="Произошла ошибка при закрытии позиции.")
-            return
-
-        await callback_query.answer(text="Позиция успешно закрыта.")
         logger.debug(
             "Command close_position processed successfully for user: %s",
             callback_query.from_user.id,
@@ -81,19 +53,6 @@ async def cancel_order_handler(
     :return: None
     """
     try:
-        data = callback_query.data
-        parts = data.split("_")
-        symbol = parts[2]
-        order_id = parts[3]
-        res = await cancel_order(
-            tg_id=callback_query.from_user.id, symbol=symbol, order_id=order_id
-        )
-
-        if not res:
-            await callback_query.answer(text="Произошла ошибка при закрытии ордера.")
-            return
-
-        await callback_query.answer(text="Ордер успешно закрыт.")
         logger.debug(
             "Command close_order processed successfully for user: %s",
             callback_query.from_user.id,

app/telegram/handlers/main_settings/additional_settings.py

@@ -7,6 +7,7 @@ from aiogram.types import CallbackQuery, Message
 import app.telegram.keyboards.inline as kbi
 import database.request as rq
 from app.bybit.get_functions.get_instruments_info import get_instruments_info
+from app.bybit.get_functions.get_positions import get_active_positions_by_symbol, get_active_orders_by_symbol
 from app.bybit.set_functions.set_leverage import set_leverage
 from app.bybit.set_functions.set_margin_mode import set_margin_mode
 from app.helper_functions import is_int, is_number, safe_float
@@ -42,7 +43,7 @@ async def settings_for_trade_mode(
             text="Выберите режим торговли:\n\n"
                  "Лонг - все сделки серии открываются на покупку.\n"
                  "Шорт - все сделки серии открываются на продажу.\n"
-                 "Свитч - направление каждой сделки серии меняется по переменно.\n",
+                 "Свитч - направление каждой сделки в рамках серии меняется попеременно.\n",
             reply_markup=kbi.trade_mode,
         )
         logger.debug(
@@ -104,10 +105,10 @@ async def trade_mode(callback_query: CallbackQuery, state: FSMContext) -> None:
         await state.clear()
 
 
-@router_additional_settings.callback_query(F.data == "switch_side_start")
+@router_additional_settings.callback_query(F.data == "switch_side_second")
-async def switch_side_start(callback_query: CallbackQuery, state: FSMContext) -> None:
+async def switch_side_second(callback_query: CallbackQuery, state: FSMContext) -> None:
     """
-    Handles the 'switch_side_start' callback query.
+    Handles the 'switch_side_second' callback query.
 
     Clears the current FSM state, edits the message text to display the switch side start message,
     and shows an inline keyboard for selection.
@@ -122,13 +123,13 @@ async def switch_side_start(callback_query: CallbackQuery, state: FSMContext) ->
     try:
         await state.clear()
         await callback_query.message.edit_text(
-            text="Выберите направление первой сделки серии:\n\n"
+            text="Выберите направление первой сделки последующих серии:\n\n"
                  "По направлению - сделка открывается в направлении последней сделки предыдущей серии.\n"
                  "Противоположно - сделка открывается в противоположном направлении последней сделки предыдущей серии.\n",
             reply_markup=kbi.switch_side,
         )
         logger.debug(
-            "Command switch_side_start processed successfully for user: %s",
+            "Command switch_side_second processed successfully for user: %s",
             callback_query.from_user.id,
         )
     except Exception as e:
@@ -136,7 +137,7 @@ async def switch_side_start(callback_query: CallbackQuery, state: FSMContext) ->
             text="Произошла ошибка. Пожалуйста, попробуйте позже."
         )
         logger.error(
-            "Error processing command switch_side_start for user %s: %s",
+            "Error processing command switch_side_second for user %s: %s",
             callback_query.from_user.id,
             e,
         )
@@ -192,6 +193,89 @@ async def switch_side_handler(callback_query: CallbackQuery, state: FSMContext)
         await state.clear()
 
 
+@router_additional_settings.callback_query(F.data == "switch_side_start")
+async def switch_side_start(callback_query: CallbackQuery, state: FSMContext) -> None:
+    """
+    Handles the 'switch_side_start' callback query.
+
+    Clears the current FSM state, edits the message text to display the switch side second message,
+    and shows an inline keyboard for selection.
+
+    Args:
+        callback_query (CallbackQuery): Incoming callback query from Telegram inline keyboard.
+        state (FSMContext): Finite State Machine context for the current user session.
+
+    Logs:
+        Success or error messages with user identification.
+    """
+    try:
+        await state.clear()
+        await callback_query.message.edit_text(
+            text="Выберите направление первой сделки:\n\n", reply_markup=kbi.side_for_switch
+        )
+        logger.debug(
+            "Command switch_side_start processed successfully for user: %s",
+            callback_query.from_user.id,
+        )
+    except Exception as e:
+        await callback_query.answer(
+            text="Произошла ошибка. Пожалуйста, попробуйте позже."
+        )
+        logger.error(
+            "Error processing command switch_side_start for user %s: %s",
+            callback_query.from_user.id,
+            e,
+        )
+
+
+@router_additional_settings.callback_query(lambda c: c.data == "buy_switch" or c.data == "sell_switch")
+async def switch_side_handler_2(callback_query: CallbackQuery, state: FSMContext) -> None:
+    """
+    Handles callback queries related to switch side selection.
+
+    Updates FSM context with selected switch side and persists the choice in database.
+    Sends an acknowledgement to user and clears FSM state afterward.
+
+    Args:
+        callback_query (CallbackQuery): Incoming callback query indicating selected switch side.
+        state (FSMContext): Finite State Machine context for the current user session.
+
+    Logs:
+        Success or error messages with user identification.
+    """
+    try:
+        if callback_query.data == "sell_switch":
+            side = "Sell"
+            side_rus = "Продажа"
+        else:
+            side = "Buy"
+            side_rus = "Покупка"
+
+        req = await rq.set_side(
+            tg_id=callback_query.from_user.id, side=side
+        )
+
+        if not req:
+            await callback_query.answer(
+                text="Произошла ошибка при смене направления. Пожалуйста, попробуйте позже."
+            )
+            return
+
+        await callback_query.answer(text=f"Выбрано: {side_rus}")
+        logger.debug(
+            "Switch side changed successfully for user: %s", callback_query.from_user.id
+        )
+    except Exception as e:
+        await callback_query.answer(text="Произошла ошибка при смене направления.")
+        logger.error(
+            "Error processing set switch_side for user %s: %s",
+            callback_query.from_user.id,
+            e,
+        )
+    finally:
+        await state.clear()
+
+
 @router_additional_settings.callback_query(F.data == "margin_type")
 async def settings_for_margin_type(
         callback_query: CallbackQuery, state: FSMContext
@@ -211,6 +295,31 @@ async def settings_for_margin_type(
     """
     try:
         await state.clear()
+        symbol = await rq.get_user_symbol(tg_id=callback_query.from_user.id)
+        deals = await get_active_positions_by_symbol(
+            tg_id=callback_query.from_user.id, symbol=symbol
+        )
+        position = next((d for d in deals if d.get("symbol") == symbol), None)
+
+        if position:
+            size = position.get("size", 0)
+        else:
+            size = 0
+
+        if safe_float(size) > 0:
+            await callback_query.answer(
+                text="У вас есть активная позиция по текущей паре",
+            )
+            return
+
+        orders = await get_active_orders_by_symbol(
+            tg_id=callback_query.from_user.id, symbol=symbol)
+
+        if orders is not None:
+            await callback_query.answer(
+                text="У вас есть активный ордер по текущей паре",
+            )
+            return
         await callback_query.message.edit_text(
             text="Выберите тип маржи:\n\n"
                  "Примечание: Если у вас есть открытые позиции, то маржа примениться ко всем позициям",
@@ -554,6 +663,8 @@ async def set_leverage_handler(message: Message, state: FSMContext) -> None:
             risk_percent = 100 / 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(
+                tg_id=message.from_user.id, take_profit_percent=risk_percent)
             logger.info(
                 "User %s set leverage: %s", message.from_user.id, leverage_float
             )

app/telegram/handlers/main_settings/risk_management.py

@@ -98,7 +98,7 @@ async def set_take_profit_percent(message: Message, state: FSMContext) -> None:
             )
             return
 
-        if safe_float(take_profit_percent_value) < 1 or safe_float(take_profit_percent_value) > 100:
+        if safe_float(take_profit_percent_value) < 0.1 or safe_float(take_profit_percent_value) > 100:
             await message.answer(
                 text="Ошибка: введите число от 1 до 100.",
                 reply_markup=kbi.back_to_risk_management,
@@ -219,7 +219,7 @@ async def set_stop_loss_percent(message: Message, state: FSMContext) -> None:
             )
             return
 
-        if safe_float(stop_loss_percent_value) < 1 or safe_float(stop_loss_percent_value) > 100:
+        if safe_float(stop_loss_percent_value) < 0.1 or safe_float(stop_loss_percent_value) > 100:
             await message.answer(
                 text="Ошибка: введите число от 1 до 100.",
                 reply_markup=kbi.back_to_risk_management,

app/telegram/handlers/settings.py

@@ -62,10 +62,19 @@ async def additional_settings(callback_query: CallbackQuery, state: FSMContext)
         max_bets = additional_data.max_bets_in_series
         quantity = f(additional_data.order_quantity)
         trigger_price = f(additional_data.trigger_price) or 0
+        side = additional_data.side
+
+        side_map = {
+            "Buy": "Лонг",
+            "Sell": "Шорт",
+        }
+        side_rus = side_map.get(side, side)
 
         switch_side_mode = ""
+        side = ""
         if trade_mode == "Switch":
-            switch_side_mode = f"- Направление первой сделки: {switch_side}\n"
+            side = f"- Направление первой сделки: {side_rus}\n"
+            switch_side_mode = f"- Направление первой сделки последующих серии: {switch_side}\n"
 
         total_budget = await calculate_total_budget(
             quantity=quantity,
@@ -75,6 +84,7 @@ async def additional_settings(callback_query: CallbackQuery, state: FSMContext)
         text = (
             f"Основные настройки:\n\n"
             f"- Режим торговли: {trade_mode_rus}\n"
+            f"{side}"
             f"{switch_side_mode}"
             f"- Тип маржи: {margin_type_rus}\n"
             f"- Размер кредитного плеча: {leverage:.2f}\n"
@@ -123,8 +133,8 @@ async def risk_management(callback_query: CallbackQuery, state: FSMContext) -> N
 
             await callback_query.message.edit_text(
                 text=f"Риск-менеджмент:\n\n"
-                f"- Процент изменения цены для фиксации прибыли: {take_profit_percent}%\n"
+                f"- Процент изменения цены для фиксации прибыли: {take_profit_percent:.2f}%\n"
-                f"- Процент изменения цены для фиксации убытка: {stop_loss_percent}%\n\n"
+                f"- Процент изменения цены для фиксации убытка: {stop_loss_percent:.2f}%\n\n"
                 f"- Комиссия биржи для расчета прибыли: {commission_fee_rus}\n\n",
                 reply_markup=kbi.risk_management,
             )

app/telegram/handlers/start_trading.py

@@ -7,7 +7,7 @@ from aiogram.types import CallbackQuery
 
 import app.telegram.keyboards.inline as kbi
 import database.request as rq
-from app.bybit.get_functions.get_positions import get_active_positions_by_symbol
+from app.bybit.get_functions.get_positions import get_active_positions_by_symbol, get_active_orders_by_symbol
 from app.bybit.open_positions import start_trading_cycle
 from app.helper_functions import safe_float
 from app.telegram.tasks.tasks import (
@@ -33,6 +33,7 @@ async def start_trading(callback_query: CallbackQuery, state: FSMContext) -> Non
     """
     try:
         await state.clear()
+        tg_id = callback_query.from_user.id
         symbol = await rq.get_user_symbol(tg_id=callback_query.from_user.id)
         deals = await get_active_positions_by_symbol(
             tg_id=callback_query.from_user.id, symbol=symbol
@@ -46,7 +47,16 @@ async def start_trading(callback_query: CallbackQuery, state: FSMContext) -> Non
 
         if safe_float(size) > 0:
             await callback_query.answer(
-                text="У вас есть активная позиция",
+                text="У вас есть активная позиция по текущей паре",
+            )
+            return
+
+        orders = await get_active_orders_by_symbol(
+            tg_id=callback_query.from_user.id, symbol=symbol)
+
+        if orders is not None:
+            await callback_query.answer(
+                text="У вас есть активный ордер по текущей паре",
             )
             return
 
@@ -73,22 +83,29 @@ async def start_trading(callback_query: CallbackQuery, state: FSMContext) -> Non
                 symbol=symbol,
                 auto_trading=True,
             )
+            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 start_trading_cycle(
                 tg_id=callback_query.from_user.id,
             )
 
             error_messages = {
-                "Limit price is out min price": "Цена лимитного ордера меньше минимального",
+                "Limit price is out min price": "Цена лимитного ордера меньше допустимого",
-                "Limit price is out max price": "Цена лимитного ордера больше максимального",
+                "Limit price is out max price": "Цена лимитного ордера больше допустимого",
                 "Risk is too high for this trade": "Риск сделки превышает допустимый убыток",
                 "estimated will trigger liq": "Лимитный ордер может вызвать мгновенную ликвидацию. Проверьте параметры ордера.",
                 "ab not enough for new order": "Недостаточно средств для создания нового ордера",
                 "InvalidRequestError": "Произошла ошибка при запуске торговли.",
-                "Order does not meet minimum order value": "Сумма ордера не достаточна для запуска торговли",
+                "Order does not meet minimum order value": "Сумма ставки меньше допустимого для запуска торговли. "
-                "position idx not match position mode": "Ошибка режима позиции для данного инструмента",
+                                                           "Увеличьте ставку, чтобы запустить торговлю",
-                "Qty invalid": "Некорректное значение ордера для данного инструмента",
+                "position idx not match position mode": "Измените режим позиции, чтобы запустить торговлю",
-                "The number of contracts exceeds maximum limit allowed": "️️Количество контрактов превышает допустимое максимальное количество контрактов",
+                "Qty invalid": "Некорректное значение ставки для данного инструмента",
-                "The number of contracts exceeds minimum limit allowed": "️️Количество контрактов превышает допустимое минимальное количество контрактов",
+                "The number of contracts exceeds maximum limit allowed": "️️Превышен максимальный лимит ставки",
+                "The number of contracts exceeds minimum limit allowed": "️️Лимит ставки меньше минимально допустимого",
             }
 
             if res == "OK":
@@ -112,7 +129,7 @@ async def start_trading(callback_query: CallbackQuery, state: FSMContext) -> Non
     except Exception as e:
         await callback_query.answer(text="Произошла ошибка при запуске торговли")
         logger.error(
-            "Error processing command long for user %s: %s",
+            "Error processing command start_trading for user %s: %s",
             callback_query.from_user.id,
             e,
         )

app/telegram/handlers/stop_trading.py

@@ -5,6 +5,7 @@ from aiogram import F, Router
 from aiogram.fsm.context import FSMContext
 from aiogram.types import CallbackQuery
 
+from app.bybit.close_positions import close_position_by_symbol
 import app.telegram.keyboards.inline as kbi
 import database.request as rq
 from app.telegram.tasks.tasks import add_stop_task, cancel_stop_task
@@ -27,6 +28,7 @@ async def stop_all_trading(callback_query: CallbackQuery, state: FSMContext):
             tg_id=callback_query.from_user.id
         )
         timer_end = conditional_data.timer_end
+        symbol = await rq.get_user_symbol(tg_id=callback_query.from_user.id)
 
         async def delay_start():
             if timer_end > 0:
@@ -37,30 +39,21 @@ 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_list = await rq.get_all_user_auto_trading(
+            user_auto_trading = await rq.get_user_auto_trading(
-                tg_id=callback_query.from_user.id
+                tg_id=callback_query.from_user.id, symbol=symbol
             )
 
-            if any(item.auto_trading for item in user_auto_trading_list):
+            if user_auto_trading and user_auto_trading.auto_trading:
-                for active_auto_trading in user_auto_trading_list:
+                await rq.set_auto_trading(
-                    if active_auto_trading.auto_trading:
-                        symbol = active_auto_trading.symbol
-                        req = await rq.set_auto_trading(
                     tg_id=callback_query.from_user.id,
                     symbol=symbol,
                     auto_trading=False,
                 )
-                        if not req:
+                await close_position_by_symbol(
-                            await callback_query.message.edit_text(
+                    tg_id=callback_query.from_user.id, symbol=symbol)
-                                text="Произошла ошибка при остановке торговли",
+                await callback_query.message.edit_text(text=f"Торговля для {symbol} остановлена", reply_markup=kbi.profile_bybit)
-                                reply_markup=kbi.profile_bybit,
-                            )
-                            return
-                await callback_query.message.edit_text(
-                    text="Торговля остановлена", reply_markup=kbi.profile_bybit
-                )
             else:
-                await callback_query.message.edit_text(text="Нет активной торговли")
+                await callback_query.message.edit_text(text=f"Нет активной торговли для {symbol}", reply_markup=kbi.profile_bybit)
 
         task = asyncio.create_task(delay_start())
         await add_stop_task(user_id=callback_query.from_user.id, task=task)

app/telegram/keyboards/inline.py

@@ -36,6 +36,7 @@ main_menu = InlineKeyboardMarkup(
             )
         ],
         [InlineKeyboardButton(text="Начать торговлю", callback_data="start_trading")],
+        [InlineKeyboardButton(text="Остановить торговлю", callback_data="stop_trading")],
     ]
 )
 
@@ -93,7 +94,10 @@ def get_additional_settings_keyboard(mode: str
 
     if mode == "Switch":
         buttons.append(
-            [InlineKeyboardButton(text="Направление первой сделки", callback_data="switch_side_start")]
+            [InlineKeyboardButton(text="Направление первой сделки первой серии", callback_data="switch_side_start")]
+        )
+        buttons.append(
+            [InlineKeyboardButton(text="Направление первой сделки последующих серии", callback_data="switch_side_second")]
         )
 
     buttons.append(
@@ -147,6 +151,19 @@ switch_side = InlineKeyboardMarkup(
     ]
 )
 
+side_for_switch = InlineKeyboardMarkup(
+    inline_keyboard=[
+        [
+            InlineKeyboardButton(text="Лонг", callback_data="buy_switch"),
+            InlineKeyboardButton(text="Шорт", callback_data="sell_switch"),
+        ],
+        [
+            InlineKeyboardButton(text="Назад", callback_data="additional_settings"),
+            InlineKeyboardButton(text="На главную", callback_data="profile_bybit"),
+        ],
+    ]
+)
+
 margin_type = InlineKeyboardMarkup(
     inline_keyboard=[
         [

config.py

@@ -6,5 +6,3 @@ if env_path:
     load_dotenv(env_path)
 
 BOT_TOKEN = os.getenv("BOT_TOKEN")
-
-DATABASE_URL = f"sqlite+aiosqlite:///database/data/sqlite.db"

database/__init__.py

@@ -1,14 +1,19 @@
-from database.models import Base
+from database.models import Base, User, UserAdditionalSettings, UserApi, UserConditionalSettings, UserDeals, \
+    UserRiskManagement, UserSymbol
 import logging.config
 from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
 from sqlalchemy import event
-from config import DATABASE_URL
+from pathlib import Path
-
 from logger_helper.logger_helper import LOGGING_CONFIG
 
 logging.config.dictConfig(LOGGING_CONFIG)
 logger = logging.getLogger("database")
 
+BASE_DIR = Path(__file__).parent.resolve()
+DATA_DIR = BASE_DIR / "db"
+DATA_DIR.mkdir(parents=True, exist_ok=True)
+
+DATABASE_URL = f"sqlite+aiosqlite:///{DATA_DIR / 'stcs.db'}"
 
 async_engine = create_async_engine(
     DATABASE_URL,
@@ -16,22 +21,25 @@ async_engine = create_async_engine(
     connect_args={"check_same_thread": False}
 )
 
+
 @event.listens_for(async_engine.sync_engine, "connect")
 def _enable_foreign_keys(dbapi_connection, connection_record):
     cursor = dbapi_connection.cursor()
     cursor.execute("PRAGMA foreign_keys=ON")
     cursor.close()
 
+
 async_session = async_sessionmaker(
     async_engine,
     class_=AsyncSession,
     expire_on_commit=False
 )
 
+
 async def init_db():
     try:
         async with async_engine.begin() as conn:
             await conn.run_sync(Base.metadata.create_all)
         logger.info("Database initialized.")
     except Exception as e:
-        logger.error("Database initialization failed: %s", e, exc_info=True)
+        logger.error("Database initialization failed: %s", e)

database/models.py

@@ -92,6 +92,7 @@ class UserAdditionalSettings(Base):
                      nullable=False, unique=True)
     trade_mode = Column(String, nullable=False, default="Merged_Single")
     switch_side = Column(String, nullable=False, default="По направлению")
+    side = Column(String, nullable=False, default="Buy")
     trigger_price = Column(Float, nullable=False, default=0.0)
     margin_type = Column(String, nullable=False, default="ISOLATED_MARGIN")
     leverage = Column(String, nullable=False, default="10")
@@ -143,6 +144,7 @@ class UserDeals(Base):
     current_step = Column(Integer, nullable=True)
     symbol = Column(String, nullable=True)
     trade_mode = Column(String, nullable=True)
+    side_mode = Column(String, nullable=True)
     base_quantity = Column(Float, nullable=True)
     margin_type = Column(String, nullable=True)
     leverage = Column(String, nullable=True)

database/request.py

@@ -358,6 +358,45 @@ async def set_switch_side(tg_id: int, switch_side: str) -> bool:
         return False
 
 
+async def set_side(tg_id: int, side: str) -> bool:
+    """
+    Set side for a user in the database.
+    :param tg_id: Telegram user ID
+    :param side: "BUY" or "SELL"
+    :return: True if successful, False otherwise
+    """
+    try:
+        async with async_session() as session:
+            result = await session.execute(
+                select(User)
+                .options(joinedload(User.user_additional_settings))
+                .filter_by(tg_id=tg_id)
+            )
+            user = result.scalars().first()
+
+            if user:
+                if user.user_additional_settings:
+                    # Updating existing record
+                    user.user_additional_settings.side = side
+                else:
+                    # Creating new record
+                    user_additional_settings = UserAdditionalSettings(
+                        side=side,
+                        user=user,
+                    )
+                    session.add(user_additional_settings)
+
+                await session.commit()
+                logger.info("User side updated for user: %s", tg_id)
+                return True
+            else:
+                logger.error("User not found with tg_id: %s", tg_id)
+                return False
+    except Exception as e:
+        logger.error("Error adding/updating user side for user %s: %s", tg_id, e)
+        return False
+
+
 async def set_leverage(tg_id: int, leverage: str) -> bool:
     """
     Set leverage for a user in the database.
@@ -895,9 +934,9 @@ async def set_stop_timer(tg_id: int, timer_end: int) -> bool:
 async def set_user_deal(
         tg_id: int,
         symbol: str,
-        last_side: str,
         current_step: int,
         trade_mode: str,
+        side_mode: str,
         margin_type: str,
         leverage: str,
         order_quantity: float,
@@ -912,9 +951,9 @@ async def set_user_deal(
     Set the user deal in the database.
     :param tg_id: Telegram user ID
     :param symbol: Symbol
-    :param last_side: Last side
     :param current_step: Current step
     :param trade_mode: Trade mode
+    :param side_mode: Side mode
     :param margin_type: Margin type
     :param leverage: Leverage
     :param order_quantity: Order quantity
@@ -941,9 +980,9 @@ async def set_user_deal(
 
             if deal:
                 # Updating existing record
-                deal.last_side = last_side
                 deal.current_step = current_step
                 deal.trade_mode = trade_mode
+                deal.side_mode = side_mode
                 deal.margin_type = margin_type
                 deal.leverage = leverage
                 deal.order_quantity = order_quantity
@@ -958,9 +997,9 @@ async def set_user_deal(
                 new_deal = UserDeals(
                     user=user,
                     symbol=symbol,
-                    last_side=last_side,
                     current_step=current_step,
                     trade_mode=trade_mode,
+                    side_mode=side_mode,
                     margin_type=margin_type,
                     leverage=leverage,
                     order_quantity=order_quantity,
@@ -1050,6 +1089,34 @@ async def set_fee_user_deal_by_symbol(tg_id: int, symbol: str, fee: float):
         return False
 
 
+async def set_last_side_by_symbol(tg_id: int, symbol: str, last_side: str):
+    """Set last side 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.last_side = last_side
+            else:
+                logger.error(f"User deal with user_id={user.id} and symbol={symbol} not found")
+                return False
+            await session.commit()
+            logger.info("Set last side for user %s and symbol %s", tg_id, symbol)
+            return True
+    except Exception as e:
+        logger.error("Error setting user deal last side 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):

run.py

@@ -5,10 +5,10 @@ import logging.config
 from aiogram import Bot, Dispatcher
 from aiogram.fsm.storage.redis import RedisStorage
 
+from database import init_db
 from app.bybit.web_socket import WebSocketBot
 from app.telegram.handlers import router
 from config import BOT_TOKEN
-from database import init_db
 from logger_helper.logger_helper import LOGGING_CONFIG
 
 logging.config.dictConfig(LOGGING_CONFIG)
@@ -46,7 +46,6 @@ async def main():
             with contextlib.suppress(asyncio.CancelledError):
                 await ws_task
                 await tg_task
-            await web_socket.clear_user_sockets()
 
     except Exception as e:
         logger.error("Bot stopped with error: %s", e)