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

Update

Browse Source
This commit is contained in:
algizn97
2025-08-23 14:34:19 +05:00
parent afe61ea7d6
commit 89ea511072
6 changed files with 238 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
app/services/Bybit/functions/Futures.py
View File

@@ -1,13 +1,15 @@
import asyncio
import time
import logging
import logging.config
from pybit import exceptions
from pybit.unified_trading import HTTP
from logger_helper.logger_helper import LOGGING_CONFIG
import app.services.Bybit.functions.price_symbol as price_symbol
import app.services.Bybit.functions.balance as balance_g
import app.telegram.database.requests as rq
logging.config.dictConfig(LOGGING_CONFIG)
logger = logging.getLogger("futures")
async def info_access_open_deal(message, symbol, trade_mode, margin_mode, leverage, qty):
human_margin_mode = 'Isolated' if margin_mode == 'ISOLATED_MARGIN' else 'Cross'
@@ -44,6 +46,10 @@ async def open_position(tg_id, message, side: str, margin_mode: str):
symbol = await rq.get_symbol(tg_id)
data_main_stgs = await rq.get_user_main_settings(tg_id)
order_type = data_main_stgs.get('entry_order_type', 'Market')
limit_price = None
if order_type == 'Limit':
limit_price = await rq.get_limit_price(tg_id)
data_risk_stgs = await rq.get_user_risk_management_settings(tg_id)
bybit_margin_mode = 'ISOLATED_MARGIN' if margin_mode == 'Isolated' else 'REGULAR_MARGIN'
@@ -51,8 +57,8 @@ async def open_position(tg_id, message, side: str, margin_mode: str):
client = HTTP(api_key=api_key, api_secret=secret_key)
try:
balance = await balance_g.get_balance(tg_id)
price = await price_symbol.get_price(tg_id, message)
balance = await balance_g.get_balance(tg_id, message)
price = await price_symbol.get_price(tg_id)
# Установка маржинального режима
client.set_margin_mode(setMarginMode=bybit_margin_mode)
@@ -109,9 +115,10 @@ async def open_position(tg_id, message, side: str, margin_mode: str):
category='linear',
symbol=symbol,
side=side,
orderType="Market",
orderType=order_type,
qty=next_quantity,
leverage=int(data_main_stgs['size_leverage']),
price=limit_price if order_type == 'Limit' else None,
takeProfit=takeProfit,
stopLoss=loss_profit,
orderLinkId=f"deal_{symbol}_{int(time.time())}"
@@ -125,11 +132,11 @@ async def open_position(tg_id, message, side: str, margin_mode: str):
await message.answer(f"Ошибка открытия ордера: {response.get('ret_msg', 'неизвестная ошибка')}")
except exceptions.InvalidRequestError as e:
logging.error(f"InvalidRequestError: {e}")
logger.error(f"InvalidRequestError: {e}")
await message.answer('Ошибка: неверно указана торговая пара или параметры.')
except Exception as e:
logging.error(f"Ошибка при совершении сделки: {e}")
await message.answer('⚠️ Ошибка при совершении сделки')
logger.error(f"Ошибка при совершении сделки: {e}")
async def trading_cycle(tg_id, message):
@@ -179,7 +186,7 @@ async def get_active_positions(message, api_key, secret_key, symbol):
if pos.get('size') and float(pos['size']) > 0:
active_positions.append(pos)
except Exception as e:
logging.error(f"Ошибка при получении позиций: {e}")
logger.error(f"Ошибка при получении позиций: {e}")
await message.answer('⚠️ Ошибка при получении позиций')
for sym in symbols:
@@ -228,7 +235,7 @@ async def close_user_trade(tg_id: int, symbol: str) -> bool:
)
return response['ret_code'] == 0
except Exception as e:
logging.error(f"Ошибка закрытия сделки {symbol} для пользователя {tg_id}: {e}")
logger.error(f"Ошибка закрытия сделки {symbol} для пользователя {tg_id}: {e}")
return False

87
app/services/Bybit/functions/functions.py
View File

@@ -1,8 +1,8 @@
import asyncio
import logging.config
from aiogram import F, Router
from app.services.Bybit.functions import Futures, func_min_qty
from logger_helper.logger_helper import LOGGING_CONFIG
from app.services.Bybit.functions import Futures, min_qty
from app.services.Bybit.functions.Futures import open_position, close_user_trade, get_active_positions, trading_cycle
from app.services.Bybit.functions.balance import get_balance
import app.telegram.Keyboards.inline_keyboards as inline_markup
@@ -15,6 +15,11 @@ from aiogram.types import Message, CallbackQuery
from aiogram.fsm.state import State, StatesGroup
from aiogram.fsm.context import FSMContext
from app.services.Bybit.functions.get_valid_symbol import get_valid_symbols
logging.config.dictConfig(LOGGING_CONFIG)
logger = logging.getLogger("functions")
router_functions_bybit_trade = Router()
@@ -30,6 +35,10 @@ class TradeSetup(StatesGroup):
waiting_for_timer = State()
waiting_for_positive_percent = State()
class state_limit_price(StatesGroup):
price = State()
@router_functions_bybit_trade.callback_query(F.data.in_(['clb_start_trading', 'clb_back_to_main', 'back_to_main']))
async def clb_start_bybit_trade_message(callback: CallbackQuery, state: FSMContext):
@@ -48,7 +57,8 @@ async def clb_start_bybit_trade_message(callback: CallbackQuery, state: FSMConte
Как начать торговлю?
1️⃣ Проверьте и тщательно настройте все параметры в вашем профиле.
2️⃣ Нажмите ниже кнопку 'Указать торговую пару' и введите торговую пару заглавными буквами, без лишних символов (например: BTCUSDT).
2️⃣ Нажмите ниже кнопку 'Указать торговую пару' и введите торговую пару, без лишних символов (например: BTCUSDT).
3️⃣ Нажмите кнопку 'Выбрать тип входа' и после нажмите начать торговлю.
'''
await callback.message.edit_text(text=text, parse_mode='html', reply_markup=inline_markup.trading_markup)
@@ -69,7 +79,8 @@ async def start_bybit_trade_message(message, state):
Как начать торговлю?
1️⃣ Проверьте и тщательно настройте все параметры в вашем профиле.
2️⃣ Нажмите ниже кнопку 'Указать торговую пару' и введите торговую пару заглавными буквами, без лишних символов (например: BTCUSDT).
2️⃣ Нажмите ниже кнопку 'Указать торговую пару' и введите торговую пару, без лишних символов (например: BTCUSDT).
3️⃣ Нажмите кнопку 'Выбрать тип входа' и после нажмите начать торговлю.
'''
await message.answer(text=text, parse_mode='html', reply_markup=inline_markup.trading_markup)
@@ -80,17 +91,23 @@ async def update_symbol_for_trade_message(callback: CallbackQuery, state: FSMCon
await state.set_state(state_update_symbol.symbol)
await callback.message.answer(
text='Укажите торговую пару заглавными буквами без пробелов и лишних символов (пример: BTCUSDT): ')
text='Укажите торговую пару заглавными буквами без пробелов и лишних символов (пример: BTCUSDT): ',
reply_markup=inline_markup.cancel)
@router_functions_bybit_trade.message(state_update_symbol.symbol)
async def update_symbol_for_trade(message: Message, state: FSMContext):
user_input = message.text.strip().upper()
exists = await get_valid_symbols(message.from_user.id, user_input)
if not exists:
await message.answer("Введена некорректная торговая пара или такой пары нет в списке. Попробуйте снова.")
return
await state.update_data(symbol=message.text)
data = await state.get_data()
await message.answer('Пара была успешно обновлена')
await rq.update_symbol(message.from_user.id, data['symbol'])
await rq.update_symbol(message.from_user.id, user_input)
await start_bybit_trade_message(message, state)
await state.clear()
@@ -111,15 +128,47 @@ async def entry_order_type_callback(callback: CallbackQuery, state: FSMContext):
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.answer("Тип входа в позицию был успешно обновлен")
await callback.message.answer(f"Выбран тип входа в позицию: {order_type}",
reply_markup=inline_markup.start_trading_markup)
await callback.answer()
except Exception as e:
await callback.message.answer("Произошла ошибка при обновлении типа входа в позицию")
logger.error(f"Произошла ошибка при обновлении типа входа в позицию: {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):
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)
data = await state.get_data()
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_my_deals")
async def show_my_trades_callback(callback: CallbackQuery):
tg_id = callback.from_user.id
@@ -227,7 +276,8 @@ async def start_trading_process(callback: CallbackQuery, state: FSMContext):
try:
positions_resp = client.get_positions(category='linear', symbol=symbol)
positions = positions_resp.get('result', {}).get('list', [])
except Exception:
except Exception as e:
logger.error(f"Ошибка при получении позиций: {e}")
positions = []
for pos in positions:
@@ -253,7 +303,10 @@ async def start_trading_process(callback: CallbackQuery, state: FSMContext):
await message.answer("Начинаю торговлю с использованием текущих настроек...")
# Открываем позицию (вызывает Futures.open_position)
await open_position(tg_id, message, side=side, margin_mode=margin_mode)
success = await open_position(tg_id, message, side=side, margin_mode=margin_mode)
if not success:
await message.answer('⚠️ Ошибка при совершении сделки', reply_markup=inline_markup.back_to_main)
return
# Проверяем таймер и информируем пользователя
@@ -271,3 +324,9 @@ async def start_trading_process(callback: CallbackQuery, state: FSMContext):
await callback.answer()
@router_functions_bybit_trade.callback_query(F.data == "clb_cancel")
async def cancel(callback: CallbackQuery, state: FSMContext):
await state.clear()
await callback.message.answer("Отменено!", reply_markup=inline_markup.back_to_main)
await callback.answer()

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

@@ -80,6 +80,7 @@ class User_Main_Settings(Base):
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(String(20), nullable=True)
class User_Risk_Management_Settings(Base):

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

@@ -1,8 +1,10 @@
import logging
import logging.config
from logger_helper.logger_helper import LOGGING_CONFIG
from datetime import datetime, timedelta
from typing import Any
logger = logging.getLogger(__name__)
logging.config.dictConfig(LOGGING_CONFIG)
logger = logging.getLogger("requests")
from app.telegram.database.models import async_session
from app.telegram.database.models import User_Telegram_Id as UTi
@@ -10,17 +12,18 @@ 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 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
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:
@@ -29,10 +32,11 @@ async def save_tg_id_new_user(tg_id):
if not user:
session.add(UTi(tg_id=tg_id))
logger.info("Новый пользователь был добавлен в бд")
logger.info("Новый пользователь был добавлен в бд %s", tg_id)
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))
@@ -42,23 +46,23 @@ async def set_new_user_bybit_api(tg_id):
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
tg_id=tg_id
))
logger.info(f"Symbol был успешно добавлен")
logger.info(f"Symbol был успешно добавлен %s", tg_id)
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))
@@ -67,13 +71,14 @@ async def set_new_user_default_main_settings(tg_id, trading_mode, margin_type) -
session.add(UMS(
tg_id=tg_id,
trading_mode=trading_mode,
margin_type=margin_type,
margin_type=margin_type,
))
logger.info("Основные настройки нового пользователя были заполнены")
logger.info("Основные настройки нового пользователя были заполнены%s", tg_id)
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))
@@ -83,10 +88,11 @@ async def set_new_user_default_risk_management_settings(tg_id) -> None:
tg_id=tg_id
))
logger.info("Риск-Менеджмент настройки нового пользователя были заполнены")
logger.info("Риск-Менеджмент настройки нового пользователя были заполнены %s", tg_id)
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))
@@ -94,13 +100,14 @@ async def set_new_user_default_condition_settings(tg_id, trigger) -> None:
if not settings:
session.add(UCS(
tg_id=tg_id,
trigger=trigger
trigger=trigger
))
logger.info("Условные настройки нового пользователя были заполнены")
logger.info("Условные настройки нового пользователя были заполнены %s", tg_id)
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))
@@ -110,30 +117,35 @@ async def set_new_user_default_additional_settings(tg_id) -> None:
tg_id=tg_id,
))
logger.info("Дополнительные настройки нового пользователя были заполнены")
logger.info("Дополнительные настройки нового пользователя были заполнены %s", tg_id)
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
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
return symbol
async def get_user_trades(tg_id):
async with async_session() as session:
@@ -149,6 +161,7 @@ async def update_user_trades(tg_id, **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(
@@ -158,34 +171,38 @@ async def delete_user_trade(tg_id: int, symbol: str):
)
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))
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))
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,
@@ -198,12 +215,13 @@ async def get_user_main_settings(tg_id):
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("Получение риск-менеджмента настроек пользователя")
logger.info("Получение риск-менеджмента настроек пользователя %s", tg_id)
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))
@@ -219,88 +237,100 @@ async def get_user_risk_management_settings(tg_id):
return data
#UPDATE_SYMBOL
# 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.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))
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))
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))
logger.info("Изменен трейд мод %s", tg_id)
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))
logger.info("Изменен тип маржи %s", tg_id)
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.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.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.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.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.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.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.execute(update(URMS).where(URMS.tg_id == tg_id).values(max_risk_deal=num))
await session.commit()
@@ -323,40 +353,66 @@ async def get_entry_order_type(tg_id: object) -> str | None | Any:
return order_type or 'Market'
async def get_limit_price(tg_id):
async with async_session() as session:
result = await session.execute(
select(UMS.limit_order_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 update_limit_price(tg_id, price):
async with async_session() as session:
await session.execute(
update(UMS)
.where(UMS.tg_id == tg_id)
.values(limit_order_price=str(price))
)
await session.commit()
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.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()
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
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
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}")
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))
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
}
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):
@@ -397,8 +453,9 @@ async def get_martingale_step(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.execute(update(UMS).where(UMS.tg_id == tg_id).values(martingale_step=step))
await session.commit()
await session.commit()

4
app/telegram/functions/functions.py
View File

@@ -27,6 +27,4 @@ async def check_profile_message(message, username):
await message.answer(f'С возвращением, {username}!', reply_markup=reply_markup.base_buttons_markup)
async def settings_message(message):
await message.edit_text("Выберите что настроить", reply_markup=inline_markup.special_settings_markup)
await message.edit_text("Выберите что настроить", reply_markup=inline_markup.special_settings_markup)

15
app/telegram/handlers/handlers.py
View File

@@ -1,4 +1,4 @@
import logging
import logging.config
from aiogram import F, Router
from aiogram.filters import CommandStart, Command
@@ -14,6 +14,11 @@ import app.telegram.functions.additional_settings.settings as func_additional_se
import app.telegram.database.requests as rq
import app.telegram.Keyboards.inline_keyboards as inline_markup
import app.telegram.Keyboards.reply_keyboards as reply_markup
from logger_helper.logger_helper import LOGGING_CONFIG
logging.config.dictConfig(LOGGING_CONFIG)
logger = logging.getLogger("handlers")
router = Router()
@@ -143,7 +148,7 @@ async def clb_main_settings_msg(callback: CallbackQuery, state: FSMContext):
case 'clb_change_maximum_quantity':
await func_main_settings.maximum_quantity_message(callback.message, state)
except Exception as e:
logging.error(f"Error callback in main_settings match-case: {e}")
logger.error(f"Error callback in main_settings match-case: {e}")
list_risk_management_settings = ['clb_change_price_profit',
@@ -168,7 +173,7 @@ async def clb_risk_management_settings_msg(callback: CallbackQuery, state: FSMCo
case 'commission_fee':
await func_rmanagement_settings.commission_fee_message(callback.message, state)
except Exception as e:
logging.error(f"Error callback in risk_management match-case: {e}")
logger.error(f"Error callback in risk_management match-case: {e}")
list_condition_settings = ['clb_change_trigger',
@@ -202,7 +207,7 @@ async def clb_condition_settings_msg(callback: CallbackQuery, state: FSMContext)
case 'clb_change_ai_analytics':
await func_condition_settings.ai_analytics_message(callback.message, state)
except Exception as e:
logging.error(f"Error callback in main_settings match-case: {e}")
logger.error(f"Error callback in main_settings match-case: {e}")
list_additional_settings = ['clb_change_save_pattern',
@@ -224,4 +229,4 @@ async def clb_additional_settings_msg(callback: CallbackQuery, state: FSMContext
case 'clb_change_notifications':
await func_additional_settings.notifications_message(callback.message, state)
except Exception as e:
logging.error(f"Error callback in additional_settings match-case: {e}")
logger.error(f"Error callback in additional_settings match-case: {e}")