Update proxy_server.py

proxy_server.py

@@ -1,34 +1,52 @@
 """
-PROXY SERVER - Публичный прокси для MT5
+SAFE BACKEND - Приватный сервер с проверкой лицензий из файла
+Схема: MT5 → PROXY → SAFE_BACKEND
 """
-from fastapi import FastAPI, HTTPException, Request
+from fastapi import FastAPI, HTTPException, Request, Header
 from fastapi.middleware.cors import CORSMiddleware
-import httpx
+import firebase_admin
+from firebase_admin import db, credentials
 import os
 import time
-import uvicorn
+import threading
+import json
 from datetime import datetime
+from typing import Optional, Tuple, Dict
+import uvicorn
 
-# ==================== КОНФИГУРАЦИЯ ИЗ СЕКРЕТОВ ====================
-# Эти значения берутся из Secrets Hugging Face
-SAFE_BACKEND_URL = os.environ.get("SAFE_BACKEND_URL", "")
-SAFE_API_TOKEN = os.environ.get("SAFE_API_TOKEN", "")
-
-# Проверяем, что секреты установлены
-if not SAFE_BACKEND_URL or not SAFE_API_TOKEN:
-    print("❌ ОШИБКА: Не настроены секреты в Hugging Face!")
-    print("❌ SAFE_BACKEND_URL:", "установлен" if SAFE_BACKEND_URL else "НЕ УСТАНОВЛЕН")
-    print("❌ SAFE_API_TOKEN:", "установлен" if SAFE_API_TOKEN else "НЕ УСТАНОВЛЕН")
-    print("❌ Инструкция: Зайдите в Settings → Variables and secrets")
-    print("❌ Добавьте секреты:")
-    print("❌   SAFE_BACKEND_URL = https://askhat777-gold-backend-secure.hf.space")
-    print("❌   SAFE_API_TOKEN = GOLD_SAFE_2026_u7x9A2B3C4D5E6F7G8H9I0J1K2L3M4N5O6P")
+# ==================== КОНФИГУРАЦИЯ ====================
+class Config:
+    # Токены из секретов HF
+    SAFE_API_TOKEN = os.environ.get(
+        "SAFE_API_TOKEN",
+        "GOLD_SAFE_2026_u7x9A2B3C4D5E6F7G8H9I0J1K2L3M4N5O6P"
+    )
+    ADMIN_TOKEN = os.environ.get(
+        "ADMIN_TOKEN",
+        "GOLD_ADMIN_2026_98765ZYXWVUTSRQPONMLKJIHGFEDCBA"
+    )
+    
+    # Пути
+    LICENSES_FILE = "licenses.json"
+    FIREBASE_CRED_FILE = "firebase-creds.json"
+    DATABASE_URL = "https://cmeparser-default-rtdb.europe-west1.firebasedatabase.app"
+    
+    # Кэширование
+    PRICE_CACHE_TTL = 3
+    LEVELS_CACHE_TTL = 180
 
-app = FastAPI(title="Gold Options Proxy", version="1.0")
+# ==================== ИНИЦИАЛИЗАЦИЯ ====================
+app = FastAPI(title="Gold Safe Backend", version="2.2")
 
-# Клиент HTTP для запросов к Safe Backend
-client = None
+print("\n" + "=" * 70)
+print("⚠️  ПРОВЕРКА КОНФИГУРАЦИИ SAFE BACKEND")
+print("=" * 70)
+print(f"✅ SAFE_API_TOKEN установлен: {bool(os.environ.get('SAFE_API_TOKEN'))}")
+print(f"✅ ADMIN_TOKEN установлен: {bool(os.environ.get('ADMIN_TOKEN'))}")
+print(f"📄 Файл лицензий: {Config.LICENSES_FILE}")
+print("=" * 70 + "\n")
 
+# CORS
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -37,181 +55,412 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# ==================== ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ ====================
-def log_request(license_key: str, dte: int, ip: str):
-    """Логирование запроса"""
-    timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
-    print(f"[{timestamp}] 📥 Запрос от {ip}: key={license_key[:8]}..., dte={dte}")
+# ==================== МЕНЕДЖЕР ЛИЦЕНЗИЙ ====================
+class LicenseManager:
+    """Управление лицензиями из файла"""
+    
+    def __init__(self, file_path: str):
+        self.file_path = file_path
+        self.licenses = {}
+        self.last_load_time = 0
+        self.load_licenses()
+    
+    def load_licenses(self):
+        """Загружает лицензии из файла"""
+        try:
+            if os.path.exists(self.file_path):
+                with open(self.file_path, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    self.licenses = data.get('licenses', {})
+                    self.last_load_time = time.time()
+                    print(f"✅ Загружено {len(self.licenses)} лицензий из {self.file_path}")
+                    self._print_licenses_summary()
+            else:
+                print(f"⚠️ Файл лицензий не найден: {self.file_path}")
+                self.licenses = {}
+        except Exception as e:
+            print(f"❌ Ошибка загрузки лицензий: {e}")
+            self.licenses = {}
+    
+    def _print_licenses_summary(self):
+        """Печатает сводку лицензий"""
+        for key, lic in self.licenses.items():
+            status = "✅ АКТИВНА" if lic.get('active') else "❌ ОТКЛЮЧЕНА"
+            days = lic.get('days_remaining', 0)
+            plan = lic.get('plan', 'UNKNOWN')
+            print(f"   {key[:15]}... | {plan:6} | {days:3} дней | {status}")
+    
+    def verify_license(self, license_key: str) -> Tuple[bool, Optional[Dict]]:
+        """
+        Проверяет лицензию
+        Возвращает (валидна ли, данные лицензии)
+        """
+        # Перезагружаем файл каждые 5 секунд
+        if time.time() - self.last_load_time > 5:
+            self.load_licenses()
+        
+        if license_key not in self.licenses:
+            return False, None
+        
+        lic = self.licenses[license_key]
+        
+        # Проверка активности
+        if not lic.get('active', False):
+            return False, None
+        
+        # Проверка срока действия
+        days_remaining = lic.get('days_remaining', 0)
+        if days_remaining <= 0:
+            return False, None
+        
+        return True, lic
+    
+    def add_license(self, license_key: str, plan: str, days: int) -> bool:
+        """Добавляет новую лицензию"""
+        if license_key in self.licenses:
+            return False
+        
+        self.licenses[license_key] = {
+            "active": True,
+            "plan": plan,
+            "days_remaining": days,
+            "max_daily_requests": 1000 if plan == "PRO" else 100,
+            "created_at": datetime.now().isoformat() + "Z",
+            "expires_at": (datetime.now().replace(hour=23, minute=59, second=59)).isoformat() + "Z"
+        }
+        
+        self._save_licenses()
+        return True
+    
+    def _save_licenses(self):
+        """Сохраняет лицензии в файл"""
+        try:
+            data = {
+                "licenses": self.licenses,
+                "last_updated": datetime.now().isoformat() + "Z"
+            }
+            with open(self.file_path, 'w', encoding='utf-8') as f:
+                json.dump(data, f, indent=2, ensure_ascii=False)
+            print(f"✅ Лицензии сохранены в {self.file_path}")
+        except Exception as e:
+            print(f"❌ Ошибка сохранения лицензий: {e}")
+
+# Создаем менеджер лицензий
+license_manager = LicenseManager(Config.LICENSES_FILE)
+
+# ==================== MIDDLEWARE ПРОВЕРКИ ТОКЕНА ====================
+@app.middleware("http")
+async def verify_api_token(request: Request, call_next):
+    """
+    Проверяет токен для /api/* эндпоинтов
+    Логирует все попытки доступа
+    """
+    # Пропускаем публичные эндпоинты
+    if request.url.path in ["/", "/health", "/docs", "/openapi.json", "/redoc"]:
+        return await call_next(request)
+    
+    if request.url.path.startswith("/api/"):
+        token_from_header = request.headers.get("X-API-Token", "")
+        client_ip = request.client.host if request.client else "unknown"
+        
+        print(f"\n🔐 API ЗАПРОС")
+        print(f"   IP: {client_ip}")
+        print(f"   Path: {request.url.path}")
+        print(f"   Токен из заголовка: {'✓ НАЙДЕН' if token_from_header else '✗ НЕ НАЙДЕН'}")
+        
+        if not token_from_header:
+            print(f"   ❌ ОШИБКА: Токен отсутствует!")
+            raise HTTPException(
+                status_code=401,
+                detail="Missing X-API-Token header"
+            )
+        
+        if token_from_header != Config.SAFE_API_TOKEN:
+            print(f"   ❌ ОШИБКА: Неверный токен!")
+            print(f"   Получен:  {token_from_header[:20]}...")
+            print(f"   Ожидается: {Config.SAFE_API_TOKEN[:20]}...")
+            raise HTTPException(
+                status_code=401,
+                detail="Invalid X-API-Token"
+            )
+        
+        print(f"   ✅ Токен верный!")
+    
+    response = await call_next(request)
+    return response
 
-def log_response(status: int, response_time: float):
-    """Логирование ответа"""
-    print(f"📤 Ответ: {status} ({response_time:.2f} сек)")
+# ==================== FIREBASE ====================
+print("\n🔥 ИНИЦИАЛИЗАЦИЯ FIREBASE...")
+try:
+    if not firebase_admin._apps:
+        if os.path.exists(Config.FIREBASE_CRED_FILE):
+            cred = credentials.Certificate(Config.FIREBASE_CRED_FILE)
+            firebase_admin.initialize_app(cred, {
+                'databaseURL': Config.DATABASE_URL
+            })
+            print("✅ Firebase подключен успешно!")
+        else:
+            print("⚠️ Firebase credentials не найдены - работаем в демо-режиме")
+except Exception as e:
+    print(f"❌ Ошибка Firebase: {e}")
+
+# ==================== КЛАСС КЭША ====================
+class DataCache:
+    """Умный кэш с автообновлением"""
+    
+    def __init__(self):
+        self.price_cache = {
+            'data': 4323.5,
+            'timestamp': time.time(),
+            'ttl': Config.PRICE_CACHE_TTL
+        }
+        self.levels_cache = {}
+        self.start_background_updater()
+    
+    def start_background_updater(self):
+        """Фоновое обновление данных"""
+        def updater():
+            while True:
+                try:
+                    self._update_price_if_needed()
+                    for dte in list(self.levels_cache.keys()):
+                        self._update_levels_if_needed(dte)
+                except Exception as e:
+                    print(f"⚠️ Ошибка фонового обновления: {e}")
+                time.sleep(1)
+        
+        thread = threading.Thread(target=updater, daemon=True)
+        thread.start()
+        print("✅ Фоновое обновление запущено")
+    
+    def _update_price_if_needed(self):
+        """Обновляет цену каждые 3 секунды"""
+        now = time.time()
+        if (now - self.price_cache['timestamp']) > self.price_cache['ttl']:
+            try:
+                ref = db.reference('current_price/price')
+                price = ref.get()
+                if price:
+                    self.price_cache['data'] = float(price)
+                    self.price_cache['timestamp'] = now
+                    print(f"💰 Цена обновлена: {price}")
+            except Exception as e:
+                pass  # Firebase может быть недоступен
+    
+    def _update_levels_if_needed(self, dte: int):
+        """Обновляет уровни каждые 3 минуты"""
+        now = time.time()
+        cache_key = f"dte_{dte}"
+        
+        if cache_key not in self.levels_cache:
+            self.levels_cache[cache_key] = {'data': {'calls': [], 'puts': []}, 'timestamp': 0}
+        
+        if (now - self.levels_cache[cache_key]['timestamp']) > Config.LEVELS_CACHE_TTL:
+            try:
+                data = self._fetch_levels_from_firebase(dte)
+                self.levels_cache[cache_key]['data'] = data
+                self.levels_cache[cache_key]['timestamp'] = now
+                print(f"📊 Уровни DTE={dte} обновлены")
+            except Exception as e:
+                pass
+    
+    def _fetch_levels_from_firebase(self, dte: int) -> dict:
+        """Получает данные из Firebase"""
+        try:
+            ref = db.reference(f'gc/mt5/breakevens/dte_{dte}')
+            data = ref.get()
+            
+            if not data:
+                return {'calls': [], 'puts': []}
+            
+            calls = []
+            if 'calls_0dte' in data:
+                raw = data['calls_0dte']
+                items = list(raw.values()) if isinstance(raw, dict) else raw
+                for item in items:
+                    if isinstance(item, dict) and item.get('v', 0) > 0:
+                        calls.append({
+                            'be': float(item.get('be', 0)),
+                            's': float(item.get('s', 0)),
+                            'v': int(item.get('v', 0)),
+                            'oi': int(item.get('oi', 0)),
+                            'pr': float(item.get('pr', 0))
+                        })
+            
+            puts = []
+            if 'puts_0dte' in data:
+                raw = data['puts_0dte']
+                items = list(raw.values()) if isinstance(raw, dict) else raw
+                for item in items:
+                    if isinstance(item, dict) and item.get('v', 0) > 0:
+                        puts.append({
+                            'be': float(item.get('be', 0)),
+                            's': float(item.get('s', 0)),
+                            'v': int(item.get('v', 0)),
+                            'oi': int(item.get('oi', 0)),
+                            'pr': float(item.get('pr', 0))
+                        })
+            
+            calls.sort(key=lambda x: x['v'], reverse=True)
+            puts.sort(key=lambda x: x['v'], reverse=True)
+            
+            return {'calls': calls[:10], 'puts': puts[:10]}
+        except Exception as e:
+            return {'calls': [], 'puts': []}
+    
+    def get_price(self) -> float:
+        return self.price_cache['data']
+    
+    def get_levels(self, dte: int) -> dict:
+        cache_key = f"dte_{dte}"
+        if cache_key not in self.levels_cache:
+            self.levels_cache[cache_key] = {'data': {'calls': [], 'puts': []}, 'timestamp': 0}
+        return self.levels_cache[cache_key]['data']
+
+cache = DataCache()
 
 # ==================== API ЭНДПОИНТЫ ====================
 @app.get("/")
 def root():
     return {
-        "status": "Gold Options Proxy",
-        "version": "1.0",
+        "name": "Gold Safe Backend",
+        "version": "2.2",
+        "status": "online",
+        "licenses_loaded": len(license_manager.licenses),
         "endpoints": {
             "data": "/api/mt5/data?license_key=TEST_KEY_12345&dte=0",
             "health": "/health",
-            "config": "/config"
-        },
-        "note": "Публичный прокси-сервер для MT5",
-        "config_status": {
-            "safe_backend_configured": bool(SAFE_BACKEND_URL),
-            "api_token_configured": bool(SAFE_API_TOKEN)
+            "stats": "/api/stats"
         }
     }
 
 @app.get("/health")
 def health_check():
-    """Проверка здоровья прокси"""
+    """Healthcheck (без проверки токена)"""
     return {
         "status": "healthy",
         "timestamp": datetime.now().isoformat(),
-        "proxy_version": "1.0",
-        "uptime": time.time() - startup_time,
-        "config": {
-            "safe_backend": "configured" if SAFE_BACKEND_URL else "not_configured",
-            "api_token": "configured" if SAFE_API_TOKEN else "not_configured"
-        }
+        "price": cache.get_price(),
+        "licenses_count": len(license_manager.licenses)
     }
 
-@app.get("/config")
-def show_config():
-    """Показать конфигурацию (без секретов)"""
+@app.get("/api/stats")
+def get_stats():
+    """Статистика (требует токен в заголовке)"""
     return {
-        "safe_backend_url": SAFE_BACKEND_URL,
-        "safe_api_token_configured": bool(SAFE_API_TOKEN),
-        "proxy_version": "1.0",
-        "request_timeout": 10.0
+        "price": cache.get_price(),
+        "total_licenses": len(license_manager.licenses),
+        "active_licenses": sum(1 for l in license_manager.licenses.values() if l.get('active')),
+        "timestamp": datetime.now().isoformat()
     }
 
 @app.get("/api/mt5/data")
-async def proxy_mt5_data(
-    request: Request,
+def get_mt5_data(
     license_key: str,
-    dte: int = 0
+    dte: int = 0,
+    x_api_token: Optional[str] = Header(None)
 ):
     """
-    Прокси-эндпоинт для MT5.
-    Принимает запрос от MT5, добавляет токен и пересылает в Safe Backend.
+    Основной эндпоинт
+    MT5 → PROXY → SAFE_BACKEND
+    
+    Требует:
+    - X-API-Token в заголовке (для Proxy)
+    - Валидный license_key
     """
     
-    # Логирование входящего запроса
-    client_ip = request.client.host if request.client else "unknown"
-    log_request(license_key, dte, client_ip)
-    start_time = time.time()
-    
-    # Проверяем конфигурацию
-    if not SAFE_BACKEND_URL or not SAFE_API_TOKEN:
-        error_msg = "Proxy не настроен. Отсутствуют SAFE_BACKEND_URL или SAFE_API_TOKEN в секретах."
-        print(f"❌ {error_msg}")
-        log_response(500, time.time() - start_time)
-        raise HTTPException(status_code=500, detail=error_msg)
-    
-    # Формируем URL для запроса к Safe Backend
-    safe_url = f"{SAFE_BACKEND_URL.rstrip('/')}/api/mt5/data"
-    
-    # Заголовки для Safe Backend
-    headers = {
-        "X-API-Token": SAFE_API_TOKEN,
-        "User-Agent": "Gold-Proxy/1.0",
-        "X-Forwarded-For": client_ip,
-        "X-Client-License": license_key[:8] + "..."  # Только начало для логирования
-    }
+    print(f"\n📥 ЗАПРОС MT5 DATA")
+    print(f"   License: {license_key}")
+    print(f"   DTE: {dte}")
     
-    # Параметры запроса
-    query_params = {
-        "license_key": license_key,
-        "dte": dte
-    }
+    # 1. Проверка лицензии
+    is_valid, lic_data = license_manager.verify_license(license_key)
     
-    # Максимальное количество попыток
-    max_retries = 3
-    last_error = None
+    if not is_valid:
+        print(f"   ❌ Лицензия НЕВАЛИДНА или ИСТЕКЛА!")
+        raise HTTPException(
+            status_code=401,
+            detail={
+                "error": "INVALID_OR_EXPIRED_LICENSE",
+                "license_key": license_key,
+                "message": "Лицензия невалидна, отключена или истекла"
+            }
+        )
     
-    for attempt in range(max_retries):
-        try:
-            print(f"🔄 Попытка #{attempt + 1} к Safe Backend")
-            
-            async with httpx.AsyncClient(timeout=10.0) as client:
-                response = await client.get(
-                    safe_url,
-                    params=query_params,
-                    headers=headers
-                )
-            
-            # Если успешно
-            if response.status_code == 200:
-                response_time = time.time() - start_time
-                print(f"✅ Успешный ответ от Safe Backend ({response_time:.2f} сек)")
-                log_response(200, response_time)
-                return response.json()
-            else:
-                last_error = f"Safe Backend вернул {response.status_code}: {response.text[:100]}"
-                print(f"❌ {last_error}")
-                
-        except httpx.TimeoutException:
-            last_error = f"Timeout при попытке #{attempt + 1}"
-            print(f"⌛ {last_error}")
-        except httpx.RequestError as e:
-            last_error = f"Ошибка сети: {e}"
-            print(f"🌐 {last_error}")
-        except Exception as e:
-            last_error = f"Неизвестная ошибка: {e}"
-            print(f"⚠️ {last_error}")
-        
-        # Ждем перед повторной попыткой (экспоненциальная задержка)
-        if attempt < max_retries - 1:
-            wait_time = 0.5 * (2 ** attempt)  # 0.5, 1.0, 2.0 секунды
-            print(f"⏳ Ждем {wait_time:.1f} сек перед повторной попыткой...")
-            await asyncio.sleep(wait_time)
-    
-    # Если все попытки неудачны
-    error_detail = f"Не удалось подключиться к Safe Backend после {max_retries} попыток. Последняя ошибка: {last_error}"
-    print(f"❌ {error_detail}")
-    log_response(503, time.time() - start_time)
-    
-    raise HTTPException(
-        status_code=503,
-        detail=error_detail
-    )
+    print(f"   ✅ Лицензия ВАЛИДНА ({lic_data.get('plan')})")
+    
+    try:
+        # 2. Получаем данные
+        price = cache.get_price()
+        levels = cache.get_levels(dte)
+        
+        # 3. Формируем ответ
+        response = {
+            "status": "ok",
+            "price": price,
+            "dte": dte,
+            "license_plan": lic_data.get("plan"),
+            "days_remaining": lic_data.get("days_remaining"),
+            "calls": levels.get("calls", []),
+            "puts": levels.get("puts", []),
+            "timestamp": datetime.now().isoformat(),
+            "calls_count": len(levels.get("calls", [])),
+            "puts_count": len(levels.get("puts", []))
+        }
+        
+        print(f"   📤 Ответ отправлен ({len(response['calls'])} calls, {len(response['puts'])} puts)")
+        return response
+    
+    except Exception as e:
+        print(f"   ❌ Ошибка: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+# ==================== АДМИН ЭНДПОИНТЫ ====================
+@app.get("/api/admin/licenses")
+def admin_get_licenses(admin_token: str):
+    """Получить все лицензии"""
+    if admin_token != Config.ADMIN_TOKEN:
+        raise HTTPException(status_code=403, detail="Invalid admin token")
+    
+    return {
+        "licenses": license_manager.licenses,
+        "total": len(license_manager.licenses),
+        "active": sum(1 for l in license_manager.licenses.values() if l.get('active')),
+        "timestamp": datetime.now().isoformat()
+    }
 
-@app.exception_handler(Exception)
-async def global_exception_handler(request: Request, exc: Exception):
-    """Глобальный обработчик исключений"""
-    error_time = time.time()
-    error_msg = str(exc)
+@app.post("/api/admin/add-license")
+def admin_add_license(
+    admin_token: str,
+    license_key: str,
+    plan: str = "PRO",
+    days: int = 30
+):
+    """Добавить лицензию"""
+    if admin_token != Config.ADMIN_TOKEN:
+        raise HTTPException(status_code=403, detail="Invalid admin token")
     
-    print(f"❌ Глобальная ошибка: {error_msg}")
+    if not license_manager.add_license(license_key, plan, days):
+        raise HTTPException(status_code=400, detail="License already exists")
     
+    print(f"✅ Новая лицензия добавлена: {license_key} ({plan})")
     return {
-        "status": "error",
-        "detail": error_msg,
-        "timestamp": error_time,
-        "path": request.url.path,
-        "proxy_version": "1.0"
+        "status": "created",
+        "license_key": license_key,
+        "plan": plan,
+        "days": days
     }
 
 # ==================== ЗАПУСК ====================
-startup_time = time.time()
-
 @app.on_event("startup")
-async def startup_event():
-    print("=" * 60)
-    print("🚀 GOLD OPTIONS PROXY ЗАПУЩЕН")
-    print("=" * 60)
-    print(f"Safe Backend URL: {SAFE_BACKEND_URL}")
-    print(f"API Token настроен: {'✅ Да' if SAFE_API_TOKEN else '❌ Нет'}")
-    print(f"Текущее время: {datetime.now().isoformat()}")
-    print("=" * 60)
-    
-    if not SAFE_BACKEND_URL or not SAFE_API_TOKEN:
-        print("⚠️ ВНИМАНИЕ: Секреты не настроены!")
-        print("👉 Зайдите в Settings → Variables and secrets")
-        print("👉 Добавьте:")
-        print("   SAFE_BACKEND_URL = https://askhat777-gold-backend-secure.hf.space")
-        print("   SAFE_API_TOKEN = GOLD_SAFE_2026_u7x9A2B3C4D5E6F7G8H9I0J1K2L3M4N5O6P")
+async def startup():
+    print("\n" + "=" * 70)
+    print("🚀 SAFE BACKEND ЗАПУЩЕН")
+    print("=" * 70)
+    print(f"Время: {datetime.now().isoformat()}")
+    print(f"API Token: {Config.SAFE_API_TOKEN[:15]}...")
+    print(f"Лицензий загружено: {len(license_manager.licenses)}")
+    print("=" * 70 + "\n")
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)