Добавлен новый файл call_validation_promo_api.py для валидации промокодов через API. Реализована логика получения JWT токена и проверки валидности промокода. Обновлены модели в integration_models.py для поддержки запросов и ответов на валидацию промокодов. Добавлен новый эндпоинт /validationPromo в integration_api.py для обработки запросов на валидацию промокодов.

bff_models.py

@@ -0,0 +1,207 @@
+from pydantic import BaseModel, Field, EmailStr, ConfigDict
+from typing import Optional, List
+from datetime import datetime
+import uuid
+from enum import Enum
+
+
+# BFF Models
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+class AccountProfileUpdateRequest(BaseModel):
+    firstName: str
+    surname: str
+    email: EmailStr
+    phone: str
+
+class AccountPasswordChangeRequest(BaseModel):
+    currentPassword: str
+    newPassword: str
+
+class TransactionStatus(str, Enum):
+    WAITING = 'waiting'
+    PROCESS = 'process'
+    DONE = 'done'
+    REJECT = 'reject'
+    ERROR = 'error'
+    NEW = 'new'
+
+class AgentTransactionResponse(BaseModel):
+    amount: float
+    status: TransactionStatus
+    transaction_group: uuid.UUID
+    create_dttm: datetime
+    update_dttm: datetime
+    agent_name: Optional[str] = None
+
+class AutoApproveSettingsRequest(BaseModel):
+    auto_approve: bool
+    apply_to_current: Optional[bool] = False
+
+class ApproveTransactionsRequest(BaseModel):
+    transaction_ids: List[uuid.UUID]
+
+# New Response Models for BFF APIs
+
+class RegisterResponse(BaseModel):
+    msg: str
+
+class TgAuthResponse(BaseModel):
+    msg: str
+    tg_id: int
+
+class DashboardCardsResponse(BaseModel):
+    totalRevenue: float
+    totalPayouts: float
+    activeReferrals: int
+    pendingPayouts: float
+    totalSales: int
+
+class DashboardChartTotalItem(BaseModel):
+    date: str
+    revenue: float
+    sales: int
+
+class DashboardChartTotalResponse(BaseModel):
+    items: List[DashboardChartTotalItem]
+
+class DashboardChartAgentItem(BaseModel):
+    name: str
+    count: int
+    sum: float
+
+class DashboardChartAgentResponse(BaseModel):
+    items: List[DashboardChartAgentItem]
+
+class StatAgentsItem(BaseModel):
+    name: str
+    refCount: int
+    salesCount: int
+    salesSum: float
+    crediting: float
+
+class StatAgentsResponse(BaseModel):
+    items: List[StatAgentsItem]
+
+class StatReferralsItem(BaseModel):
+    ref: str
+    agent: Optional[str] = None
+    description: str
+    promocode: str
+    salesSum: float
+    salesCount: int
+
+class StatReferralsResponse(BaseModel):
+    items: List[StatReferralsItem]
+
+class StatSalesItem(BaseModel):
+    saleId: str
+    cost: float
+    crediting: float
+    ref: Optional[str] = None
+    name: Optional[str] = None
+
+class StatSalesResponse(BaseModel):
+    items: List[StatSalesItem]
+
+class BillingCardsResponse(BaseModel):
+    cost: float
+    crediting: float
+    pendingPayouts: float
+
+class BillingChartStatItem(BaseModel):
+    date: str
+    status: str
+    count: int
+
+class BillingChartStatResponse(BaseModel):
+    items: List[BillingChartStatItem]
+
+class BillingChartPieItem(BaseModel):
+    status: str
+    count: int
+
+class BillingChartPieResponse(BaseModel):
+    items: List[BillingChartPieItem]
+
+class BillingPayoutsTransactionsItem(BaseModel):
+    id: uuid.UUID
+    amount: float
+    agent: Optional[str] = None
+    status: TransactionStatus
+    create_dttm: datetime
+    update_dttm: datetime
+
+class BillingPayoutsTransactionsResponse(BaseModel):
+    items: List[BillingPayoutsTransactionsItem]
+
+class AccountResponse(BaseModel):
+    firstName: Optional[str] = None
+    surname: Optional[str] = None
+
+class CompanyProfileResponse(BaseModel):
+    name: str
+    key: str
+    commission: float
+
+class AccountProfileResponse(BaseModel):
+    firstName: Optional[str] = None
+    surname: Optional[str] = None
+    phone: Optional[str] = None
+    email: Optional[EmailStr] = None
+    create_dttm: datetime
+    company: CompanyProfileResponse
+
+class AccountProfileUpdateResponse(BaseModel):
+    msg: str
+
+class AccountPasswordChangeResponse(BaseModel):
+    msg: str
+
+class AutoApproveSettingsGetResponse(BaseModel):
+    auto_approve_transactions: bool
+
+class AutoApproveSettingsUpdateResponse(BaseModel):
+    msg: str
+    auto_approve_transactions: bool
+
+class ApproveTransactionsResult(BaseModel):
+    msg: str
+    approved_count: int
+
+# New models for integration tokens
+class IntegrationTokenResponse(BaseModel):
+    id: int
+    description: str
+    masked_token: str
+    rawToken: Optional[str] = None
+    create_dttm: datetime
+    use_dttm: Optional[datetime] = None
+
+    model_config = ConfigDict(from_attributes=True)
+
+class IntegrationTokenCreateRequest(BaseModel):
+    description: str
+
+class IntegrationTokenUpdateRequest(BaseModel):
+    id: int
+    description: str
+
+# New models for sale categories
+class SaleCategoryRequest(BaseModel):
+    id: int | None = None
+    category: str
+    description: str | None = None
+    perc: float
+
+class SaleCategoryResponse(BaseModel):
+    id: int
+    category: str
+    description: str | None = None
+    perc: float
+    create_dttm: datetime
+    update_dttm: datetime
+
+    model_config = ConfigDict(from_attributes=True)

call_sale_api.py

@@ -0,0 +1,63 @@
+import uuid
+import requests
+import json
+
+# Конфигурация API
+BASE_URL = "http://127.0.0.1:8001"
+API_KEY = "de058226-37d3-4d0e-a483-3c2a7fac3573"
+REF = "0d9aaa96-80e6-424c-84c9-ff70a6eb915e"
+
+# Данные для запроса на создание продажи
+# Замените эти значения на актуальные для вашей продажи
+sale_data = {
+    "cost": 100,  # Стоимость продажи
+    "ref": REF,  # Ваш реферальный код
+    "sale_id": str(uuid.uuid4()), # Уникальный идентификатор продажи для вашей компании
+    "category": "vip",  # название категории (например, 'basic', 'premium', 'vip')
+    "group_sale_id": str(uuid.uuid4())  # уникальный идентификатор группы продаж
+}
+
+# Эндпоинты
+token_endpoint = f"{BASE_URL}/token"
+sale_endpoint = f"{BASE_URL}/sale"
+
+# Шаг 1: Получение JWT токена
+print(f"Отправка запроса на получение токена на {token_endpoint}")
+token_headers = {
+    "X-API-Key": API_KEY,
+    "Content-Type": "application/json"
+}
+
+try:
+    token_response = requests.post(token_endpoint, headers=token_headers)
+    token_response.raise_for_status()
+
+    token_data = token_response.json()
+    jwt_token = token_data["access_token"]
+    print("JWT токен успешно получен.")
+
+except requests.exceptions.RequestException as e:
+    print(f"Произошла ошибка при получении токена: {e}")
+    if hasattr(e, 'response') and e.response is not None:
+        print("Тело ответа с ошибкой:", e.response.json())
+    exit() # Прерываем выполнение, если не удалось получить токен
+
+# Шаг 2: Вызов эндпоинта /sale с использованием полученного JWT токена
+headers_with_jwt = {
+    "Authorization": f"Bearer {jwt_token}",
+    "Content-Type": "application/json"
+}
+
+print(f"Отправка запроса на {sale_endpoint} с данными: {sale_data}")
+
+try:
+    sale_response = requests.post(sale_endpoint, headers=headers_with_jwt, data=json.dumps(sale_data))
+    sale_response.raise_for_status()  # Вызовет исключение для ошибок HTTP (4xx или 5xx)
+
+    print("Статус ответа:", sale_response.status_code)
+    print("Тело ответа:", sale_response.json())
+
+except requests.exceptions.RequestException as e:
+    print(f"Произошла ошибка при вызове API sale: {e}")
+    if hasattr(e, 'response') and e.response is not None:
+        print("Тело ответа с ошибкой:", e.response.json()) 

call_validation_promo_api.py

@@ -0,0 +1,63 @@
+import requests
+import json
+
+# Конфигурация API
+BASE_URL = "http://127.0.0.1:8001"
+API_KEY = "9efb2df0-03d7-4212-93db-0ae6418667e1" # API-ключ
+PROMOCODE = "brw0OMOz" 
+
+# Данные для запроса на валидацию промокода
+validation_data = {
+    "promocode": PROMOCODE,
+}
+
+# Эндпоинты
+token_endpoint = f"{BASE_URL}/token"
+validation_endpoint = f"{BASE_URL}/validationPromo"
+
+# Шаг 1: Получение JWT токена
+print(f"Отправка запроса на получение токена на {token_endpoint}")
+token_headers = {
+    "X-API-Key": API_KEY,
+    "Content-Type": "application/json"
+}
+
+try:
+    token_response = requests.post(token_endpoint, headers=token_headers)
+    token_response.raise_for_status()
+
+    token_data = token_response.json()
+    jwt_token = token_data["access_token"]
+    print("JWT токен успешно получен.")
+
+except requests.exceptions.RequestException as e:
+    print(f"Произошла ошибка при получении токена: {e}")
+    if hasattr(e, 'response') and e.response is not None:
+        try:
+            print("Тело ответа с ошибкой:", e.response.json())
+        except json.JSONDecodeError:
+            print("Тело ответа с ошибкой (не JSON):", e.response.text)
+    exit() # Прерываем выполнение, если не удалось получить токен
+
+# Шаг 2: Вызов эндпоинта /validationPromo с использованием полученного JWT токена
+headers_with_jwt = {
+    "Authorization": f"Bearer {jwt_token}",
+    "Content-Type": "application/json"
+}
+
+print(f"Отправка запроса на {validation_endpoint} с данными: {validation_data}")
+
+try:
+    validation_response = requests.post(validation_endpoint, headers=headers_with_jwt, data=json.dumps(validation_data))
+    validation_response.raise_for_status()  # Вызовет исключение для ошибок HTTP (4xx или 5xx)
+
+    print("Статус ответа:", validation_response.status_code)
+    print("Тело ответа:", validation_response.json())
+
+except requests.exceptions.RequestException as e:
+    print(f"Произошла ошибка при вызове API validationPromo: {e}")
+    if hasattr(e, 'response') and e.response is not None:
+        try:
+            print("Тело ответа с ошибкой:", e.response.json())
+        except json.JSONDecodeError:
+            print("Тело ответа с ошибкой (не JSON):", e.response.text) 

fill_db.py

@@ -1,11 +1,12 @@
 import random
 from uuid import uuid4
 from sqlmodel import Session
-from main import AUTH_DB_ENGINE, TgAgent, Ref, Sale, Transaction, Account
+from sql_models import TgAgent, Ref, Sale, Account, Company, AgentTransaction, PartnerTransaction, CompanyBalance, AgentBalance, IntegrationToken, SaleCategory
 from sqlalchemy import text
 from datetime import datetime, timedelta
 from hashlib import sha256
-from passlib.context import CryptContext
+from helpers_bff import AUTH_DB_ENGINE, get_password_hash
+import string
 
 
 # Константа: список user_ids
@@ -63,11 +64,6 @@ LOGINS = [
 ALL_DESCRIPTIONS = DESCRIPTIONS 
 
 # ---
-pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
-
-def get_password_hash(password):
-    return pwd_context.hash(password)
-
 def get_date_list(days=7):
     today = datetime.utcnow().replace(hour=0, minute=0, second=0, microsecond=0)
     return [today - timedelta(days=i) for i in range(days, -1, -1)]
@@ -76,27 +72,77 @@ def fill_db():
     date_list = get_date_list(7)  # 8 дней: от недели назад до сегодня
     with Session(AUTH_DB_ENGINE) as session:
         # Очистка таблиц
+        # session.execute(text("DELETE FROM promocode"))
         session.execute(text("DELETE FROM sale"))
         session.execute(text("DELETE FROM ref"))
         session.execute(text("DELETE FROM tgagent"))
         session.execute(text("DELETE FROM account"))
+        session.execute(text('DELETE FROM "agent_transactions"'))
+        session.execute(text('DELETE FROM "partner_transactions"'))
+        session.execute(text('DELETE FROM "company_balances"'))
+        session.execute(text('DELETE FROM "agent_balances"'))
+        session.execute(text("DELETE FROM salecategory"))
+        session.execute(text("DELETE FROM company"))
         session.commit()
-        # 0. Accounts
+        # 0. Company
+        company = Company(
+            name="RE: Premium",
+            commission=0.0,
+            key="re-premium-key",
+        )
+        session.add(company)
+        session.commit()
+        session.refresh(company)
+
+        # 0.1 IntegrationTokens
+        for _ in range(3): # Создаем 3 токена для каждой компании
+            new_token_value = str(uuid4()) # Генерируем уникальный токен
+            token_hash = sha256(new_token_value.encode()).hexdigest() # Хешируем токен для хранения
+            masked_token = new_token_value[:5] + "***********************" + new_token_value[-4:] # Генерируем замаскированный токен
+
+            integration_token = IntegrationToken(
+                description=random.choice(DESCRIPTIONS), # Используем существующие описания
+                token_hash=token_hash,
+                masked_token=masked_token,
+                company_id=company.id,
+                use_dttm=random.choice(date_list) if random.random() < 0.7 else None # Пример: 70% токенов будут иметь дату использования
+            )
+            session.add(integration_token)
+        session.commit()
+
+        # 0.2 SaleCategory
+        sale_categories = [
+            SaleCategory(category="basic", description="Базовая продажа", perc=10.0, company_id=company.id),
+            SaleCategory(category="premium", description="Премиум продажа", perc=20.0, company_id=company.id),
+            SaleCategory(category="vip", description="VIP продажа", perc=30.0, company_id=company.id),
+        ]
+        for cat in sale_categories:
+            session.add(cat)
+        session.commit()
+        for cat in sale_categories:
+            session.refresh(cat)
+
+        # 1. Accounts
         accounts = []
         for i in range(4):
+            name_parts = NAMES[i % len(NAMES)].split()
+            first_name = name_parts[0]
+            surname = name_parts[1] if len(name_parts) > 1 else 'Тестов'
             acc = Account(
                 login=f"user{i+1}",
-                password_hash=get_password_hash("password123"),  # теперь храним хеш
-                name=NAMES[i % len(NAMES)],
+                password_hash=get_password_hash("password123"),
+                firstName=first_name,
+                surname=surname,
+                phone=PHONES[i % len(PHONES)],
                 email=f"user{i+1}@example.com",
-                balance=round(random.uniform(1000, 10000), 2)
+                company_id=company.id
             )
             session.add(acc)
             accounts.append(acc)
         session.commit()
         for acc in accounts:
             session.refresh(acc)
-        # 1. TgAgents
+        # 2. TgAgents
         tg_agents = []
         for i, tg_agent_id in enumerate(USER_IDS):
             dt = random.choice(date_list)
@@ -107,6 +153,7 @@ def fill_db():
                 phone=PHONES[i % len(PHONES)],
                 name=NAMES[i % len(NAMES)],
                 login=LOGINS[i % len(LOGINS)],
+                company_id=company.id,
                 create_dttm=dt,
                 update_dttm=dt,
                 hash=hash_value
@@ -116,20 +163,28 @@ def fill_db():
         session.commit()
         for tg_agent in tg_agents:
             session.refresh(tg_agent)
-
-        # 2. Refs (минимум 22 на агента)
+        # Отладка: количество агентов
+        agent_count = session.execute(text("SELECT COUNT(*) FROM tgagent")).scalar()
+        print(f'Агентов в базе: {agent_count}')
+        # 3. Refs (минимум 22 на агента)
         refs = []
         desc_count = len(ALL_DESCRIPTIONS)
+        alphabet = string.ascii_letters + string.digits + "!@#$%^&*"
         for tg_agent in tg_agents:
             ref_count = random.randint(22, int(22 * 1.25))  # от 22 до 27
             for j in range(ref_count):
                 ref_val = str(uuid4())
                 desc_val = ALL_DESCRIPTIONS[(j % desc_count)]
                 dt = random.choice(date_list)
+                promocode = ''.join(random.choices(alphabet, k=8))
+                # Проверяем уникальность промокода среди уже созданных рефов
+                while any(r.promocode == promocode for r in refs):
+                    promocode = ''.join(random.choices(alphabet, k=8))
                 ref = Ref(
                     tg_agent_id=tg_agent.id,
                     ref=ref_val,
                     description=desc_val,
+                    promocode=promocode,
                     create_dttm=dt,
                     update_dttm=dt
                 )
@@ -138,47 +193,141 @@ def fill_db():
         session.commit()
         for ref in refs:
             session.refresh(ref)
-
-        # 3. Sales (минимум 20 на каждый ref)
+        # 4. Sales (минимум 20 на каждый ref)
+        all_categories = session.query(SaleCategory).filter_by(company_id=company.id).all()
         for ref in refs:
             sale_count = random.randint(20, int(20 * 1.25))  # от 20 до 25
-            for _ in range(sale_count):
+            group_size = 5
+            group_sale_ids = [str(uuid4()) for _ in range((sale_count // group_size) + 1)]
+            for idx in range(sale_count):
                 cost = round(random.uniform(100, 1000), 2)
-                crediting = round(cost * random.uniform(0.5, 1.0), 2)
-                dt = random.choice(date_list)
+                sale_category = random.choice(all_categories)
+                crediting = round(cost * (sale_category.perc / 100.0), 2)
+                # Генерируем случайную дату и время в пределах последних 7 дней
+                end_dttm = datetime.utcnow()
+                start_dttm = end_dttm - timedelta(days=7)
+                time_diff = end_dttm - start_dttm
+                random_seconds = random.uniform(0, time_diff.total_seconds())
+                sale_dttm = start_dttm + timedelta(seconds=random_seconds)
+                group_sale_id = group_sale_ids[idx // group_size]
                 sale = Sale(
                     cost=cost,
                     crediting=crediting,
                     ref=ref.id,
                     sale_id=str(uuid4()),
-                    create_dttm=dt,
-                    update_dttm=dt
+                    group_sale_id=group_sale_id,
+                    company_id=company.id,
+                    category=sale_category.id,
+                    sale_dttm=sale_dttm,
+                    create_dttm=sale_dttm, # create_dttm также будет случайным в этом диапазоне
+                    update_dttm=sale_dttm  # update_dttm также будет случайным в этом диапазоне
                 )
                 session.add(sale)
         session.commit()
+        # 5. Заполнение новых таблиц
+        # 5.1 CompanyBalance
+        company_balance = CompanyBalance(
+            company_id=company.id,
+            available_balance=round(random.uniform(10000, 50000), 2),
+            pending_balance=round(random.uniform(1000, 10000), 2),
+            updated_dttm=datetime.utcnow()
+        )
+        session.add(company_balance)
+        session.commit()
+        session.refresh(company_balance)
 
-        # 4. Transactions (только withdrawal на агента)
-        TRANSACTION_STATUSES = ['process', 'done', 'error', 'waiting']
+        # 5.2 AgentBalances
+        agent_balances = []
         for tg_agent in tg_agents:
-            withdrawal_count = random.randint(5, int(5 * 1.25))  # от 5 до 6
-            used_statuses = set()
-            for i in range(withdrawal_count):
             dt = random.choice(date_list)
-                # Гарантируем, что каждый статус будет использован хотя бы раз
-                if len(used_statuses) < len(TRANSACTION_STATUSES):
-                    status = TRANSACTION_STATUSES[len(used_statuses)]
-                    used_statuses.add(status)
-                else:
-                    status = random.choice(TRANSACTION_STATUSES)
-                transaction = Transaction(
-                    transaction_id=str(uuid4()),
-                    sum=round(random.uniform(200, 3000), 2),
+            agent_balance = AgentBalance(
                 tg_agent_id=tg_agent.id,
-                    status=status,
+                available_balance=round(random.uniform(100, 5000), 2),
+                frozen_balance=round(random.uniform(0, 1000), 2),
+                updated_dttm=dt
+            )
+            session.add(agent_balance)
+            agent_balances.append(agent_balance)
+        session.commit()
+        for balance in agent_balances:
+            session.refresh(balance)
+
+        # 5.3 AgentTransactions and PartnerTransactions
+        AGENT_TRANSACTION_STATUSES = ['waiting', 'process', 'done', 'reject', 'error', 'new']
+        PARTNER_TRANSACTION_TYPES = ['deposit', 'agent_payout', 'service_fee']
+        PARTNER_TRANSACTION_STATUSES = ['process', 'done', 'error', 'new']
+
+        waiting_transactions_to_ensure = 7
+        waiting_transactions_count = 0
+
+        for tg_agent in tg_agents:
+            # Генерируем несколько групп транзакций для каждого агента
+            for _ in range(random.randint(3, 6)): # От 3 до 6 групп на агента
+                transaction_group_id = uuid4()
+                dt = random.choice(date_list)
+                agent_trans_amount = round(random.uniform(500, 3000), 2)
+
+                if waiting_transactions_count < waiting_transactions_to_ensure:
+                    agent_trans_status = 'waiting'
+                    waiting_transactions_count += 1
+                else:
+                    agent_trans_status = random.choice(AGENT_TRANSACTION_STATUSES)
+
+                # Создаем AgentTransaction
+                agent_transaction = AgentTransaction(
+                    tg_agent_id=tg_agent.id,
+                    amount=agent_trans_amount,
+                    status=agent_trans_status,
+                    transaction_group=transaction_group_id,
                     create_dttm=dt,
                     update_dttm=dt
                 )
-                session.add(transaction)
+                session.add(agent_transaction)
+                session.commit()
+                session.refresh(agent_transaction)
+
+                # Создаем соответствующие PartnerTransactions
+                # Для каждой AgentTransaction создаем PartnerTransaction типа 'agent_payout'
+                if agent_trans_status != 'waiting': # Создаем партнерскую транзакцию только если агентская не в статусе 'waiting'
+                     # Добавляем PartnerTransaction для выплаты агенту
+                    partner_payout = PartnerTransaction(
+                        company_id=company.id,
+                        type='agent_payout',
+                        amount=agent_trans_amount,
+                        status=random.choice([s for s in PARTNER_TRANSACTION_STATUSES if s != 'process']) if agent_trans_status in ['done', 'error', 'reject'] else 'process', # Статус зависит от статуса агентской
+                        transaction_group=transaction_group_id,
+                        agent_transaction_id=agent_transaction.id,
+                        create_dttm=dt,
+                        update_dttm=dt
+                    )
+                    session.add(partner_payout)
+
+
+                # Добавляем другие типы PartnerTransactions для разнообразия
+                if random.random() < 0.5: # 50% шанс добавить депозит
+                    partner_deposit = PartnerTransaction(
+                        company_id=company.id,
+                        type='deposit',
+                        amount=round(random.uniform(1000, 10000), 2),
+                        status=random.choice(PARTNER_TRANSACTION_STATUSES),
+                        transaction_group=uuid4(), # Новая группа для независимых транзакций
+                        create_dttm=dt,
+                        update_dttm=dt
+                    )
+                    session.add(partner_deposit)
+
+                if random.random() < 0.3: # 30% шанс добавить комиссию
+                    partner_fee = PartnerTransaction(
+                        company_id=company.id,
+                        type='service_fee',
+                        amount=round(random.uniform(50, 500), 2),
+                        status=random.choice(PARTNER_TRANSACTION_STATUSES),
+                        transaction_group=uuid4(), # Новая группа
+                        create_dttm=dt,
+                        update_dttm=dt
+                    )
+                    session.add(partner_fee)
+
         session.commit()
     print("База успешно заполнена!")
 

generate_sql.py

@@ -0,0 +1,22 @@
+from sqlmodel import SQLModel
+from helpers_bff import AUTH_DB_ENGINE
+from sqlalchemy.schema import CreateTable
+import os
+
+# --- Отладочный вывод ---
+print("Таблицы в metadata:", SQLModel.metadata.sorted_tables)
+print("Все зарегистрированные модели:", SQLModel.__subclasses__())
+
+# --- Генерация и сохранение SQL-скрипта создания таблиц ---
+def get_sql_create_script():
+    script = []
+    for table in SQLModel.metadata.sorted_tables:
+        create_table_sql = str(CreateTable(table).compile(dialect=AUTH_DB_ENGINE.dialect))
+        script.append(f"{create_table_sql};")
+    return "\n\n".join(script)
+
+sql_script = get_sql_create_script()
+sql_file_path = os.path.join(os.path.dirname(__file__), "sql_create.sql")
+with open(sql_file_path, "w", encoding="utf-8") as f:
+    f.write(sql_script)
+print("SQL-скрипт успешно сгенерирован!") 

helpers_bff.py

@@ -0,0 +1,142 @@
+from sqlmodel import Session, select, create_engine
+from passlib.context import CryptContext
+from typing import Optional
+from datetime import datetime, timedelta
+from bff_models import Token, TransactionStatus
+from sql_models import Company, TgAgent, Account, AgentBalance, AgentTransaction, PartnerTransaction, Sale, Ref, IntegrationToken, CompanyBalance
+from hashlib import sha256
+import jwt
+from jwt.exceptions import InvalidTokenError
+from fastapi import HTTPException, status, Depends, Request, Header
+from fastapi.security import OAuth2PasswordBearer
+import hashlib
+
+# Конфигурация
+AUTH_DATABASE_ADDRESS = "sqlite:///partner.db"
+AUTH_DB_ENGINE = create_engine(AUTH_DATABASE_ADDRESS, echo=True)
+
+SECRET_KEY = "supersecretkey"
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 60
+
+# JWT Configuration for Integration API
+INTEGRATION_SECRET_KEY = "your-super-secret-jwt-key"  # TODO: Замените на реальный секретный ключ из переменных окружения
+INTEGRATION_ALGORITHM = "HS256"
+INTEGRATION_ACCESS_TOKEN_EXPIRE_MINUTES = 60 * 24 * 7 # Токен действителен 7 дней
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/token")
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+def get_integration_db():
+    with Session(AUTH_DB_ENGINE) as session:
+        yield session
+
+def create_integration_jwt_token(company_id: int):
+    expires = datetime.utcnow() + timedelta(minutes=INTEGRATION_ACCESS_TOKEN_EXPIRE_MINUTES)
+    payload = {
+        "sub": str(company_id),
+        "exp": expires,
+        "type": "access"
+    }
+    return jwt.encode(payload, INTEGRATION_SECRET_KEY, algorithm=INTEGRATION_ALGORITHM)
+
+async def get_current_company_from_jwt(
+    token: str = Depends(OAuth2PasswordBearer(tokenUrl="/token")),
+    db: Session = Depends(get_integration_db)
+):
+    """
+    Зависимость для получения текущей компании на основе JWT токена для Integration API.
+    """
+    try:
+        payload = jwt.decode(token, INTEGRATION_SECRET_KEY, algorithms=[INTEGRATION_ALGORITHM])
+        company_id: int = int(payload.get("sub"))
+        if company_id is None:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Недействительная полезная нагрузка токена",
+                headers={"WWW-Authenticate": "Bearer"},
+            )
+        company = db.exec(select(Company).where(Company.id == company_id)).first()
+        if not company:
+            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Компания не найдена")
+        return company
+    except InvalidTokenError:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Недействительный токен",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    except jwt.ExpiredSignatureError:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Срок действия токена истек",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+def get_tg_agent_by_tg_id(db: Session, tg_id: int) -> Optional[TgAgent]:
+    statement = select(TgAgent).where(TgAgent.tg_id == tg_id)
+    return db.exec(statement).first()
+
+def get_db():
+    with Session(AUTH_DB_ENGINE) as session:
+        yield session
+
+def get_current_account(token: str = Depends(oauth2_scheme), db: Session = Depends(get_db)):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        login: str = payload.get("sub")
+        if login is None:
+            raise credentials_exception
+    except InvalidTokenError:
+        raise credentials_exception
+    account = get_account_by_login(db, login)
+    if account is None:
+        raise credentials_exception
+    return account
+
+async def get_current_tg_agent(request: Request, db: Session = Depends(get_db)):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    auth_header = request.headers.get("Authorization")
+    if not auth_header or not auth_header.startswith("Bearer "):
+        raise credentials_exception
+    hash_value = auth_header.replace("Bearer ", "").strip()
+    tg_agent = db.exec(select(TgAgent).where(TgAgent.hash == hash_value)).first()
+    if tg_agent is None:
+        raise credentials_exception
+    return tg_agent
+
+def authenticate_tg_agent(engine, tg_id: int):
+    with Session(engine) as db:
+        tg_agent = get_tg_agent_by_tg_id(db, tg_id)
+        if not tg_agent:
+            return None
+        return tg_agent
+
+def create_access_token(data: dict, expires_delta: timedelta = None):
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(minutes=15)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return encoded_jwt
+
+def verify_password(plain_password, hashed_password):
+    return pwd_context.verify(plain_password, hashed_password)
+
+def get_password_hash(password):
+    return pwd_context.hash(password)
+
+def get_account_by_login(db: Session, login: str) -> Optional[Account]:
+    statement = select(Account).where(Account.login == login)
+    return db.exec(statement).first() 

integration_api.py

@@ -0,0 +1,343 @@
+from fastapi import FastAPI, Depends, HTTPException, status, Header, Body, Request
+from sqlmodel import Session, select, Field
+from typing import Optional, List, Dict
+from datetime import datetime, timedelta
+import hashlib
+import uuid
+from random import choices
+import string
+
+from sql_models import Company, IntegrationToken, Ref, Sale, AgentTransaction, PartnerTransaction, AgentBalance, TgAgent, CompanyBalance, SaleCategory
+from integration_models import Token, SaleCreateRequest, SaleCreateResponse, TransactionStatus, WithdrawRequest, WithdrawResponse, PromoValidationRequest, PromoValidationResponse
+from bff_models import RegisterResponse, TgAuthResponse
+from tg_models import RefAddRequest, RefResponse, RefAddResponse, RefStatResponse, RegisterRequest, StatResponse
+from helpers_bff import AUTH_DB_ENGINE, get_integration_db, create_integration_jwt_token, get_current_company_from_jwt, get_tg_agent_by_tg_id, get_current_tg_agent
+
+app = FastAPI()
+
+#7c06945b-f4b8-4929-8350-b9841405a609
+
+
+@app.post("/token", tags=["integration"], response_model=Token)
+async def get_token_for_api_key(
+    x_api_key: str = Header(..., alias="X-API-Key"),
+    db: Session = Depends(get_integration_db)
+):
+    """
+    Обменивает API-ключ на JWT токен.
+    """
+
+    if not x_api_key:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="API-ключ не предоставлен",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    api_key_hash = hashlib.sha256(x_api_key.encode()).hexdigest()
+    integration_token_db = db.exec(
+        select(IntegrationToken).where(IntegrationToken.token_hash == api_key_hash)
+    ).first()
+
+    if not integration_token_db:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Неверный API-ключ",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    
+    # Обновляем use_dttm токена
+    integration_token_db.use_dttm = datetime.utcnow()
+    db.add(integration_token_db)
+    db.commit()
+    db.refresh(integration_token_db)
+
+    jwt_token = create_integration_jwt_token(integration_token_db.company_id)
+    return {"access_token": jwt_token, "token_type": "bearer"}
+
+@app.get("/ref", response_model=List[RefResponse], tags=["agent-tg"])
+def get_refs(current_tg_agent: TgAgent = Depends(get_current_tg_agent), db: Session = Depends(get_integration_db)):
+    """
+    Возвращает список реферальных ссылок текущего Telegram-агента.
+    """
+    refs = db.exec(select(Ref).where(Ref.tg_agent_id == current_tg_agent.id)).all()
+    return [RefResponse(ref=r.ref, description=r.description or "", promocode=r.promocode) for r in refs]
+
+@app.post("/ref/add", tags=["agent-tg"], response_model=RefAddResponse)
+def add_ref(req: RefAddRequest, current_tg_agent: TgAgent = Depends(get_current_tg_agent), db: Session = Depends(get_integration_db)):
+    """
+    Добавляет новую реферальную ссылку для текущего Telegram-агента.
+    """
+    # Генерация промокода (логика как была для промокодов)
+    alphabet = string.ascii_letters + string.digits + "!@#$%^&*"
+    promocode = ''.join(choices(alphabet, k=8))
+    while db.exec(select(Ref).where(Ref.promocode == promocode)).first():
+        promocode = ''.join(choices(alphabet, k=8))
+    new_ref = Ref(
+        tg_agent_id=current_tg_agent.id,
+        ref=str(uuid.uuid4()),
+        description=req.description,
+        promocode=promocode
+    )
+    db.add(new_ref)
+    db.commit()
+    db.refresh(new_ref)
+    return {"ref": new_ref.ref, "promocode": new_ref.promocode, "description": new_ref.description}
+
+@app.get("/ref/stat", tags=["agent-tg"], response_model=RefStatResponse)
+def get_ref_stat(current_tg_agent: TgAgent = Depends(get_current_tg_agent), db: Session = Depends(get_integration_db)):
+    """
+    Возвращает статистику по реферальным ссылкам текущего Telegram-агента.
+    """
+    # 1. Получаем все реферальные ссылки пользователя
+    refs = db.exec(select(Ref).where(Ref.tg_agent_id == current_tg_agent.id)).all()
+    result = []
+    for ref in refs:
+        # 2. Для каждой ссылки считаем продажи и сумму
+        sales = db.exec(select(Sale).where(Sale.ref == ref.id)).all()
+        sales_count = len(sales)
+        income = sum(sale.crediting for sale in sales)
+        result.append({
+            "description": ref.description or "",
+            "sales": sales_count,
+            "income": income
+        })
+    return {"refData": result}
+
+@app.get("/stat", tags=["agent-tg"], response_model=StatResponse)
+def get_stat(current_tg_agent: TgAgent = Depends(get_current_tg_agent), db: Session = Depends(get_integration_db)):
+    """
+    Возвращает общую статистику для текущего Telegram-агента.
+    """
+    # 1. Получаем все реферальные ссылки пользователя
+    refs = db.exec(select(Ref).where(Ref.tg_agent_id == current_tg_agent.id)).all()
+    ref_ids = [r.id for r in refs]
+
+    # 2. Считаем totalSales (продажи по всем рефам пользователя)
+    total_sales = db.exec(select(Sale).where(Sale.ref.in_(ref_ids))).all()
+    totalSales = len(total_sales)
+    totalIncome = sum(sale.crediting for sale in total_sales)
+    # Заменено получение доступного остатка из AgentBalance
+    agent_balance = db.exec(select(AgentBalance).where(AgentBalance.tg_agent_id == current_tg_agent.id)).first()
+    availableWithdrawal = agent_balance.available_balance if agent_balance else 0.0
+    return {
+        "totalSales": totalSales,
+        "totalIncome": totalIncome,
+        "availableWithdrawal": availableWithdrawal
+    }
+
+@app.post("/tg_auth", tags=["agent-tg"], response_model=TgAuthResponse)
+def tg_auth(hash: str = Body(..., embed=True), db: Session = Depends(get_integration_db)):
+    """
+    Авторизует Telegram-агента по хешу.
+    """
+    tg_agent = db.exec(select(TgAgent).where(TgAgent.hash == hash)).first()
+    if not tg_agent:
+        raise HTTPException(status_code=401, detail="Hash not found")
+    return {"msg": "Auth success", "tg_id": tg_agent.tg_id}
+
+@app.post("/withdraw", tags=["agent-tg"], response_model=WithdrawResponse)
+async def withdraw_funds(
+    req: WithdrawRequest,
+    db: Session = Depends(get_integration_db)
+):
+    """
+    Запрос на вывод средств для Telegram-агента.
+    """
+    tg_agent = db.exec(select(TgAgent).where(TgAgent.tg_id == req.tg_id)).first()
+    if not tg_agent:
+        raise HTTPException(status_code=404, detail="Telegram-агент не найден")
+
+    company = db.exec(select(Company).where(Company.id == tg_agent.company_id)).first()
+    if not company:
+        raise HTTPException(status_code=404, detail="Компания не найдена для агента")
+
+    if req.amount <= 0:
+        raise HTTPException(status_code=400, detail="Сумма для вывода должна быть положительной")
+
+    agent_balance = db.exec(select(AgentBalance).where(AgentBalance.tg_agent_id == tg_agent.id)).first()
+    if not agent_balance or agent_balance.available_balance < req.amount:
+        raise HTTPException(status_code=400, detail="Недостаточно средств на балансе для вывода")
+
+    # Определяем статус транзакции
+    transaction_status = TransactionStatus.WAITING
+    if company.auto_approve_transactions:
+        transaction_status = TransactionStatus.NEW
+
+    # Создаем запись AgentTransaction
+    new_agent_transaction = AgentTransaction(
+        tg_agent_id=tg_agent.id,
+        amount=req.amount,
+        status=transaction_status.value,
+        transaction_group=uuid.uuid4()
+    )
+    db.add(new_agent_transaction)
+
+
+    # Обновляем баланс агента
+    agent_balance.available_balance -= req.amount
+    if transaction_status == TransactionStatus.WAITING: # Если автоматически одобряется, переводим на замороженный баланс компании (т.е. компания должна выплатить)
+        agent_balance.frozen_balance += req.amount # Удерживаем средства, пока они не будут выведены
+    db.add(agent_balance)
+
+    db.commit()
+    db.refresh(new_agent_transaction)
+    db.refresh(agent_balance)
+
+    return {"msg": "Запрос на вывод средств успешно создан", "transaction_id": new_agent_transaction.transaction_group}
+
+@app.post("/sale", tags=["integration"], response_model=SaleCreateResponse)
+async def create_sale(
+    req: SaleCreateRequest,
+    company: Company = Depends(get_current_company_from_jwt),
+    db: Session = Depends(get_integration_db)
+):
+    """
+    Регистрирует новую продажу в системе.
+    """
+    # Устанавливаем уровень изоляции для текущей транзакции
+    db.connection(execution_options={'isolation_level': 'SERIALIZABLE'})
+
+    # Проверка входных данных
+    if not req.ref and not req.promocode:
+        raise HTTPException(status_code=400, detail="Необходимо передать либо ref, либо promocode")
+    if not req.category:
+        raise HTTPException(status_code=400, detail="Необходимо передать category (id категории)")
+
+    # 1. Найти Ref по ref и/или promocode
+    referral = None
+    if req.ref and req.promocode:
+        referral_by_ref = db.exec(select(Ref).where(Ref.ref == req.ref)).first()
+        referral_by_code = db.exec(select(Ref).where(Ref.promocode == req.promocode)).first()
+        if not referral_by_ref or not referral_by_code:
+            raise HTTPException(status_code=404, detail="Реферальная ссылка или промокод не найдены")
+        if referral_by_ref.id != referral_by_code.id:
+            raise HTTPException(status_code=400, detail="ref и promocode не соответствуют одной ссылке")
+        referral = referral_by_ref
+    elif req.ref:
+        referral = db.exec(select(Ref).where(Ref.ref == req.ref)).first()
+        if not referral:
+            raise HTTPException(status_code=404, detail="Реферальная ссылка не найдена")
+    elif req.promocode:
+        referral = db.exec(select(Ref).where(Ref.promocode == req.promocode)).first()
+        if not referral:
+            raise HTTPException(status_code=404, detail="Промокод не найден")
+
+    # Проверяем, что реф действительно принадлежит компании
+    tg_agent = db.exec(select(TgAgent).where(TgAgent.id == referral.tg_agent_id, TgAgent.company_id == company.id)).first()
+    if not tg_agent:
+        raise HTTPException(status_code=404, detail="Реферальная ссылка не принадлежит данной компании")
+
+    # 2. Проверить, что sale_id уникален для данной компании
+    existing_sale = db.exec(
+        select(Sale)
+        .where(Sale.company_id == company.id)
+        .where(Sale.sale_id == req.sale_id)
+    ).first()
+    if existing_sale:
+        raise HTTPException(status_code=400, detail="Продажа с таким sale_id уже существует для данной компании")
+
+    # 3. Найти категорию и рассчитать crediting
+    sale_category = db.exec(select(SaleCategory).where(SaleCategory.category == req.category, SaleCategory.company_id == company.id)).first()
+    if not sale_category:
+        raise HTTPException(status_code=404, detail="Категория продажи не найдена")
+    crediting_amount = req.cost * (sale_category.perc / 100.0)
+
+    # 4. Проверить и обновить AgentBalance и CompanyBalance
+    agent_balance = db.exec(select(AgentBalance).where(AgentBalance.tg_agent_id == tg_agent.id)).first()
+    if not agent_balance:
+        raise HTTPException(status_code=404, detail="Баланс агента не найден")
+    company_balance = db.exec(select(CompanyBalance).where(CompanyBalance.company_id == company.id)).first()
+    if not company_balance:
+        raise HTTPException(status_code=404, detail="Баланс компании не найден")
+
+    # 5. Создать Sale
+    new_sale = Sale(
+        cost=req.cost,
+        crediting=crediting_amount,
+        ref=referral.id,
+        sale_id=req.sale_id,
+        group_sale_id=req.group_sale_id,
+        company_id=company.id,
+        category=sale_category.id,
+        sale_dttm=datetime.utcnow()
+    )
+    db.add(new_sale)
+    # Создать AgentTransaction
+    agent_transaction_status = TransactionStatus.DONE
+    agent_transaction = AgentTransaction(
+        tg_agent_id=tg_agent.id,
+        amount=crediting_amount,
+        status=agent_transaction_status.value,
+        transaction_group=uuid.uuid4()
+    )
+    db.add(agent_transaction)
+    # Обновление балансов для продаж - всегда в замороженный/ожидающий баланс
+    agent_balance.frozen_balance += crediting_amount
+    company_balance.pending_balance -= crediting_amount
+    company_balance.updated_dttm = datetime.utcnow()
+
+    db.commit()
+    db.refresh(new_sale)
+    db.refresh(agent_balance)
+    db.refresh(company_balance)
+    db.refresh(agent_transaction)
+
+    return {
+        "msg": "Продажа успешно зарегистрирована",
+        "sale_id": new_sale.sale_id,
+        "crediting": new_sale.crediting
+    }
+
+@app.post("/validationPromo", tags=["integration"], response_model=PromoValidationResponse)
+async def validate_promocode(
+    req: PromoValidationRequest,
+    company: Company = Depends(get_current_company_from_jwt),
+    db: Session = Depends(get_integration_db)
+):
+    """
+    Проверяет валидность промокода для текущей компании.
+    """
+    referral = db.exec(select(Ref).where(Ref.promocode == req.promocode)).first()
+    if not referral:
+        return {"validation": False}
+
+    tg_agent = db.exec(select(TgAgent).where(TgAgent.id == referral.tg_agent_id, TgAgent.company_id == company.id)).first()
+    if not tg_agent:
+        return {"validation": False}
+
+    return {"validation": True}
+
+@app.post("/register", tags=["agent-tg"], response_model=RegisterResponse)
+def register(req: RegisterRequest, db: Session = Depends(get_integration_db)):
+    """
+    Регистрирует нового Telegram-агента в системе.
+    """
+    tg_id = req.tg_id
+    chat_id = req.chat_id
+    phone = req.phone
+    name = getattr(req, 'name', None)
+    login = getattr(req, 'login', None)
+    company_key = req.company_key
+    print(f'tg_id: {tg_id}, chat_id: {chat_id}, phone: {phone}, name: {name}, login: {login}, company_key: {company_key}')
+    tg_agent = get_tg_agent_by_tg_id(db, tg_id)
+    if tg_agent:
+        raise HTTPException(status_code=400, detail="tg_id already registered")
+    # Поиск компании по ключу
+    company = db.exec(select(Company).where(Company.key == company_key)).first()
+    if not company:
+        raise HTTPException(status_code=400, detail="Компания с таким ключом не найдена")
+    hash_value = hashlib.sha256(f"{tg_id}sold".encode()).hexdigest()
+    new_tg_agent = TgAgent(
+        tg_id=tg_id,
+        chat_id=chat_id,
+        phone=phone,
+        name=name,
+        login=login,
+        hash=hash_value,
+        company_id=company.id
+    )
+    db.add(new_tg_agent)
+    db.commit()
+    db.refresh(new_tg_agent)
+    return {"msg": "TgAgent registered successfully"}

integration_models.py

@@ -0,0 +1,51 @@
+from typing import Optional
+from datetime import datetime
+from pydantic import BaseModel
+import uuid
+from enum import Enum
+
+# Models for /token endpoint
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+class IntegrationTokenResponse(BaseModel):
+    msg: str
+    company_name: str
+    company_key: str
+
+# Models for /sale endpoint
+class SaleCreateRequest(BaseModel):
+    ref: Optional[str] = None
+    promocode: Optional[str] = None
+    sale_id: str
+    cost: float
+    category: str  # название категории продажи
+    group_sale_id: str  # новое поле для группировки продаж
+
+class SaleCreateResponse(BaseModel):
+    msg: str
+    sale_id: str
+    crediting: float
+
+class WithdrawRequest(BaseModel):
+    tg_id: int
+    amount: float
+
+class WithdrawResponse(BaseModel):
+    msg: str
+    transaction_id: uuid.UUID
+
+class TransactionStatus(str, Enum):
+    NEW = "new"
+    PROCESS = "process"
+    WAITING = "waiting"
+    DONE = "done"
+    CANCELED = "canceled"
+    ERROR = "error"
+
+class PromoValidationRequest(BaseModel):
+    promocode: str
+
+class PromoValidationResponse(BaseModel):
+    validation: bool 

models.py

@@ -1,31 +0,0 @@
-from pydantic import BaseModel, Field
-from typing import Optional
-
-from sqlmodel import SQLModel
-
-
-
-
-
-
-#API models
-class Token(BaseModel):
-    access_token: str
-    token_type: str 
-
-class RefResponse(BaseModel):
-    ref: str
-    description: str
-
-class RefAddRequest(BaseModel):
-    description: str
-
-class TokenRequest(BaseModel):
-    tg_id: int
-
-class RegisterRequest(BaseModel):
-    tg_id: int
-    chat_id: Optional[int] = None
-    phone: Optional[str] = None
-    name: Optional[str] = None
-    login: Optional[str] = None

requirements.txt

@@ -1,146 +1,54 @@
-# This file was autogenerated by uv via the following command:
-#    uv pip compile pyproject.toml -o requirements.txt
 annotated-types==0.7.0
-    # via pydantic
 anyio==4.8.0
-    # via
-    #   httpx
-    #   starlette
-    #   watchfiles
 bcrypt==4.2.1
-    # via passlib
 behave==1.2.6
-    # via epai-auth (pyproject.toml)
 certifi==2024.12.14
-    # via
-    #   httpcore
-    #   httpx
-    #   requests
 cffi==1.17.1
-    # via cryptography
 charset-normalizer==3.4.2
-    # via requests
 click==8.1.8
-    # via
-    #   rich-toolkit
-    #   typer
-    #   uvicorn
+colorama==0.4.6
 cryptography==44.0.0
-    # via epai-auth (pyproject.toml)
 dnspython==2.7.0
-    # via email-validator
 email-validator==2.2.0
-    # via fastapi
 fastapi==0.115.6
-    # via epai-auth (pyproject.toml)
 fastapi-cli==0.0.7
-    # via fastapi
 greenlet==3.1.1
-    # via sqlalchemy
 h11==0.14.0
-    # via
-    #   httpcore
-    #   uvicorn
 httpcore==1.0.7
-    # via httpx
 httptools==0.6.4
-    # via uvicorn
 httpx==0.28.1
-    # via fastapi
 idna==3.10
-    # via
-    #   anyio
-    #   email-validator
-    #   httpx
-    #   requests
 jinja2==3.1.5
-    # via fastapi
 markdown-it-py==3.0.0
-    # via rich
 markupsafe==3.0.2
-    # via jinja2
 mdurl==0.1.2
-    # via markdown-it-py
 parse==1.20.2
-    # via
-    #   behave
-    #   parse-type
 parse-type==0.6.4
-    # via behave
 passlib==1.7.4
-    # via epai-auth (pyproject.toml)
 psycopg2==2.9.10
-    # via epai-auth (pyproject.toml)
 pycparser==2.22
-    # via cffi
 pydantic==2.10.5
-    # via
-    #   fastapi
-    #   pydantic-settings
-    #   sqlmodel
 pydantic-core==2.27.2
-    # via pydantic
 pydantic-settings==2.9.1
-    # via epai-auth (pyproject.toml)
 pygments==2.19.1
-    # via rich
 pyjwt==2.10.1
-    # via epai-auth (pyproject.toml)
 python-dotenv==1.0.1
-    # via
-    #   pydantic-settings
-    #   uvicorn
 python-multipart==0.0.20
-    # via fastapi
 pyyaml==6.0.2
-    # via uvicorn
 requests==2.32.3
-    # via epai-auth (pyproject.toml)
 rich==13.9.4
-    # via
-    #   rich-toolkit
-    #   typer
 rich-toolkit==0.12.0
-    # via fastapi-cli
 ruff==0.9.1
-    # via epai-auth (pyproject.toml)
 shellingham==1.5.4
-    # via typer
 six==1.17.0
-    # via
-    #   behave
-    #   parse-type
 sniffio==1.3.1
-    # via anyio
 sqlalchemy==2.0.37
-    # via sqlmodel
 sqlmodel==0.0.22
-    # via epai-auth (pyproject.toml)
 starlette==0.41.3
-    # via fastapi
 typer==0.15.1
-    # via fastapi-cli
 typing-extensions==4.12.2
-    # via
-    #   anyio
-    #   fastapi
-    #   pydantic
-    #   pydantic-core
-    #   rich-toolkit
-    #   sqlalchemy
-    #   typer
-    #   typing-inspection
 typing-inspection==0.4.0
-    # via pydantic-settings
 urllib3==2.4.0
-    # via requests
 uvicorn==0.34.0
-    # via
-    #   fastapi
-    #   fastapi-cli
-#uvloop==0.21.0
-    # via uvicorn
 watchfiles==1.0.4
-    # via uvicorn
 websockets==14.1
-    # via uvicorn

sql_create.sql

@@ -0,0 +1,179 @@
+
+CREATE TABLE company (
+	id INTEGER NOT NULL, 
+	name VARCHAR NOT NULL, 
+	commission FLOAT NOT NULL, 
+	agent_commission FLOAT NOT NULL, 
+	"key" VARCHAR NOT NULL, 
+	create_dttm DATETIME NOT NULL, 
+	update_dttm DATETIME NOT NULL, 
+	auto_approve_transactions BOOLEAN NOT NULL, 
+	PRIMARY KEY (id)
+)
+
+;
+
+
+CREATE TABLE account (
+	id INTEGER NOT NULL, 
+	login VARCHAR NOT NULL, 
+	password_hash VARCHAR NOT NULL, 
+	"firstName" VARCHAR, 
+	surname VARCHAR, 
+	phone VARCHAR, 
+	email VARCHAR, 
+	company_id INTEGER NOT NULL, 
+	create_dttm DATETIME NOT NULL, 
+	update_dttm DATETIME NOT NULL, 
+	PRIMARY KEY (id), 
+	FOREIGN KEY(company_id) REFERENCES company (id)
+)
+
+;
+
+
+CREATE TABLE company_balances (
+	id INTEGER NOT NULL, 
+	company_id INTEGER NOT NULL, 
+	available_balance FLOAT NOT NULL, 
+	pending_balance FLOAT NOT NULL, 
+	updated_dttm DATETIME NOT NULL, 
+	PRIMARY KEY (id), 
+	UNIQUE (company_id), 
+	FOREIGN KEY(company_id) REFERENCES company (id)
+)
+
+;
+
+
+CREATE TABLE integrationtoken (
+	id INTEGER NOT NULL, 
+	description VARCHAR NOT NULL, 
+	token_hash VARCHAR, 
+	masked_token VARCHAR, 
+	company_id INTEGER NOT NULL, 
+	create_dttm DATETIME NOT NULL, 
+	update_dttm DATETIME NOT NULL, 
+	use_dttm DATETIME, 
+	PRIMARY KEY (id), 
+	FOREIGN KEY(company_id) REFERENCES company (id)
+)
+
+;
+
+
+CREATE TABLE salecategory (
+	id INTEGER NOT NULL, 
+	category VARCHAR NOT NULL, 
+	description VARCHAR, 
+	perc FLOAT NOT NULL, 
+	company_id INTEGER NOT NULL, 
+	create_dttm DATETIME NOT NULL, 
+	update_dttm DATETIME NOT NULL, 
+	PRIMARY KEY (id), 
+	FOREIGN KEY(company_id) REFERENCES company (id)
+)
+
+;
+
+
+CREATE TABLE tgagent (
+	id INTEGER NOT NULL, 
+	tg_id INTEGER NOT NULL, 
+	chat_id INTEGER, 
+	phone VARCHAR, 
+	name VARCHAR, 
+	login VARCHAR, 
+	hash VARCHAR, 
+	company_id INTEGER NOT NULL, 
+	create_dttm DATETIME NOT NULL, 
+	update_dttm DATETIME NOT NULL, 
+	PRIMARY KEY (id), 
+	FOREIGN KEY(company_id) REFERENCES company (id)
+)
+
+;
+
+
+CREATE TABLE agent_balances (
+	id INTEGER NOT NULL, 
+	tg_agent_id INTEGER NOT NULL, 
+	available_balance FLOAT NOT NULL, 
+	frozen_balance FLOAT NOT NULL, 
+	updated_dttm DATETIME NOT NULL, 
+	PRIMARY KEY (id), 
+	UNIQUE (tg_agent_id), 
+	FOREIGN KEY(tg_agent_id) REFERENCES tgagent (id)
+)
+
+;
+
+
+CREATE TABLE agent_transactions (
+	id INTEGER NOT NULL, 
+	tg_agent_id INTEGER NOT NULL, 
+	amount FLOAT NOT NULL, 
+	status VARCHAR NOT NULL, 
+	transaction_group CHAR(32) NOT NULL, 
+	create_dttm DATETIME NOT NULL, 
+	update_dttm DATETIME NOT NULL, 
+	PRIMARY KEY (id), 
+	FOREIGN KEY(tg_agent_id) REFERENCES tgagent (id), 
+	UNIQUE (transaction_group)
+)
+
+;
+
+
+CREATE TABLE ref (
+	id INTEGER NOT NULL, 
+	tg_agent_id INTEGER NOT NULL, 
+	ref VARCHAR NOT NULL, 
+	description VARCHAR, 
+	promocode VARCHAR(8) NOT NULL, 
+	create_dttm DATETIME NOT NULL, 
+	update_dttm DATETIME NOT NULL, 
+	PRIMARY KEY (id), 
+	FOREIGN KEY(tg_agent_id) REFERENCES tgagent (id)
+)
+
+;
+
+
+CREATE TABLE partner_transactions (
+	id INTEGER NOT NULL, 
+	company_id INTEGER NOT NULL, 
+	type VARCHAR NOT NULL, 
+	amount FLOAT NOT NULL, 
+	status VARCHAR NOT NULL, 
+	transaction_group CHAR(32) NOT NULL, 
+	agent_transaction_id INTEGER, 
+	create_dttm DATETIME NOT NULL, 
+	update_dttm DATETIME NOT NULL, 
+	PRIMARY KEY (id), 
+	FOREIGN KEY(company_id) REFERENCES company (id), 
+	FOREIGN KEY(agent_transaction_id) REFERENCES agent_transactions (id)
+)
+
+;
+
+
+CREATE TABLE sale (
+	id INTEGER NOT NULL, 
+	cost FLOAT NOT NULL, 
+	crediting FLOAT NOT NULL, 
+	ref INTEGER NOT NULL, 
+	sale_id VARCHAR NOT NULL, 
+	group_sale_id VARCHAR NOT NULL, 
+	company_id INTEGER NOT NULL, 
+	category INTEGER NOT NULL, 
+	sale_dttm DATETIME NOT NULL, 
+	create_dttm DATETIME NOT NULL, 
+	update_dttm DATETIME NOT NULL, 
+	PRIMARY KEY (id), 
+	FOREIGN KEY(ref) REFERENCES ref (id), 
+	FOREIGN KEY(company_id) REFERENCES company (id), 
+	FOREIGN KEY(category) REFERENCES salecategory (id)
+)
+
+;

sql_models.py

@@ -0,0 +1,155 @@
+from typing import Optional, List
+from datetime import datetime
+import uuid
+from sqlmodel import SQLModel, Field, Relationship
+from sqlalchemy import Column, String
+
+class Company(SQLModel, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    name: str
+    commission: float  # процент комиссии, который взымается за пользование сервисом
+    key: str = Field(index=True, unique=True)
+    create_dttm: datetime = Field(default_factory=datetime.utcnow)
+    update_dttm: datetime = Field(default_factory=datetime.utcnow)
+    auto_approve_transactions: bool = Field(default=False) # Отвечает за автоматическое одобрение агентских транзакций на вывод.
+
+    integration_tokens: List["IntegrationToken"] = Relationship(back_populates="company")
+    tg_agents: List["TgAgent"] = Relationship(back_populates="company")
+    sales: List["Sale"] = Relationship(back_populates="company")
+    partner_transactions: List["PartnerTransaction"] = Relationship(back_populates="company")
+    company_balance: Optional["CompanyBalance"] = Relationship(back_populates="company")
+    accounts: List["Account"] = Relationship(back_populates="company")
+    sale_categories: List["SaleCategory"] = Relationship(back_populates="company")
+
+class TgAgent(SQLModel, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    tg_id: int = Field(index=True, unique=True)
+    chat_id: Optional[int] = None
+    phone: Optional[str] = None
+    name: Optional[str] = None
+    login: Optional[str] = None
+    hash: Optional[str] = None
+    company_id: int = Field(foreign_key="company.id")
+    create_dttm: datetime = Field(default_factory=datetime.utcnow)
+    update_dttm: datetime = Field(default_factory=datetime.utcnow)
+
+    company: "Company" = Relationship(back_populates="tg_agents")
+    refs: List["Ref"] = Relationship(back_populates="tg_agent")
+    agent_transactions: List["AgentTransaction"] = Relationship(back_populates="tg_agent")
+    agent_balance: Optional["AgentBalance"] = Relationship(back_populates="tg_agent")
+
+class Ref(SQLModel, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    tg_agent_id: int = Field(foreign_key="tgagent.id")
+    ref: str
+    description: Optional[str] = None
+    promocode: str = Field(index=True, unique=True, max_length=8)
+    create_dttm: datetime = Field(default_factory=datetime.utcnow)
+    update_dttm: datetime = Field(default_factory=datetime.utcnow)
+
+    tg_agent: "TgAgent" = Relationship(back_populates="refs")
+    sales: List["Sale"] = Relationship(back_populates="ref_obj")
+
+class SaleCategory(SQLModel, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    category: str
+    description: Optional[str] = None
+    perc: float  # процент начисления партнеру
+    company_id: int = Field(foreign_key="company.id")
+    create_dttm: datetime = Field(default_factory=datetime.utcnow)
+    update_dttm: datetime = Field(default_factory=datetime.utcnow)
+    
+    company: "Company" = Relationship(back_populates="sale_categories")
+    sales: List["Sale"] = Relationship(back_populates="sale_category")
+
+class Sale(SQLModel, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    cost: float
+    crediting: float  # сколько начислено за продажу
+    ref: int = Field(foreign_key="ref.id")
+    sale_id: str 
+    group_sale_id: str  # новое поле для группировки продаж
+    company_id: int = Field(foreign_key="company.id")
+    category: int = Field(foreign_key="salecategory.id")  # новая ссылка на категорию
+    sale_dttm: datetime = Field(default_factory=datetime.utcnow)
+    create_dttm: datetime = Field(default_factory=datetime.utcnow)
+    update_dttm: datetime = Field(default_factory=datetime.utcnow)
+
+    ref_obj: "Ref" = Relationship(back_populates="sales")
+    company: "Company" = Relationship(back_populates="sales")
+    sale_category: "SaleCategory" = Relationship(back_populates="sales")
+
+class AgentTransaction(SQLModel, table=True):
+    __tablename__ = "agent_transactions"
+    id: Optional[int] = Field(default=None, primary_key=True)
+    tg_agent_id: int = Field(foreign_key="tgagent.id")
+    amount: float
+    status: str
+    transaction_group: uuid.UUID = Field(default_factory=uuid.uuid4, unique=True)
+    create_dttm: datetime = Field(default_factory=datetime.utcnow)
+    update_dttm: datetime = Field(default_factory=datetime.utcnow)
+
+    tg_agent: "TgAgent" = Relationship(back_populates="agent_transactions")
+    partner_transactions: List["PartnerTransaction"] = Relationship(back_populates="agent_transaction")
+
+class PartnerTransaction(SQLModel, table=True):
+    __tablename__ = "partner_transactions"
+    id: Optional[int] = Field(default=None, primary_key=True)
+    company_id: int = Field(foreign_key="company.id")
+    type: str
+    amount: float
+    status: str
+    transaction_group: uuid.UUID 
+    agent_transaction_id: Optional[int] = Field(default=None, foreign_key="agent_transactions.id")
+    create_dttm: datetime = Field(default_factory=datetime.utcnow)
+    update_dttm: datetime = Field(default_factory=datetime.utcnow)
+
+    company: "Company" = Relationship(back_populates="partner_transactions")
+    agent_transaction: Optional["AgentTransaction"] = Relationship(back_populates="partner_transactions")
+
+class CompanyBalance(SQLModel, table=True):
+    __tablename__ = "company_balances"
+    id: Optional[int] = Field(default=None, primary_key=True)
+    company_id: int = Field(foreign_key="company.id", unique=True)
+    available_balance: float = Field(default=0.0)
+    pending_balance: float = Field(default=0.0)
+    updated_dttm: datetime = Field(default_factory=datetime.utcnow)
+
+    company: "Company" = Relationship(back_populates="company_balance")
+
+class AgentBalance(SQLModel, table=True):
+    __tablename__ = "agent_balances"
+    id: Optional[int] = Field(default=None, primary_key=True)
+    tg_agent_id: int = Field(foreign_key="tgagent.id", unique=True)
+    available_balance: float = Field(default=0.0)
+    frozen_balance: float = Field(default=0.0)
+    updated_dttm: datetime = Field(default_factory=datetime.utcnow)
+
+    tg_agent: "TgAgent" = Relationship(back_populates="agent_balance")
+
+class Account(SQLModel, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    login: str = Field(index=True, unique=True)
+    password_hash: str  
+    firstName: Optional[str] = None
+    surname: Optional[str] = None
+    phone: Optional[str] = None
+    email: Optional[str] = None
+    company_id: int = Field(foreign_key="company.id")
+    create_dttm: datetime = Field(default_factory=datetime.utcnow)
+    update_dttm: datetime = Field(default_factory=datetime.utcnow)
+
+    company: "Company" = Relationship(back_populates="accounts")
+
+# Новая модель для интеграционных токенов
+class IntegrationToken(SQLModel, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    description: str
+    token_hash: str = Field(sa_column=Column(String, unique=True, index=True))
+    masked_token: str = Field(sa_column=Column(String))
+    company_id: int = Field(foreign_key="company.id")
+    create_dttm: datetime = Field(default_factory=datetime.utcnow, nullable=False)
+    update_dttm: datetime = Field(default_factory=datetime.utcnow, nullable=False)
+    use_dttm: Optional[datetime] = None
+
+    company: "Company" = Relationship(back_populates="integration_tokens") 

tg_models.py

@@ -0,0 +1,43 @@
+from pydantic import BaseModel, Field
+from typing import Optional, List
+from uuid import UUID
+
+
+# TG Models
+class RefResponse(BaseModel):
+    ref: str
+    description: str
+    promocode: str
+
+class RefAddRequest(BaseModel):
+    description: str
+
+class TokenRequest(BaseModel):
+    tg_id: int
+
+class RegisterRequest(BaseModel):
+    tg_id: int
+    chat_id: Optional[int] = None
+    phone: Optional[str] = None
+    name: Optional[str] = None
+    login: Optional[str] = None
+    company_key: str
+
+# New Response Models for TG APIs
+class RefAddResponse(BaseModel):
+    ref: str
+    promocode: str
+    description: str
+
+class RefStatItem(BaseModel):
+    description: str
+    sales: int
+    income: float
+
+class RefStatResponse(BaseModel):
+    refData: List[RefStatItem]
+
+class StatResponse(BaseModel):
+    totalSales: int
+    totalIncome: float
+    availableWithdrawal: float