Alex/stcs
2
0
Fork 0
forked from kodorvan/stcs
Code Pull Requests Activity

Fixed

Browse Source
This commit is contained in:
algizn97
2025-09-09 10:24:01 +05:00
parent 058ba09c03
commit cf581dc485
11 changed files with 670 additions and 428 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
app/telegram/database/models.py
View File

@@ -54,10 +54,10 @@ class User_Bybit_API(Base):
id: Mapped[int] = mapped_column(primary_key=True)
tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))
tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"), unique=True, nullable=True)
api_key = mapped_column(String(18), default='None')
secret_key = mapped_column(String(36), default='None')
api_key = mapped_column(String(18), unique=True, nullable=True)
secret_key = mapped_column(String(36), unique=True, nullable=True)
class User_Symbol(Base):
@@ -65,25 +65,12 @@ class User_Symbol(Base):
Модель таблицы user_main_settings.
Хранит основные настройки торговли для пользователя.
Атрибуты:
id (int): Внутренний первичный ключ записи.
tg_id (int): Внешний ключ на Telegram пользователя.
trading_mode (str): Режим торговли (ForeignKey на trading_modes.mode).
margin_type (str): Тип маржи (ForeignKey на margin_types.type).
size_leverage (int): Кредитное плечо.
starting_quantity (int): Начальный объём позиции.
martingale_factor (int): Коэффициент мартингейла.
martingale_step (int): Текущий шаг мартингейла.
maximal_quantity (int): Максимальное количество шагов мартингейла.
entry_order_type (str): Тип входа (Market или Limit).
limit_order_price (str, optional): Цена лимитного ордера, если используется.
"""
__tablename__ = 'user_symbols'
id: Mapped[int] = mapped_column(primary_key=True)
tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))
tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"), unique=True, nullable=True)
symbol = mapped_column(String(18), default='PENGUUSDT')
@@ -94,7 +81,7 @@ class Trading_Mode(Base):
Атрибуты:
id (int): Первичный ключ.
mode (str): Уникальный режим (например, 'Long', 'Short').
mode (str): Уникальный режим (например, 'Long', 'Short', 'Switch).
"""
__tablename__ = 'trading_modes'
@@ -123,7 +110,7 @@ class Trigger(Base):
Справочник триггеров для сделок.
Атрибуты:
id (int): Первичный ключ..
id (int): Первичный ключ.
"""
__tablename__ = 'triggers'
@@ -148,17 +135,17 @@ class User_Main_Settings(Base):
maximal_quantity (int): Максимальное число шагов мартингейла.
entry_order_type (str): Тип ордера входа (Market/Limit).
limit_order_price (Optional[str]): Цена лимитного ордера, если есть.
last_side (str): Последняя сторона ордера.
"""
__tablename__ = 'user_main_settings'
id: Mapped[int] = mapped_column(primary_key=True)
tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))
tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"), unique=True, nullable=True)
trading_mode = mapped_column(ForeignKey("trading_modes.mode"))
margin_type = mapped_column(ForeignKey("margin_types.type"))
switch_mode_enabled = mapped_column(String(15), default="Выключен")
switch_state = mapped_column(String(10), default='Long')
switch_state = mapped_column(String(10), default='По направлению')
size_leverage = mapped_column(Integer(), default=1)
starting_quantity = mapped_column(Integer(), default=1)
martingale_factor = mapped_column(Integer(), default=1)
@@ -166,6 +153,7 @@ class User_Main_Settings(Base):
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)
last_side = mapped_column(String(10), default='Buy')
class User_Risk_Management_Settings(Base):
@@ -184,7 +172,7 @@ class User_Risk_Management_Settings(Base):
id: Mapped[int] = mapped_column(primary_key=True)
tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))
tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"), unique=True, nullable=True)
price_profit = mapped_column(Integer(), default=1)
price_loss = mapped_column(Integer(), default=1)
@@ -211,9 +199,9 @@ class User_Condition_Settings(Base):
id: Mapped[int] = mapped_column(primary_key=True)
tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))
tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"), unique=True, nullable=True)
trigger = mapped_column(String(15), default='Ручной')
trigger = mapped_column(String(15), default='Автоматический')
filter_time = mapped_column(String(25), default='???')
filter_volatility = mapped_column(Boolean, default=False)
external_cues = mapped_column(Boolean, default=False)
@@ -237,7 +225,7 @@ class User_Additional_Settings(Base):
id: Mapped[int] = mapped_column(primary_key=True)
tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))
tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"), unique=True, nullable=True)
pattern_save = mapped_column(Boolean, default=False)
autostart = mapped_column(Boolean, default=False)
@@ -260,7 +248,7 @@ class USER_DEALS(Base):
id: Mapped[int] = mapped_column(primary_key=True)
tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))
tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"), unique=True, nullable=True)
symbol = mapped_column(String(18), default='PENGUUSDT')
side = mapped_column(String(10), nullable=False)
@@ -282,7 +270,7 @@ class UserTimer(Base):
__tablename__ = 'user_timers'
id: Mapped[int] = mapped_column(primary_key=True)
tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))
tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"), unique=True, nullable=True)
timer_minutes = mapped_column(Integer, nullable=False, default=0)
timer_start = mapped_column(DateTime, default=datetime.utcnow)
timer_end = mapped_column(DateTime, nullable=True)
@@ -296,7 +284,7 @@ async def async_main():
await conn.run_sync(Base.metadata.create_all)
# Заполнение таблиц
modes = ['Long', 'Short', 'Smart']
modes = ['Long', 'Short', 'Switch', 'Smart']
for mode in modes:
result = await conn.execute(select(Trading_Mode).where(Trading_Mode.mode == mode))
if not result.first():
@@ -309,3 +297,10 @@ async def async_main():
if not result.first():
logger.info("Заполение таблицы типов маржи")
await conn.execute(Margin_type.__table__.insert().values(type=type))
last_side = ['Buy', 'Sell']
for side in last_side:
result = await conn.execute(select(User_Main_Settings).where(User_Main_Settings.last_side == side))
if not result.first():
logger.info("Заполение таблицы последнего направления")
await conn.execute(User_Main_Settings.__table__.insert().values(last_side=side))

79
app/telegram/database/requests.py
View File

@@ -239,17 +239,21 @@ async def update_symbol(tg_id: int, symbol: str) -> None:
await session.commit()
async def update_api_key(tg_id: int, api: str) -> None:
async def upsert_api_keys(tg_id: int, api_key: str, secret_key: str) -> None:
"""Обновить API ключ пользователя."""
async with async_session() as session:
await session.execute(update(UBA).where(UBA.tg_id == tg_id).values(api_key=api))
await session.commit()
async def update_secret_key(tg_id: int, api: str) -> None:
"""Обновить секретный ключ пользователя."""
async with async_session() as session:
await session.execute(update(UBA).where(UBA.tg_id == tg_id).values(secret_key=api))
result = await session.execute(select(UBA).where(UBA.tg_id == tg_id))
user = result.scalars().first()
if user:
if api_key is not None:
user.api_key = api_key
if secret_key is not None:
user.secret_key = secret_key
logger.info(f"Обновлены ключи для пользователя {tg_id}")
else:
new_user = UBA(tg_id=tg_id, api_key=api_key, secret_key=secret_key)
session.add(new_user)
logger.info(f"Добавлен новый пользователь {tg_id} с ключами")
await session.commit()
@@ -303,36 +307,20 @@ async def get_user_main_settings(tg_id):
"""Получить основные настройки пользователя."""
async with async_session() as session:
user = await session.scalar(select(UMS).where(UMS.tg_id == tg_id))
if user:
logger.info("Получение основных настроек пользователя %s", tg_id)
trading_mode = await session.scalar(select(UMS.trading_mode).where(UMS.tg_id == tg_id))
margin_mode = await session.scalar(select(UMS.margin_type).where(UMS.tg_id == tg_id))
switch_mode_enabled = await session.scalar(select(UMS.switch_mode_enabled).where(UMS.tg_id == tg_id))
switch_state = await session.scalar(select(UMS.switch_state).where(UMS.tg_id == tg_id))
size_leverage = await session.scalar(select(UMS.size_leverage).where(UMS.tg_id == tg_id))
starting_quantity = await session.scalar(select(UMS.starting_quantity).where(UMS.tg_id == tg_id))
martingale_factor = await session.scalar(select(UMS.martingale_factor).where(UMS.tg_id == tg_id))
maximal_quantity = await session.scalar(select(UMS.maximal_quantity).where(UMS.tg_id == tg_id))
entry_order_type = await session.scalar(select(UMS.entry_order_type).where(UMS.tg_id == tg_id))
limit_order_price = await session.scalar(select(UMS.limit_order_price).where(UMS.tg_id == tg_id))
martingale_step = await session.scalar(select(UMS.martingale_step).where(UMS.tg_id == tg_id))
data = {
'trading_mode': trading_mode,
'margin_type': margin_mode,
'switch_mode_enabled': switch_mode_enabled,
'switch_state': switch_state,
'size_leverage': size_leverage,
'starting_quantity': starting_quantity,
'martingale_factor': martingale_factor,
'maximal_quantity': maximal_quantity,
'entry_order_type': entry_order_type,
'limit_order_price': limit_order_price,
'martingale_step': martingale_step,
'trading_mode': user.trading_mode,
'margin_type': user.margin_type,
'switch_state': user.switch_state,
'size_leverage': user.size_leverage,
'starting_quantity': user.starting_quantity,
'martingale_factor': user.martingale_factor,
'maximal_quantity': user.maximal_quantity,
'entry_order_type': user.entry_order_type,
'limit_order_price': user.limit_order_price,
'martingale_step': user.martingale_step,
'last_side': user.last_side,
}
return data
@@ -575,4 +563,23 @@ async def update_trigger(tg_id, trigger):
async with async_session() as session:
await session.execute(update(UCS).where(UCS.tg_id == tg_id).values(trigger=trigger))
await session.commit()
async def set_last_series_info(tg_id: int, last_side: str):
async with async_session() as session:
async with session.begin():
# Обновляем запись
result = await session.execute(
update(UMS)
.where(UMS.tg_id == tg_id)
.values(last_side=last_side)
)
if result.rowcount == 0:
# Если запись не существует, создаём новую
new_entry = UMS(
tg_id=tg_id,
last_side=last_side,
)
session.add(new_entry)
await session.commit()