404 lines
15 KiB
Python
404 lines
15 KiB
Python
import logging
|
|
from datetime import datetime, timedelta
|
|
from typing import Any
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
from app.telegram.database.models import async_session
|
|
from app.telegram.database.models import User_Telegram_Id as UTi
|
|
from app.telegram.database.models import User_Main_Settings as UMS
|
|
from app.telegram.database.models import User_Bybit_API as UBA
|
|
from app.telegram.database.models import User_Symbol
|
|
from app.telegram.database.models import User_Risk_Management_Settings as URMS
|
|
from app.telegram.database.models import User_Condition_Settings as UCS
|
|
from app.telegram.database.models import User_Additional_Settings as UAS
|
|
from app.telegram.database.models import Trading_Mode
|
|
from app.telegram.database.models import Margin_type
|
|
from app.telegram.database.models import Trigger
|
|
from app.telegram.database.models import USER_DEALS, UserTimer
|
|
|
|
import app.telegram.functions.functions as func # functions
|
|
|
|
from sqlalchemy import select, delete, update
|
|
|
|
# SET_DB
|
|
async def save_tg_id_new_user(tg_id):
|
|
async with async_session() as session:
|
|
user = await session.scalar(select(UTi).where(UTi.tg_id == tg_id))
|
|
|
|
if not user:
|
|
session.add(UTi(tg_id=tg_id))
|
|
|
|
logger.info("Новый пользователь был добавлен в бд")
|
|
|
|
await session.commit()
|
|
|
|
async def set_new_user_bybit_api(tg_id):
|
|
async with async_session() as session:
|
|
user = await session.scalar(select(UBA).where(UBA.tg_id == tg_id))
|
|
|
|
if not user:
|
|
session.add(UBA(
|
|
tg_id=tg_id,
|
|
))
|
|
|
|
logger.info(f"Bybit был успешно подключен")
|
|
|
|
await session.commit()
|
|
|
|
async def set_new_user_symbol(tg_id):
|
|
async with async_session() as session:
|
|
user = await session.scalar(select(User_Symbol).where(User_Symbol.tg_id == tg_id))
|
|
|
|
if not user:
|
|
session.add(User_Symbol(
|
|
tg_id=tg_id
|
|
))
|
|
|
|
logger.info(f"Symbol был успешно добавлен")
|
|
|
|
await session.commit()
|
|
|
|
async def set_new_user_default_main_settings(tg_id, trading_mode, margin_type) -> None:
|
|
async with async_session() as session:
|
|
settings = await session.scalar(select(UMS).where(UMS.tg_id == tg_id))
|
|
|
|
if not settings:
|
|
session.add(UMS(
|
|
tg_id=tg_id,
|
|
trading_mode=trading_mode,
|
|
margin_type=margin_type,
|
|
))
|
|
|
|
logger.info("Основные настройки нового пользователя были заполнены")
|
|
|
|
await session.commit()
|
|
|
|
async def set_new_user_default_risk_management_settings(tg_id) -> None:
|
|
async with async_session() as session:
|
|
settings = await session.scalar(select(URMS).where(URMS.tg_id == tg_id))
|
|
|
|
if not settings:
|
|
session.add(URMS(
|
|
tg_id=tg_id
|
|
))
|
|
|
|
logger.info("Риск-Менеджмент настройки нового пользователя были заполнены")
|
|
|
|
await session.commit()
|
|
|
|
async def set_new_user_default_condition_settings(tg_id, trigger) -> None:
|
|
async with async_session() as session:
|
|
settings = await session.scalar(select(UCS).where(UCS.tg_id == tg_id))
|
|
|
|
if not settings:
|
|
session.add(UCS(
|
|
tg_id=tg_id,
|
|
trigger=trigger
|
|
))
|
|
|
|
logger.info("Условные настройки нового пользователя были заполнены")
|
|
|
|
await session.commit()
|
|
|
|
async def set_new_user_default_additional_settings(tg_id) -> None:
|
|
async with async_session() as session:
|
|
settings = await session.scalar(select(UAS).where(UAS.tg_id == tg_id))
|
|
|
|
if not settings:
|
|
session.add(UAS(
|
|
tg_id=tg_id,
|
|
))
|
|
|
|
logger.info("Дополнительные настройки нового пользователя были заполнены")
|
|
|
|
await session.commit()
|
|
|
|
# GET_DB
|
|
async def check_user(tg_id):
|
|
async with async_session() as session:
|
|
user = await session.scalar(select(UTi).where(UTi.tg_id == tg_id))
|
|
return user
|
|
|
|
async def get_bybit_api_key(tg_id):
|
|
async with async_session() as session:
|
|
api_key = await session.scalar(select(UBA.api_key).where(UBA.tg_id == tg_id))
|
|
return api_key
|
|
|
|
async def get_bybit_secret_key(tg_id):
|
|
async with async_session() as session:
|
|
secret_key = await session.scalar(select(UBA.secret_key).where(UBA.tg_id == tg_id))
|
|
return secret_key
|
|
|
|
async def get_symbol(tg_id):
|
|
async with async_session() as session:
|
|
symbol = await session.scalar(select(User_Symbol.symbol).where(User_Symbol.tg_id == tg_id))
|
|
return symbol
|
|
|
|
async def get_user_trades(tg_id):
|
|
async with async_session() as session:
|
|
query = select(USER_DEALS.symbol, USER_DEALS.side).where(USER_DEALS.tg_id == tg_id)
|
|
result = await session.execute(query)
|
|
trades = result.all()
|
|
return trades
|
|
|
|
|
|
async def update_user_trades(tg_id, **kwargs):
|
|
async with async_session() as session:
|
|
query = update(USER_DEALS).where(USER_DEALS.tg_id == tg_id).values(**kwargs)
|
|
await session.execute(query)
|
|
await session.commit()
|
|
|
|
async def delete_user_trade(tg_id: int, symbol: str):
|
|
async with async_session() as session:
|
|
await session.execute(
|
|
USER_DEALS.__table__.delete().where(
|
|
(USER_DEALS.tg_id == tg_id) & (USER_DEALS.symbol == symbol)
|
|
)
|
|
)
|
|
await session.commit()
|
|
|
|
async def get_for_registration_trading_mode():
|
|
async with async_session() as session:
|
|
mode = await session.scalar(select(Trading_Mode.mode).where(Trading_Mode.id == 1))
|
|
return mode
|
|
|
|
async def get_for_registration_margin_type():
|
|
async with async_session() as session:
|
|
type = await session.scalar(select(Margin_type.type).where(Margin_type.id == 1))
|
|
return type
|
|
|
|
async def get_for_registration_trigger():
|
|
async with async_session() as session:
|
|
trigger = await session.scalar(select(Trigger.trigger).where(Trigger.id == 1))
|
|
return trigger
|
|
|
|
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("Получение основных настроек пользователя")
|
|
|
|
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))
|
|
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))
|
|
|
|
data = {
|
|
'trading_mode': trading_mode,
|
|
'margin_type': margin_mode,
|
|
'size_leverage': size_leverage,
|
|
'starting_quantity': starting_quantity,
|
|
'martingale_factor': martingale_factor,
|
|
'maximal_quantity': maximal_quantity
|
|
}
|
|
|
|
return data
|
|
|
|
async def get_user_risk_management_settings(tg_id):
|
|
async with async_session() as session:
|
|
user = await session.scalar(select(URMS).where(URMS.tg_id == tg_id))
|
|
|
|
if user:
|
|
logger.info("Получение риск-менеджмента настроек пользователя")
|
|
|
|
price_profit = await session.scalar(select(URMS.price_profit).where(URMS.tg_id == tg_id))
|
|
price_loss = await session.scalar(select(URMS.price_loss).where(URMS.tg_id == tg_id))
|
|
max_risk_deal = await session.scalar(select(URMS.max_risk_deal).where(URMS.tg_id == tg_id))
|
|
commission_fee = await session.scalar(select(URMS.commission_fee).where(URMS.tg_id == tg_id))
|
|
|
|
data = {
|
|
'price_profit': price_profit,
|
|
'price_loss': price_loss,
|
|
'max_risk_deal': max_risk_deal,
|
|
'commission_fee': commission_fee,
|
|
}
|
|
|
|
return data
|
|
|
|
#UPDATE_SYMBOL
|
|
async def update_symbol(tg_id, symbol) -> None:
|
|
async with async_session() as session:
|
|
await session.execute(update(User_Symbol).where(User_Symbol.tg_id == tg_id).values(symbol = symbol))
|
|
|
|
await session.commit()
|
|
|
|
async def update_api_key(tg_id, api):
|
|
async with async_session() as session:
|
|
api_key = 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, api):
|
|
async with async_session() as session:
|
|
secret_key = await session.execute(update(UBA).where(UBA.tg_id == tg_id).values(secret_key = api))
|
|
|
|
await session.commit()
|
|
|
|
# UPDATE_MAIN_SETTINGS_DB
|
|
async def update_trade_mode_user(tg_id, trading_mode) -> None:
|
|
async with async_session() as session:
|
|
mode = await session.scalar(select(Trading_Mode.mode).where(Trading_Mode.mode == trading_mode))
|
|
|
|
if mode:
|
|
logger.info("Изменен трейд мод")
|
|
await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(trading_mode = mode))
|
|
|
|
await session.commit()
|
|
|
|
async def update_margin_type(tg_id, margin_type) -> None:
|
|
async with async_session() as session:
|
|
type = await session.scalar(select(Margin_type.type).where(Margin_type.type == margin_type))
|
|
|
|
if type:
|
|
logger.info("Изменен тип маржи")
|
|
await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(margin_type = type))
|
|
|
|
await session.commit()
|
|
|
|
async def update_size_leverange(tg_id, num):
|
|
async with async_session() as session:
|
|
await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(size_leverage = num))
|
|
|
|
await session.commit()
|
|
|
|
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_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))
|
|
|
|
await session.commit()
|
|
|
|
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))
|
|
|
|
await session.commit()
|
|
|
|
# UPDATE_RISK_MANAGEMENT_SETTINGS_DB
|
|
|
|
async def update_price_profit(tg_id, num):
|
|
async with async_session() as session:
|
|
await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(price_profit = num))
|
|
|
|
await session.commit()
|
|
|
|
async def update_price_loss(tg_id, num):
|
|
async with async_session() as session:
|
|
await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(price_loss = num))
|
|
|
|
await session.commit()
|
|
|
|
async def update_max_risk_deal(tg_id, num):
|
|
async with async_session() as session:
|
|
await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(max_risk_deal = num))
|
|
|
|
await session.commit()
|
|
|
|
|
|
async def update_entry_order_type(tg_id, order_type):
|
|
async with async_session() as session:
|
|
await session.execute(
|
|
update(UMS)
|
|
.where(UMS.tg_id == tg_id)
|
|
.values(entry_order_type=order_type)
|
|
)
|
|
await session.commit()
|
|
|
|
|
|
async def get_entry_order_type(tg_id: object) -> str | None | Any:
|
|
async with async_session() as session:
|
|
order_type = await session.scalar(
|
|
select(UMS.entry_order_type).where(UMS.tg_id == tg_id)
|
|
)
|
|
# Если в базе не установлен тип — возвращаем значение по умолчанию
|
|
return order_type or 'Market'
|
|
|
|
|
|
async def update_commission_fee(tg_id, num):
|
|
async with async_session() as session:
|
|
await session.execute(update(URMS).where(URMS.tg_id == tg_id).values(commission_fee = num))
|
|
|
|
await session.commit()
|
|
|
|
async def get_user_timer(tg_id):
|
|
async with async_session() as session:
|
|
result = await session.execute(select(UserTimer).where(UserTimer.tg_id == tg_id))
|
|
user_timer = result.scalars().first()
|
|
|
|
if not user_timer:
|
|
logging.info(f"No timer found for user {tg_id}")
|
|
return None
|
|
|
|
timer_minutes = user_timer.timer_minutes
|
|
timer_start = user_timer.timer_start
|
|
timer_end = user_timer.timer_end
|
|
|
|
logging.info(f"Timer data for tg_id={tg_id}: "
|
|
f"timer_minutes={timer_minutes}, "
|
|
f"timer_start={timer_start}, "
|
|
f"timer_end={timer_end}")
|
|
|
|
remaining = None
|
|
if timer_end:
|
|
remaining = max(0, int((timer_end - datetime.utcnow()).total_seconds() // 60))
|
|
|
|
return {
|
|
"timer_minutes": timer_minutes,
|
|
"timer_start": timer_start,
|
|
"timer_end": timer_end,
|
|
"remaining_minutes": remaining
|
|
}
|
|
|
|
|
|
async def update_user_timer(tg_id, minutes: int):
|
|
async with async_session() as session:
|
|
try:
|
|
async with async_session() as session:
|
|
timer_start = None
|
|
timer_end = None
|
|
|
|
if minutes > 0:
|
|
timer_start = datetime.utcnow()
|
|
timer_end = timer_start + timedelta(minutes=minutes)
|
|
|
|
result = await session.execute(select(UserTimer).where(UserTimer.tg_id == tg_id))
|
|
user_timer = result.scalars().first()
|
|
|
|
if user_timer:
|
|
user_timer.timer_minutes = minutes
|
|
user_timer.timer_start = timer_start
|
|
user_timer.timer_end = timer_end
|
|
else:
|
|
user_timer = UserTimer(
|
|
tg_id=tg_id,
|
|
timer_minutes=minutes,
|
|
timer_start=timer_start,
|
|
timer_end=timer_end
|
|
)
|
|
session.add(user_timer)
|
|
|
|
await session.commit()
|
|
except Exception as e:
|
|
logging.error(f"Ошибка обновления таймера пользователя {tg_id}: {e}")
|
|
|
|
|
|
async def get_martingale_step(tg_id):
|
|
async with async_session() as session:
|
|
result = await session.execute(select(UMS).where(UMS.tg_id == tg_id))
|
|
user_settings = result.scalars().first()
|
|
return user_settings.martingale_step
|
|
|
|
async def update_martingale_step(tg_id, step):
|
|
async with async_session() as session:
|
|
await session.execute(update(UMS).where(UMS.tg_id == tg_id).values(martingale_step = step))
|
|
|
|
await session.commit() |