add files project

.env.sample

@@ -0,0 +1 @@
+TOKEN_TELEGRAM_BOT=

.gitignore

@@ -0,0 +1,12 @@
+.env
+!*.sample
+
+__pycache__/
+*.pyc
+
+env/
+venv/
+.venv/
+
+requirements.txt
+

BibytBot_API.py

@@ -0,0 +1,31 @@
+import asyncio
+
+from aiogram import Bot, Dispatcher
+from aiogram.filters import Command, CommandStart
+from aiogram.types import Message
+
+from app.telegram.database.models import async_main
+
+from app.telegram.handlers.handlers import router # Для вызова событий
+from app.telegram.functions.main_settings.settings import router_main_settings # Для вызова событий
+
+from config import TOKEN_TG_BOT
+
+from app.telegram.logs import logger
+
+bot = Bot(token=TOKEN_TG_BOT)
+dp = Dispatcher()
+
+async def main():
+    await async_main()
+
+    dp.include_router(router)
+    dp.include_router(router_main_settings)
+
+    await dp.start_polling(bot)
+
+if __name__ == '__main__':
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        print("Bot is off")

BibytBot_API.pyproj

@@ -0,0 +1,59 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>bc1d7460-d8ca-4977-a249-0f6d6cc2375a</ProjectGuid>
+    <ProjectHome>.</ProjectHome>
+    <StartupFile>BibytBot_API.py</StartupFile>
+    <SearchPath>
+    </SearchPath>
+    <WorkingDirectory>.</WorkingDirectory>
+    <OutputPath>.</OutputPath>
+    <Name>BibytBot_API</Name>
+    <RootNamespace>BibytBot_API</RootNamespace>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
+    <DebugSymbols>true</DebugSymbols>
+    <EnableUnmanagedDebugging>false</EnableUnmanagedDebugging>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
+    <DebugSymbols>true</DebugSymbols>
+    <EnableUnmanagedDebugging>false</EnableUnmanagedDebugging>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="app\telegram\functions\additional_settings\settings.py" />
+    <Compile Include="app\telegram\functions\condition_settings\settings.py" />
+    <Compile Include="app\telegram\functions\functions.py" />
+    <Compile Include="app\telegram\database\models.py" />
+    <Compile Include="app\telegram\database\requests.py" />
+    <Compile Include="app\telegram\functions\main_settings\settings.py" />
+    <Compile Include="app\telegram\functions\risk_management_settings\settings.py" />
+    <Compile Include="app\telegram\handlers\handlers.py" />
+    <Compile Include="app\telegram\Keyboards\inline_keyboards.py" />
+    <Compile Include="app\telegram\Keyboards\reply_keyboards.py" />
+    <Compile Include="app\telegram\logs.py" />
+    <Compile Include="BibytBot_API.py" />
+    <Compile Include="config.py" />
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="app\" />
+    <Folder Include="app\telegram\database\" />
+    <Folder Include="app\telegram\functions\condition_settings\" />
+    <Folder Include="app\telegram\functions\additional_settings\" />
+    <Folder Include="app\telegram\functions\risk_management_settings\" />
+    <Folder Include="app\telegram\handlers\" />
+    <Folder Include="app\telegram\Keyboards\" />
+    <Folder Include="app\telegram\functions\main_settings\" />
+    <Folder Include="app\telegram\functions\" />
+    <Folder Include="app\telegram\" />
+  </ItemGroup>
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\Python Tools\Microsoft.PythonTools.targets" />
+  <!-- Uncomment the CoreCompile target to enable the Build command in
+       Visual Studio and specify your pre- and post-build commands in
+       the BeforeBuild and AfterBuild targets below. -->
+  <!--<Target Name="CoreCompile" />-->
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+</Project>

BibytBot_API.sln

@@ -0,0 +1,23 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.13.35825.156 d17.13
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{888888A0-9F3D-457C-B088-3A5042F75D52}") = "BibytBot_API", "BibytBot_API.pyproj", "{BC1D7460-D8CA-4977-A249-0F6D6CC2375A}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{BC1D7460-D8CA-4977-A249-0F6D6CC2375A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{BC1D7460-D8CA-4977-A249-0F6D6CC2375A}.Release|Any CPU.ActiveCfg = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {9AF00E9A-19FB-4146-96C0-B86C8B1E02C0}
+	EndGlobalSection
+EndGlobal

app/telegram/Keyboards/inline_keyboards.py

@@ -0,0 +1,88 @@
+from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup
+
+start_markup = InlineKeyboardMarkup(inline_keyboard=[
+    [InlineKeyboardButton(text="Зарегистрироваться", callback_data="callback_registration")],    
+    [InlineKeyboardButton(text="Авторизоваться", callback_data="callback_autorisation")]   
+])
+
+settings_markup = InlineKeyboardMarkup(inline_keyboard=[
+    [InlineKeyboardButton(text="Настройки", callback_data='clb_settings_message')]
+])
+
+back_btn_profile = [InlineKeyboardButton(text="Назад", callback_data='callback_autorisation')]
+
+special_settings_markup = InlineKeyboardMarkup(inline_keyboard=[
+    [InlineKeyboardButton(text="Основные настройки", callback_data='clb_change_main_settings'), 
+     InlineKeyboardButton(text="Риск-менеджмент", callback_data='clb_change_risk_management_settings')],
+
+    [InlineKeyboardButton(text="Условия запуска", callback_data='clb_change_condition_settings'), 
+     InlineKeyboardButton(text="Дополнительные параметры", callback_data='clb_change_additional_settings')],
+
+     back_btn_profile
+])
+
+back_btn_list_settings = [InlineKeyboardButton(text="Назад", callback_data='clb_back_to_special_settings_message')] # Кнопка для возврата к списку каталога настроек
+back_btn_list_settings_markup = InlineKeyboardMarkup(inline_keyboard=[[InlineKeyboardButton(text="Назад", callback_data='clb_back_to_special_settings_message')]]) # Клавиатура для возврата к списку каталога настроек
+
+main_settings_markup = InlineKeyboardMarkup(inline_keyboard=[
+    [InlineKeyboardButton(text='Режим торговли', callback_data='clb_change_trading_mode'), 
+     InlineKeyboardButton(text='Тип маржи', callback_data='clb_change_margin_type')],
+
+    [InlineKeyboardButton(text='Размер кредитного плеча', callback_data='clb_change_size_leverage'), 
+     InlineKeyboardButton(text='Начальная ставка', callback_data='clb_change_starting_quantity')],
+
+    [InlineKeyboardButton(text='Коэффициент Мартингейла', callback_data='clb_change_martingale_factor'), 
+     InlineKeyboardButton(text='Максимльное кол-во ставок', callback_data='clb_change_maximum_quantity')],
+
+     back_btn_list_settings
+])
+
+risk_management_settings_markup = InlineKeyboardMarkup(inline_keyboard=[
+    [InlineKeyboardButton(text='Изм. цены прибыли', callback_data='clb_change_price_profit'), 
+     InlineKeyboardButton(text='Изм. цены убытков', callback_data='clb_change_price_loss')],
+
+    [InlineKeyboardButton(text='Иакс. риск на сделку', callback_data='clb_change_max_risk_deal')],
+
+    back_btn_list_settings
+])
+
+condition_settings_markup = InlineKeyboardMarkup(inline_keyboard=[
+    [InlineKeyboardButton(text='Триггер', callback_data='clb_change_trigger'), 
+     InlineKeyboardButton(text='Фильтр времени', callback_data='clb_change_filter_time')],
+
+    [InlineKeyboardButton(text='Фильтр волатильности', callback_data='clb_change_filter_volatility'), 
+     InlineKeyboardButton(text='Внешние сигналы', callback_data='clb_change_external_cues')],
+
+    [InlineKeyboardButton(text='Сигналы TradingView', callback_data='clb_change_tradingview_cues'), 
+     InlineKeyboardButton(text='Webhook URL', callback_data='clb_change_webhook')],
+     
+    [InlineKeyboardButton(text='AI - аналитика', callback_data='clb_change_ai_analytics')],
+
+    back_btn_list_settings
+])
+
+additional_settings_markup = InlineKeyboardMarkup(inline_keyboard=[
+    [InlineKeyboardButton(text='Сохранить шаблон', callback_data='clb_change_save_pattern'), 
+     InlineKeyboardButton(text='Автозапуск', callback_data='clb_change_auto_start')],
+
+    [InlineKeyboardButton(text='Уведомления', callback_data='clb_change_notifications')],
+
+    back_btn_list_settings
+])
+
+trading_mode_markup = InlineKeyboardMarkup(inline_keyboard=[
+    [InlineKeyboardButton(text="Лонг", callback_data="trade_mode_long"),
+    InlineKeyboardButton(text="Шорт", callback_data="trade_mode_short")],
+
+    [InlineKeyboardButton(text="Свитч", callback_data="trade_mode_switch"),
+    InlineKeyboardButton(text="Смарт", callback_data="trade_mode_smart")],
+
+    back_btn_list_settings
+])
+
+margin_type_markup = InlineKeyboardMarkup(inline_keyboard=[
+    [InlineKeyboardButton(text="Изолированный", callback_data="margin_type_isolated"),
+    InlineKeyboardButton(text="Кросс", callback_data="margin_type_cross")],
+
+    back_btn_list_settings
+])

app/telegram/Keyboards/reply_keyboards.py

@@ -0,0 +1,19 @@
+from aiogram.types import ReplyKeyboardMarkup, KeyboardButton
+
+base_buttons_markup = ReplyKeyboardMarkup(keyboard=[
+    [KeyboardButton(text="👤 Профиль")],    
+    # [KeyboardButton(text="Настройки")]         
+], resize_keyboard=True)
+
+trigger_markup = ReplyKeyboardMarkup(keyboard=[ # ИЗМЕНИТЬ НА INLINE
+    [KeyboardButton(text='Ручной'), KeyboardButton(text='TradingView')],    
+    [KeyboardButton(text="Автоматический")]    
+], resize_keyboard=True)
+
+buttons_yes_no_markup = ReplyKeyboardMarkup(keyboard=[  # ИЗМЕНИТЬ НА INLINE
+    [KeyboardButton(text='Да'), KeyboardButton(text='Нет')]         
+], resize_keyboard=True)
+
+buttons_on_off_markup = ReplyKeyboardMarkup(keyboard=[  # ИЗМЕНИТЬ НА INLINE
+    [KeyboardButton(text='Включить'), KeyboardButton(text='Выключить')]        
+], resize_keyboard=True)

app/telegram/database/models.py

@@ -0,0 +1,120 @@
+import logging
+logger = logging.getLogger(__name__)
+
+from sqlalchemy import BigInteger, Boolean, Integer, String, ForeignKey
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+from sqlalchemy.ext.asyncio import AsyncAttrs, async_sessionmaker, create_async_engine
+
+from sqlalchemy import select, insert
+
+engine = create_async_engine(url='sqlite+aiosqlite:///db.sqlite3')
+
+async_session = async_sessionmaker(engine)
+
+class Base(AsyncAttrs, DeclarativeBase):
+    pass
+
+class User_Telegram_Id(Base):
+    __tablename__ = 'user_telegram_id'
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+
+    tg_id = mapped_column(BigInteger)
+
+class Trading_Mode(Base):
+    __tablename__ = 'trading_modes'
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+
+    mode = mapped_column(String(10), unique=True)
+
+class Margin_type(Base):
+    __tablename__ = 'margin_types'
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+
+    type = mapped_column(String(15), unique=True)
+
+class Trigger(Base):
+    __tablename__ = 'triggers'
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+
+    trigger = mapped_column(String(15), unique=True)
+
+class User_Main_Settings(Base):
+    __tablename__ = 'user_main_settings'
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+
+    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))
+
+    trading_mode = mapped_column(ForeignKey("trading_modes.mode"))
+    margin_type = mapped_column(ForeignKey("margin_types.type"))
+    size_leverage = mapped_column(Integer(), default=1)
+    starting_quantity = mapped_column(Integer(), default=1)
+    martingale_factor = mapped_column(Integer(), default=1)
+    maximal_quantity = mapped_column(Integer(), default=10)
+
+class User_Risk_Management_Settings(Base):
+    __tablename__ = 'user_risk_management_settings'
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+
+    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))
+
+    price_profit = mapped_column(Integer(), default=1)
+    price_loss = mapped_column(Integer(), default=1)
+    max_risk_deal = mapped_column(Integer(), default=1)
+
+class User_Condition_Settings(Base):
+    __tablename__ = 'user_condition_settings'
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+
+    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))
+
+    trigger = mapped_column(ForeignKey("triggers.trigger"))
+    filter_time = mapped_column(String(25), default='???')
+    filter_volatility = mapped_column(Boolean, default=False)
+    external_cues = mapped_column(Boolean, default=False)
+    tradingview_cues = mapped_column(Boolean, default=False)
+    webhook = mapped_column(String(40), default='')
+    ai_analytics = mapped_column(Boolean, default=False)
+
+class User_Additional_Settings(Base):
+    __tablename__ = 'user_additional_settings'
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+
+    tg_id = mapped_column(ForeignKey("user_telegram_id.tg_id"))
+
+    pattern_save = mapped_column(Boolean, default=False)
+    autostart = mapped_column(Boolean, default=False)
+    notifications = mapped_column(Boolean, default=False)
+
+async def async_main():
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+                                                                  
+        # Заполнение таблиц
+        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():
+                logger.info("Заполение таблицы режима торговли")
+                await conn.execute(Trading_Mode.__table__.insert().values(mode=mode))
+
+        types = ['Изолированный', 'Кросс']
+        for type in types:
+            result = await conn.execute(select(Margin_type).where(Margin_type.type == type))           
+            if not result.first():
+                logger.info("Заполение таблицы типов маржи")
+                await conn.execute(Margin_type.__table__.insert().values(type=type))
+
+        triggers = ['Ручной', 'Автоматический', 'TradingView']
+        for trigger in triggers:
+            result = await conn.execute(select(Trigger).where(Trigger.trigger == trigger))
+            if not result.first():
+                logger.info("Заполение таблицы триггеров")
+                await conn.execute(Trigger.__table__.insert().values(trigger=trigger))

app/telegram/database/requests.py

@@ -0,0 +1,174 @@
+import logging
+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_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
+
+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_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_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
+
+# UPDATE_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()

app/telegram/functions/additional_settings/settings.py

@@ -0,0 +1,41 @@
+import app.telegram.Keyboards.inline_keyboards as inline_markup
+import app.telegram.Keyboards.reply_keyboards as reply_markup
+
+import app.telegram.database.requests as rq
+
+async def reg_new_user_default_additional_settings(id, message):
+    tg_id = id
+
+    await rq.set_new_user_default_additional_settings(tg_id)
+
+async def main_settings_message(message):
+    text = '''<b>Дополнительные параметры</b>
+
+Сохранить как шаблон стратегии: да / нет
+
+Автозапуск после сохранения: да / нет
+
+Уведомления в Telegram: включено / отключено '''
+
+    await message.answer(text=text, parse_mode='html', reply_markup=inline_markup.additional_settings_markup)
+
+async def save_pattern_message(message, state):
+    text = '''<b>Сохранение шаблона</b>
+
+    Описание... '''
+
+    await message.answer(text=text, parse_mode='html', reply_markup=reply_markup.buttons_yes_no_markup)
+
+async def auto_start_message(message, state):
+    text = '''<b>Автозапуск</b>
+
+    Описание... '''
+
+    await message.answer(text=text, parse_mode='html', reply_markup=reply_markup.buttons_yes_no_markup)
+
+async def notifications_message(message, state):
+    text = '''<b>Уведомления</b>
+
+    Описание... '''
+
+    await message.answer(text=text, parse_mode='html', reply_markup=reply_markup.buttons_on_off_markup)

app/telegram/functions/condition_settings/settings.py

@@ -0,0 +1,82 @@
+import app.telegram.Keyboards.inline_keyboards as inline_markup
+import app.telegram.Keyboards.reply_keyboards as reply_markup
+
+import app.telegram.database.requests as rq
+
+async def reg_new_user_default_condition_settings(id, message):
+    tg_id = id
+
+    trigger = await rq.get_for_registration_trigger()
+
+    await rq.set_new_user_default_condition_settings(tg_id, trigger)
+
+async def main_settings_message(message):
+    text = """ <b>Условия запуска</b>
+
+Триггер: Ручной запуск / Сигнал TradingView / Полностью автоматический
+
+Фильтр времени: диапазон по дням недели и времени суток
+
+Фильтр волатильности / объёма: включить/отключить
+
+Интеграции и внешние сигналы:
+
+Использовать сигналы TradingView: да / нет
+
+Использовать AI-аналитику от ChatGPT: да / нет
+
+Webhook URL для сигналов (если используется TradingView).
+
+"""
+
+    await message.answer(text=text, parse_mode='html', reply_markup=inline_markup.condition_settings_markup)
+   
+async def trigger_message(message, state):
+    text = '''Триггер
+
+    Описание ручного запуска, сигналов, автоматического режима '''
+
+    await message.answer(text=text, parse_mode='html', reply_markup=reply_markup.trigger_markup)
+
+async def filter_time_message(message, state):
+    text = '''Фильтр времени
+
+    ???
+    '''
+
+    await message.answer(text=text)
+
+async def filter_volatility_message(message, state):
+    text = '''Фильтр волатильности
+
+    Описание... '''
+
+    await message.answer(text=text, parse_mode='html', reply_markup=reply_markup.buttons_on_off_markup)
+
+async def external_cues_message(message, state):
+    text = '''<b>Внешние сигналы</b>
+
+    Описание... '''
+
+    await message.answer(text=text, parse_mode='html', reply_markup=None)
+
+async def trading_cues_message(message, state):
+    text = '''<b>Использование сигналов</b>
+
+    Описание... '''
+
+    await message.answer(text=text, parse_mode='html', reply_markup=reply_markup.buttons_yes_no_markup)
+
+async def webhook_message(message, state):
+    text = '''Скиньте ссылку на <b>webhook</b> (если есть trading view): '''
+
+    await message.answer(text=text, parse_mode='html')
+    
+async def ai_analytics_message(message, state):
+    text = '''<b>ИИ - Аналитика</b> 
+
+    Описание... '''
+
+    await message.answer(text=text, parse_mode='html', reply_markup=reply_markup.buttons_yes_no_markup)
+
+

app/telegram/functions/functions.py

@@ -0,0 +1,34 @@
+import app.telegram.Keyboards.inline_keyboards as inline_markup
+import app.telegram.Keyboards.reply_keyboards as reply_markup
+
+async def start_message(message):
+    await message.answer(f""" Привет <b>{message.from_user.username}</b>! 👋
+
+Добро пожаловать в бот по трейдингу на Bibyt — вашего надежного помощника для анализа рынка и принятия взвешенных решений. Здесь вы получите:
+<b>
+📊 Анализ текущих трендов  
+📈 Инструменты для прогнозирования и оценки рисков  
+⚡️ Сигналы и рекомендации по сделкам  
+🔔 Уведомления о важных изменениях и новостях
+</b>
+Просто отправляйте интересующий вас инструмент или команду, и бот быстро предоставит актуальную информацию и аналитику.
+
+Начнем торговать умно и эффективно вместе! 🚀 
+
+""", parse_mode='html', reply_markup=inline_markup.start_markup)
+
+async def profile_message(username, message):
+    await message.answer(f""" <b>{username}</b>
+
+Баланс:  
+⭐️ 0
+
+Описание:  
+Активный трейдер на платформе Bibyt с индивидуальной стратегией и аналитикой в реальном времени. Постоянно улучшает навыки и следит за рыночными тенденциями для максимальной прибыли.
+""", parse_mode='html', reply_markup=inline_markup.settings_markup)
+
+async def check_profile_message(message):
+    await message.answer(f'Добро пожаловать {message.from_user.username}!', reply_markup=reply_markup.base_buttons_markup)
+    
+async def settings_message(message):
+    await message.edit_text("Выберите что настроить", reply_markup=inline_markup.special_settings_markup)

app/telegram/functions/main_settings/settings.py

@@ -0,0 +1,211 @@
+from aiogram import Router
+
+import app.telegram.Keyboards.inline_keyboards as inline_markup
+import app.telegram.Keyboards.reply_keyboards as reply_markup
+
+import app.telegram.database.requests as rq
+from aiogram.types import Message, CallbackQuery
+
+# FSM - Механизм состояния
+from aiogram.fsm.state import State, StatesGroup
+
+router_main_settings = Router()
+
+class update_main_settings(StatesGroup):
+    trading_mode = State() # +
+    size_leverage = State() #
+    margin_type = State() #
+    martingale_factor = State() #
+    starting_quantity = State() #
+    maximal_quantity = State() #
+
+async def reg_new_user_default_main_settings(id, message):
+    tg_id = id
+
+    trading_mode = await rq.get_for_registration_trading_mode()
+    margin_type = await rq.get_for_registration_margin_type()
+
+    await rq.set_new_user_default_main_settings(tg_id, trading_mode, margin_type)
+    
+
+async def main_settings_message(id, message, state):
+     data = await rq.get_user_main_settings(id)
+
+     await message.answer(f"""<b>Основные настройки</b>   
+Режим торговли: <b>{data['trading_mode']}</b>
+
+Тип маржи: <b>{data['margin_type']}</b>
+
+Размер кредитного плеча: <b>х{data['size_leverage']}</b>
+
+Начальная ставка: <b>{data['starting_quantity']}</b>
+
+Коэффициент мартингейла: <b>{data['martingale_factor']}</b>
+
+Максимальное количесиво ставок в серии: <b>{data['maximal_quantity']}</b>    
+""", parse_mode='html', reply_markup=inline_markup.main_settings_markup)
+
+async def trading_mode_message(message, state):
+    await state.set_state(update_main_settings.trading_mode)
+
+    await message.edit_text("""<b>Режим торговли</b>
+
+<b>Лонг</b> — стратегия, ориентированная на покупку актива с целью заработать на повышении его стоимости.
+
+<b>Шорт</b> — метод продажи активов, взятых в кредит, чтобы получить прибыль от снижения цены.
+
+<b>Смарт</b> — автоматизированный режим, который подбирает оптимальную стратегию в зависимости от текущих рыночных условий.
+
+<b>Свитч</b> — динамическое переключение между торговыми режимами для максимизации эффективности.
+    
+<em>Выберите ниже для изменений:</em>    
+""", parse_mode='html', reply_markup=inline_markup.trading_mode_markup)
+
+@router_main_settings.callback_query(update_main_settings.trading_mode)
+async def state_trading_mode(callback: CallbackQuery, state):
+   await callback.answer()
+
+   id = callback.from_user.id
+   print(f"sdljfngdjklfg ## {callback.data}")
+
+   try:
+       match callback.data:
+           case 'trade_mode_long':
+                await rq.update_trade_mode_user(id, 'Long')
+                await main_settings_message(id, callback.message, state)
+
+                await state.clear()
+           case 'trade_mode_short':
+                await rq.update_trade_mode_user(id, 'Short')
+                await main_settings_message(id, callback.message, state)
+
+                await state.clear()
+           case 'trade_mode_switch':
+                await rq.update_trade_mode_user(id, 'Switch')
+                await main_settings_message(id, callback.message, state)
+
+                await state.clear()
+           case 'trade_mode_smart':
+               await rq.update_trade_mode_user(id, 'Smart')
+               await main_settings_message(id, callback.message, state)
+
+               await state.clear()
+   except Exception as e:
+        print(f"error: {e}")
+
+async def size_leverage_message (message, state):
+    await state.set_state(update_main_settings.size_leverage)
+
+    await message.edit_text("Введите размер <b>кредитного плеча</b> (от 1 до 100): ", parse_mode='html', reply_markup=inline_markup.back_btn_list_settings_markup)
+
+@router_main_settings.message(update_main_settings.size_leverage)
+async def state_size_leverage(message: Message, state):
+    await state.update_data(size_leverage = message.text)
+
+    data = await state.get_data()
+
+    if data['size_leverage'].isdigit() and int(data['size_leverage']) <= 100:
+        await rq.update_size_leverange(message.from_user.id, data['size_leverage'])
+        await main_settings_message(message.from_user.id, message, state)
+
+        await state.clear()
+    else:
+        await main_settings_message(message.from_user.id, message, state)        
+
+async def martingale_factor_message(message, state):
+    await state.set_state(update_main_settings.martingale_factor)
+
+    await message.edit_text("Введите <b>коэффициент Мартингейла:</b>", parse_mode='html', reply_markup=inline_markup.back_btn_list_settings_markup)
+
+@router_main_settings.message(update_main_settings.martingale_factor)
+async def state_martingale_factor(message: Message, state):
+    await state.update_data(martingale_factor = message.text)
+
+    data = await state.get_data()
+
+    if data['martingale_factor'].isdigit() and int(data['martingale_factor']) <= 100:
+        await rq.update_martingale_factor(message.from_user.id, data['martingale_factor'])
+        await main_settings_message(message.from_user.id, message, state)
+
+        await state.clear()
+    else:
+        await main_settings_message(message.from_user.id, message, state)
+    
+async def margin_type_message(message, state):
+    await state.set_state(update_main_settings.margin_type)
+
+    await message.edit_text("""<b>Тип маржи</b>
+
+<b>Изолированная маржа</b>  
+Этот тип маржи позволяет ограничить риск конкретной позиции. 
+При использовании изолированной маржи вы выделяете определённую сумму средств только для одной позиции. 
+Если позиция начинает приносить убытки, ваши потери ограничиваются этой суммой, 
+и остальные средства на счёте не затрагиваются.
+
+<b>Кросс-маржа</b>  
+Кросс-маржа объединяет весь маржинальный баланс на счёте и использует все доступные средства для поддержания открытых позиций. 
+В случае убытков средства с других позиций или баланса автоматически покрывают дефицит, 
+снижая риск ликвидации, но увеличивая общий риск потери капитала.
+
+<em>Выберите ниже для изменений:</em>
+""", parse_mode='html', reply_markup=inline_markup.margin_type_markup)
+
+@router_main_settings.callback_query(update_main_settings.margin_type)
+async def state_margin_type(callback: CallbackQuery, state):
+   await callback.answer()
+
+   id = callback.from_user.id
+   print(f"sdljfngdjklfg ## {callback.data}")
+
+   try:
+       match callback.data:
+           case 'margin_type_isolated':
+                await rq.update_margin_type(id, 'Изолированный')
+                await main_settings_message(id, callback.message, state)
+
+                await state.clear()
+           case 'margin_type_cross':
+                await rq.update_margin_type(id, 'Кросс')
+                await main_settings_message(id, callback.message, state)
+
+                await state.clear()
+   except Exception as e:
+        print(f"error: {e}")
+
+async def starting_quantity_message (message, state):
+    await state.set_state(update_main_settings.starting_quantity)
+
+    await message.edit_text("Введите <b>началаьную ставку:</b>", parse_mode='html', reply_markup=inline_markup.back_btn_list_settings_markup)
+
+@router_main_settings.message(update_main_settings.starting_quantity)
+async def state_starting_quantity(message: Message, state):
+    await state.update_data(starting_quantity = message.text)
+
+    data = await state.get_data()
+
+    if data['starting_quantity'].isdigit() and int(data['starting_quantity']) <= 100:
+        await rq.update_starting_quantity(message.from_user.id, data['starting_quantity'])
+        await main_settings_message(message.from_user.id, message, state)
+
+        await state.clear()
+    else:
+        await main_settings_message(message.from_user.id, message, state)
+
+async def maximum_quantity_message(message, state):
+    await state.set_state(update_main_settings.maximal_quantity)
+
+    await message.edit_text("Введите <b>максимальное количество ставок:</b>", parse_mode='html', reply_markup=inline_markup.back_btn_list_settings_markup)
+
+@router_main_settings.message(update_main_settings.maximal_quantity)
+async def state_maximal_quantity(message: Message, state):
+    await state.update_data(maximal_quantity = message.text)
+
+    data = await state.get_data()
+
+    if data['maximal_quantity'].isdigit() and int(data['maximal_quantity']) <= 100:
+        await rq.update_maximal_quantity(message.from_user.id, data['maximal_quantity'])
+        await main_settings_message(message.from_user.id, message, state)
+
+        await state.clear()
+    else:
+        await main_settings_message(message.from_user.id, message, state)

app/telegram/functions/risk_management_settings/settings.py

@@ -0,0 +1,37 @@
+import app.telegram.Keyboards.inline_keyboards as inline_markup
+import app.telegram.Keyboards.reply_keyboards as reply_markup
+
+import app.telegram.database.requests as rq
+
+async def reg_new_user_default_risk_management_settings(id, message):
+    tg_id = id
+
+    await rq.set_new_user_default_risk_management_settings(tg_id)    
+
+
+async def main_settings_message(message):
+    text = f"""<b>Риск менеджмент</b>,
+
+    Процент изменения цены для фиксации прибыли: 0
+
+    Процент изменения цены для фиксации убытков: 0
+
+    Максимальный риск на сделку (в % от баланса): 0 
+    """
+
+    await message.edit_text(text=text, parse_mode='html', reply_markup=inline_markup.risk_management_settings_markup)
+
+async def price_profit_message(message, state):
+    text =  'Введите число изменения цены для фиксации прибыли: '
+
+    await message.answer(text=text, parse_mode='html', reply_markup=None)
+
+async def price_loss_message(message, state):
+    text =  'Введите число изменения цены для фиксации убытков: '
+
+    await message.answer(text=text, parse_mode='html', reply_markup=None)
+
+async def max_risk_deal_message(message, state):
+    text =  'Введите число (процент от баланса) для изменения максимального риска на сделку: '
+
+    await message.answer(text=text, parse_mode='html', reply_markup=None)

app/telegram/handlers/handlers.py

@@ -0,0 +1,195 @@
+import logging
+
+from aiogram import F, Router
+from aiogram.filters import CommandStart, Command
+from aiogram.types import Message, CallbackQuery
+from aiogram.fsm.context import FSMContext
+
+import app.telegram.functions.functions as func # functions
+import app.telegram.functions.main_settings.settings as func_main_settings
+import app.telegram.functions.risk_management_settings.settings as func_rmanagement_settings
+import app.telegram.functions.condition_settings.settings as func_condition_settings
+import app.telegram.functions.additional_settings.settings as func_additional_settings
+
+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
+
+router = Router()
+
+@router.message(CommandStart())
+async def start_message(message: Message):
+    await func.start_message(message)
+
+@router.message(F.text == "👤 Профиль")
+async def profile_message(message: Message):
+    user = await rq.check_user(message.from_user.id)
+
+    if user:
+        await func.profile_message(message.from_user.username, message)
+
+@router.message(F.text == "Настройки")
+async def settings_msg(message: Message):
+    user = await rq.check_user(message.from_user.id)
+
+    if user:
+        await func.settings_message(message)
+
+@router.callback_query(F.data == "callback_registration")
+async def clb_func_reg (callback: CallbackQuery):
+    await rq.save_tg_id_new_user(callback.from_user.id)
+    print(callback.from_user.id)
+
+    await func_main_settings.reg_new_user_default_main_settings(callback.from_user.id, callback.message)
+    await func_rmanagement_settings.reg_new_user_default_risk_management_settings(callback.from_user.id, callback.message)
+    await func_condition_settings.reg_new_user_default_condition_settings(callback.from_user.id, callback.message) 
+    await func_additional_settings.reg_new_user_default_additional_settings(callback.from_user.id, callback.message)
+
+    await callback.message.answer(f'Регистрация прошла успешно, здравствуйте {callback.from_user.username}!', reply_markup=reply_markup.base_buttons_markup)
+
+    await callback.answer()
+
+@router.callback_query(F.data == "callback_autorisation")
+async def clb_func_reg (callback: CallbackQuery):
+    user = await rq.check_user(callback.from_user.id)
+
+    if user:
+        await func.profile_message(callback.from_user.username, callback.message)
+    
+ # Настройки торговли
+@router.callback_query(F.data == "clb_settings_message")
+async def clb_settings_msg (callback: CallbackQuery):
+    await func.settings_message(callback.message)
+
+    await callback.answer()
+
+@router.callback_query(F.data == "clb_back_to_special_settings_message")
+async def clb_back_to_settings_msg(callback: CallbackQuery):
+    await func.settings_message(callback.message)
+
+    await callback.answer()
+
+@router.callback_query(F.data == "clb_change_main_settings")
+async def clb_change_main_settings_message(callback: CallbackQuery, state: FSMContext):
+    await func_main_settings.main_settings_message(callback.from_user.id, callback.message, state)
+
+    await callback.answer() 
+
+@router.callback_query(F.data == "clb_change_risk_management_settings")
+async def clb_change_risk_management_message(callback: CallbackQuery, state: FSMContext):
+    await func_rmanagement_settings.main_settings_message(callback.from_user.id, callback.message, state)
+
+    await callback.answer()
+
+@router.callback_query(F.data == "clb_change_condition_settings")
+async def clb_change_condition_message(callback: CallbackQuery, state: FSMContext):
+    await func_condition_settings.main_settings_message(callback.from_user.id, callback.message, state)
+
+    await callback.answer()
+
+@router.callback_query(F.data == "clb_change_additional_settings")
+async def clb_change_additional_message(callback: CallbackQuery, state: FSMContext):
+    await func_additional_settings.main_settings_message(callback.from_user.id, callback.message, state)
+
+    await callback.answer()
+
+ # Конкретные настройки каталогов   
+list_main_settings = ['clb_change_trading_mode', 
+                      'clb_change_margin_type', 
+                      'clb_change_size_leverage', 
+                      'clb_change_starting_quantity', 
+                      'clb_change_martingale_factor', 
+                      'clb_change_maximum_quantity'
+]
+@router.callback_query(F.data.in_(list_main_settings))
+async def clb_main_settings_msg(callback: CallbackQuery, state: FSMContext):
+    await callback.answer()
+
+    try:
+        match callback.data:
+            case 'clb_change_trading_mode':
+                await func_main_settings.trading_mode_message(callback.message, state)
+            case 'clb_change_margin_type':
+                await func_main_settings.margin_type_message(callback.message, state)
+            case 'clb_change_size_leverage':
+                await func_main_settings.size_leverage_message(callback.message, state)
+            case 'clb_change_starting_quantity':
+                await func_main_settings.starting_quantity_message(callback.message, state)
+            case 'clb_change_martingale_factor':
+                await func_main_settings.martingale_factor_message(callback.message, state)
+            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}")
+
+
+list_risk_management_settings = ['clb_change_price_profit', 
+                      'clb_change_price_loss', 
+                      'clb_change_max_risk_deal', 
+]
+@router.callback_query(F.data.in_(list_risk_management_settings))
+async def clb_risk_management_settings_msg(callback: CallbackQuery, state: FSMContext):
+    await callback.answer()
+
+    try:
+        match callback.data:
+            case 'clb_change_price_profit':
+                await func_rmanagement_settings.price_profit_message(callback.message, state)
+            case 'clb_change_price_loss':
+                await func_rmanagement_settings.price_loss_message(callback.message, state)
+            case 'clb_change_max_risk_deal':
+                await func_rmanagement_settings.max_risk_deal_message(callback.message, state)
+    except Exception as e:
+        logging.error(f"Error callback in risk_management match-case: {e}")
+  
+        
+list_condition_settings = ['clb_change_trigger',
+                           'clb_change_filter_time',
+                           'clb_change_filter_volatility',
+                           'clb_change_external_cues',
+                           'clb_change_tradingview_cues',
+                           'clb_change_webhook',
+                           'clb_change_ai_analytics'
+]
+@router.callback_query(F.data.in_(list_condition_settings))
+async def clb_condition_settings_msg(callback: CallbackQuery, state: FSMContext):
+    await callback.answer()
+    
+    try:
+        match callback.data:
+            case 'clb_change_trigger':
+                await func_condition_settings.trigger_message(callback.message, state)
+            case 'clb_change_filter_time':
+                await func_condition_settings.filter_time_message(callback.message, state)
+            case 'clb_change_filter_volatility':
+                await func_condition_settings.filter_volatility_message(callback.message, state)
+            case 'clb_change_external_cues':
+                await func_condition_settings.external_cues_message(callback.message, state)
+            case 'clb_change_tradingview_cues':
+                await func_condition_settings.trading_cues_message(callback.message, state)
+            case 'clb_change_webhook':
+                await func_condition_settings.webhook_message(callback.message, state)
+            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}")
+
+
+list_additional_settings = ['clb_change_save_pattern', 
+                      'clb_change_auto_start', 
+                      'clb_change_notifications', 
+]
+@router.callback_query(F.data.in_(list_additional_settings))
+async def clb_additional_settings_msg(callback: CallbackQuery, state: FSMContext):
+    await callback.answer()
+
+    try:
+        match callback.data:
+            case 'clb_change_save_pattern':
+                await func_additional_settings.save_pattern_message(callback.message, state)
+            case 'clb_change_auto_start':
+                await func_additional_settings.auto_start_message(callback.message, state)
+            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}")

app/telegram/logs.py

@@ -0,0 +1,8 @@
+import logging
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+
+logger = logging.getLogger(__name__)

config.py

@@ -0,0 +1,6 @@
+from dotenv import load_dotenv
+import os
+
+load_dotenv('.env')
+
+TOKEN_TG_BOT = os.getenv('TOKEN_TELEGRAM_BOT')