Initial backend for Hugging Face Spaces

DEPLOYMENT.md

@@ -0,0 +1,189 @@
+# 🎮 2D Game Backend - Инструкция по деплою на Hugging Face Spaces
+
+## Шаг 1: Подготовка
+
+1. Создайте аккаунт на [Hugging Face](https://huggingface.co)
+2. Перейдите в раздел [Spaces](https://huggingface.co/spaces)
+3. Нажмите **"Create new Space"**
+
+## Шаг 2: Настройка Space
+
+1. **Space name**: Выберите имя (например, `2d-game-backend`)
+2. **License**: Выберите лицензию (MIT рекомендуется)
+3. **SDK**: Выберите **Docker**
+4. **Space hardware**: Free CPU (достаточно для начала)
+5. Нажмите **"Create Space"**
+
+## Шаг 3: Загрузка файлов
+
+### Вариант A: Через веб-интерфейс
+
+1. Загрузите все файлы из папки `backend/`:
+   - `main.py`
+   - `models.py`
+   - `schemas.py`
+   - `database.py`
+   - `auth.py`
+   - `config.py`
+   - `requirements.txt`
+   - `Dockerfile`
+   - `README.md`
+   - Папку `routes/` со всеми файлами
+
+2. Убедитесь, что файл `README.md` начинается с frontmatter:
+```yaml
+---
+title: 2D Game Backend
+emoji: 🎮
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+app_port: 7860
+---
+```
+
+### Вариант B: Через Git
+
+```bash
+# Клонируйте ваш Space
+git clone https://huggingface.co/spaces/<your-username>/<space-name>
+cd <space-name>
+
+# Скопируйте все файлы из backend/
+cp -r ../backend/* .
+
+# Добавьте и закоммитьте
+git add .
+git commit -m "Initial backend deployment"
+git push
+```
+
+## Шаг 4: Настройка переменных окружения (опционально)
+
+В настройках Space добавьте секреты:
+
+1. Перейдите в **Settings** вашего Space
+2. В разделе **Repository secrets** добавьте:
+   - `SECRET_KEY` - случайная строка для JWT
+   - `ADMIN_PASSWORD` - пароль администратора (по умолчанию: admin123)
+
+## Шаг 5: Запуск
+
+Space автоматически запустится после загрузки файлов. Процесс займет 2-5 минут.
+
+## Шаг 6: Проверка
+
+1. Откройте URL вашего Space: `https://<your-username>-<space-name>.hf.space`
+2. Должна появиться JSON-ответ от API
+3. Перейдите на `/docs` для Swagger документации: `https://<your-username>-<space-name>.hf.space/docs`
+
+## Шаг 7: Тестирование API
+
+### Регистрация пользователя
+```bash
+curl -X POST "https://<your-space-url>/api/auth/register" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "username": "testuser",
+    "email": "test@example.com",
+    "password": "password123"
+  }'
+```
+
+### Вход администратора
+```bash
+curl -X POST "https://<your-space-url>/api/auth/login" \
+  -H "Content-Type: application/x-www-form-urlencoded" \
+  -d "username=admin&password=admin123"
+```
+
+### Получение статистики (нужен токен)
+```bash
+curl -X GET "https://<your-space-url>/api/game/stats" \
+  -H "Authorization: Bearer <your-token>"
+```
+
+## Структура проекта
+
+```
+backend/
+├── main.py                 # Главный файл приложения
+├── models.py              # Модели базы данных
+├── schemas.py             # Pydantic схемы
+├── database.py            # Настройка БД
+├── auth.py                # Авторизация и JWT
+├── config.py              # Конфигурация
+├── requirements.txt       # Зависимости Python
+├── Dockerfile            # Docker конфигурация
+├── README.md             # Документация
+└── routes/
+    ├── __init__.py
+    ├── auth_routes.py    # Роуты авторизации
+    ├── game.py           # Игровые роуты
+    └── admin.py          # Админ-панель
+```
+
+## Важные замечания
+
+1. **База данных**: По умолчанию используется SQLite. Данные сохраняются в `/app/data/game.db`
+2. **Безопасность**: Обязательно измените `SECRET_KEY` и пароль администратора в продакшене
+3. **CORS**: Настроен для всех источников (`*`). Для продакшена укажите конкретные домены
+4. **Логи**: Доступны в интерфейсе Space во вкладке "Logs"
+
+## Обновление Space
+
+При изменении кода просто загрузите новые файлы или сделайте git push. Space автоматически пересоберется.
+
+## Подключение к ��ронтенду
+
+В вашем фронтенд-коде используйте URL API:
+
+```typescript
+const API_URL = 'https://<your-username>-<space-name>.hf.space';
+
+// Пример регистрации
+async function register(username: string, email: string, password: string) {
+  const response = await fetch(`${API_URL}/api/auth/register`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ username, email, password })
+  });
+  return response.json();
+}
+
+// Пример получения статистики
+async function getStats(token: string) {
+  const response = await fetch(`${API_URL}/api/game/stats`, {
+    headers: { 'Authorization': `Bearer ${token}` }
+  });
+  return response.json();
+}
+```
+
+## Мониторинг
+
+- **Health check**: `GET /health`
+- **API docs**: `/docs`
+- **ReDoc**: `/redoc`
+
+## Troubleshooting
+
+### Space не запускается
+1. Проверьте логи в интерфейсе HF
+2. Убедитесь что все файлы загружены
+3. Проверьте Dockerfile на ошибки
+
+### База данных не инициализируется
+- Проверьте права на запись в `/app/data`
+- Убедитесь что SQLite установлен (включен в образ)
+
+### Ошибки импорта
+- Проверьте `requirements.txt`
+- Убедитесь что все файлы в нужных директориях
+
+## Полезные ссылки
+
+- [Hugging Face Spaces Documentation](https://huggingface.co/docs/hub/spaces)
+- [FastAPI Documentation](https://fastapi.tiangolo.com/)
+- [Docker Documentation](https://docs.docker.com/)

Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Установка зависимостей
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Копирование кода приложения
+COPY . .
+
+# Создание директории для базы данных
+RUN mkdir -p /app/data
+
+# Переменные окружения
+ENV DATABASE_URL=sqlite:///./data/game.db
+ENV PYTHONUNBUFFERED=1
+
+# Экспонирование порта
+EXPOSE 7860
+
+# Команда запуска
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,78 @@
+---
+title: 2D Game Backend
+emoji: 🎮
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+app_port: 7860
+---
+
+# 2D Game Backend API
+
+Backend сервер для 2D игры с полной системой авторизации, управлением игроками и админ-панелью.
+
+## Функции
+
+### 🔐 Авторизация
+- Регистрация пользователей
+- JWT аутентификация
+- Управление профилями
+
+### 🎮 Игровая механика
+- Управление энергией и сытостью
+- Статистика игроков (уровень, опыт, монеты)
+- Трекинг игровых сессий
+- Логирование действий игроков
+
+### 👨‍💼 Админ-панель
+- Общая статистика игры
+- Управление пользователями
+- Топ игроков по различным метрикам
+- Аналитика активности
+- Временные графики
+- Метрики удержания игроков
+- История действий
+
+## API Документация
+
+После запуска доступна по адресу: `/docs`
+
+## Эндпоинты
+
+### Авторизация
+- `POST /api/auth/register` - Регистрация
+- `POST /api/auth/login` - Вход
+- `GET /api/auth/me` - Текущий пользователь
+
+### Игра
+- `GET /api/game/stats` - Статистика игрока
+- `PATCH /api/game/stats` - Обновление статистики
+- `POST /api/game/stats/consume-energy` - Расход энергии
+- `POST /api/game/stats/restore-energy` - Восстановление энергии
+- `POST /api/game/stats/consume-hunger` - Расход сытости
+- `POST /api/game/stats/restore-hunger` - Восстановление сытости
+- `POST /api/game/session/start` - Начало сессии
+- `POST /api/game/session/end` - Завершение сессии
+
+### Админка (требуется admin права)
+- `GET /api/admin/stats/overview` - Общая статистика
+- `GET /api/admin/users` - Список пользователей
+- `GET /api/admin/stats/top-players` - Топ игроков
+- `GET /api/admin/stats/sessions-timeline` - График сессий
+- `GET /api/admin/stats/activity-heatmap` - Тепловая карта активности
+- `GET /api/admin/stats/user-retention` - Удержание пользователей
+- `GET /api/admin/stats/game-metrics` - Игровые метрики
+- `GET /api/admin/actions/recent` - Последние действия
+
+## Настройка
+
+По умолчанию создается администратор:
+- Username: `admin`
+- Password: `admin123`
+
+⚠️ **Важно:** Измените пароль администратора после первого входа!
+
+## База данных
+
+Использует SQLite для простоты деплоя. Для продакшена можно переключиться на PostgreSQL через переменную окружения `DATABASE_URL`.

auth.py

@@ -0,0 +1,142 @@
+from datetime import datetime, timedelta
+from typing import Optional
+from jose import JWTError, jwt
+from passlib.context import CryptContext
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from sqlalchemy.orm import Session
+from database import get_db
+from models import User, UserStats
+from schemas import TokenData
+from config import get_settings
+
+settings = get_settings()
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="api/auth/login")
+
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    """Проверка пароля"""
+    return pwd_context.verify(plain_password, hashed_password)
+
+
+def get_password_hash(password: str) -> str:
+    """Хеширование пароля"""
+    return pwd_context.hash(password)
+
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None):
+    """Создание JWT токена"""
+    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, settings.SECRET_KEY, algorithm=settings.ALGORITHM)
+    return encoded_jwt
+
+
+def authenticate_user(db: Session, username: str, password: str):
+    """Аутентификация пользователя"""
+    user = db.query(User).filter(User.username == username).first()
+    if not user:
+        return False
+    if not verify_password(password, user.hashed_password):
+        return False
+    return user
+
+
+async def get_current_user(
+    token: str = Depends(oauth2_scheme),
+    db: Session = Depends(get_db)
+) -> User:
+    """Получение текущего пользователя из токена"""
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[settings.ALGORITHM])
+        username: str = payload.get("sub")
+        if username is None:
+            raise credentials_exception
+        token_data = TokenData(username=username)
+    except JWTError:
+        raise credentials_exception
+    
+    user = db.query(User).filter(User.username == token_data.username).first()
+    if user is None:
+        raise credentials_exception
+    return user
+
+
+async def get_current_active_user(
+    current_user: User = Depends(get_current_user)
+) -> User:
+    """Проверка активности пользователя"""
+    if not current_user.is_active:
+        raise HTTPException(status_code=400, detail="Inactive user")
+    return current_user
+
+
+async def get_current_admin_user(
+    current_user: User = Depends(get_current_active_user)
+) -> User:
+    """Проверка прав администратора"""
+    if not current_user.is_admin:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Not enough permissions"
+        )
+    return current_user
+
+
+def create_user(db: Session, username: str, email: str, password: str, is_admin: bool = False) -> User:
+    """Создание нового пользователя"""
+    # Проверка существования пользователя
+    if db.query(User).filter(User.username == username).first():
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Username already registered"
+        )
+    if db.query(User).filter(User.email == email).first():
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Email already registered"
+        )
+    
+    # Создание пользователя
+    hashed_password = get_password_hash(password)
+    user = User(
+        username=username,
+        email=email,
+        hashed_password=hashed_password,
+        is_admin=is_admin
+    )
+    db.add(user)
+    db.commit()
+    db.refresh(user)
+    
+    # Создание статистики пользователя
+    user_stats = UserStats(user_id=user.id)
+    db.add(user_stats)
+    db.commit()
+    
+    return user
+
+
+def init_admin_user(db: Session):
+    """Инициализация администратора при первом запуске"""
+    admin = db.query(User).filter(User.username == settings.ADMIN_USERNAME).first()
+    if not admin:
+        create_user(
+            db=db,
+            username=settings.ADMIN_USERNAME,
+            email=settings.ADMIN_EMAIL,
+            password=settings.ADMIN_PASSWORD,
+            is_admin=True
+        )
+        print(f"Admin user created: {settings.ADMIN_USERNAME}")

config.py

@@ -0,0 +1,20 @@
+from pydantic_settings import BaseSettings
+from functools import lru_cache
+
+
+class Settings(BaseSettings):
+    DATABASE_URL: str = "sqlite:///./game.db"
+    SECRET_KEY: str = "your-secret-key-change-in-production"
+    ALGORITHM: str = "HS256"
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
+    ADMIN_USERNAME: str = "admin"
+    ADMIN_PASSWORD: str = "admin123"
+    ADMIN_EMAIL: str = "admin@example.com"
+
+    class Config:
+        env_file = ".env"
+
+
+@lru_cache()
+def get_settings():
+    return Settings()

database.py

@@ -0,0 +1,23 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from config import get_settings
+
+settings = get_settings()
+
+engine = create_engine(
+    settings.DATABASE_URL, 
+    connect_args={"check_same_thread": False} if "sqlite" in settings.DATABASE_URL else {}
+)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

main.py

@@ -0,0 +1,77 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
+from database import engine, get_db
+from models import Base
+from routes import auth_routes, game, admin
+from auth import init_admin_user
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Lifecycle events"""
+    # Startup
+    Base.metadata.create_all(bind=engine)
+    
+    # Инициализация администратора
+    db = next(get_db())
+    try:
+        init_admin_user(db)
+    finally:
+        db.close()
+    
+    print("✅ Database initialized")
+    print("✅ Admin user initialized")
+    
+    yield
+    
+    # Shutdown
+    print("👋 Shutting down...")
+
+
+app = FastAPI(
+    title="2D Game API",
+    description="Backend API для 2D игры с авторизацией и статистикой",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+# CORS настройки
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # В продакшене укажите конкретные домены
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Подключение роутеров
+app.include_router(auth_routes.router)
+app.include_router(game.router)
+app.include_router(admin.router)
+
+
+@app.get("/")
+async def root():
+    """Корневой эндпоинт"""
+    return {
+        "message": "2D Game API",
+        "version": "1.0.0",
+        "docs": "/docs",
+        "endpoints": {
+            "auth": "/api/auth",
+            "game": "/api/game",
+            "admin": "/api/admin"
+        }
+    }
+
+
+@app.get("/health")
+async def health_check():
+    """Проверка работоспособности"""
+    return {"status": "healthy"}
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

models.py

@@ -0,0 +1,105 @@
+from sqlalchemy import Column, Integer, String, Float, Boolean, DateTime, ForeignKey, Text
+from sqlalchemy.orm import relationship
+from sqlalchemy.sql import func
+from database import Base
+
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True, index=True)
+    username = Column(String(50), unique=True, index=True, nullable=False)
+    email = Column(String(100), unique=True, index=True, nullable=False)
+    hashed_password = Column(String(255), nullable=False)
+    is_active = Column(Boolean, default=True)
+    is_admin = Column(Boolean, default=False)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    last_login = Column(DateTime(timezone=True), onupdate=func.now())
+
+    # Relationships
+    stats = relationship("UserStats", back_populates="user", uselist=False, cascade="all, delete-orphan")
+    sessions = relationship("GameSession", back_populates="user", cascade="all, delete-orphan")
+
+
+class UserStats(Base):
+    __tablename__ = "user_stats"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id"), unique=True, nullable=False)
+    
+    # Игровые параметры
+    energy = Column(Float, default=100.0)
+    max_energy = Column(Float, default=100.0)
+    hunger = Column(Float, default=100.0)  # сытость
+    max_hunger = Column(Float, default=100.0)
+    
+    # Статистика
+    total_playtime = Column(Integer, default=0)  # в секундах
+    level = Column(Integer, default=1)
+    experience = Column(Integer, default=0)
+    coins = Column(Integer, default=0)
+    
+    # Игровые достижения
+    rooms_visited = Column(Integer, default=0)
+    items_collected = Column(Integer, default=0)
+    enemies_defeated = Column(Integer, default=0)
+    deaths = Column(Integer, default=0)
+    
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now(), server_default=func.now())
+
+    # Relationship
+    user = relationship("User", back_populates="stats")
+
+
+class GameSession(Base):
+    __tablename__ = "game_sessions"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+    
+    started_at = Column(DateTime(timezone=True), server_default=func.now())
+    ended_at = Column(DateTime(timezone=True), nullable=True)
+    duration = Column(Integer, default=0)  # в секундах
+    
+    # Статистика сессии
+    energy_consumed = Column(Float, default=0.0)
+    hunger_consumed = Column(Float, default=0.0)
+    rooms_visited_session = Column(Integer, default=0)
+    items_collected_session = Column(Integer, default=0)
+    enemies_defeated_session = Column(Integer, default=0)
+    deaths_session = Column(Integer, default=0)
+    
+    # Relationship
+    user = relationship("User", back_populates="sessions")
+
+
+class GameAction(Base):
+    """Лог действий пользователя для детальной аналитики"""
+    __tablename__ = "game_actions"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+    action_type = Column(String(50), nullable=False)  # move, attack, collect, eat, rest
+    action_data = Column(Text, nullable=True)  # JSON данные
+    timestamp = Column(DateTime(timezone=True), server_default=func.now())
+
+
+class SystemStats(Base):
+    """Системная статистика для админки"""
+    __tablename__ = "system_stats"
+
+    id = Column(Integer, primary_key=True, index=True)
+    date = Column(DateTime(timezone=True), server_default=func.now())
+    
+    # Общие показатели
+    total_users = Column(Integer, default=0)
+    active_users_today = Column(Integer, default=0)
+    new_users_today = Column(Integer, default=0)
+    total_sessions = Column(Integer, default=0)
+    avg_session_duration = Column(Float, default=0.0)
+    
+    # Игровая статистика
+    total_playtime = Column(Integer, default=0)
+    total_rooms_visited = Column(Integer, default=0)
+    total_items_collected = Column(Integer, default=0)
+    total_enemies_defeated = Column(Integer, default=0)

requirements.txt

@@ -0,0 +1,12 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+sqlalchemy==2.0.23
+psycopg2-binary==2.9.9
+python-jose[cryptography]==3.3.0
+passlib[bcrypt]==1.7.4
+python-multipart==0.0.6
+pydantic==2.5.0
+pydantic-settings==2.1.0
+python-dotenv==1.0.0
+alembic==1.12.1
+email-validator==2.1.0

routes/admin.py

@@ -0,0 +1,330 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from sqlalchemy import func, and_, desc
+from typing import List
+from datetime import datetime, timedelta
+from database import get_db
+from models import User, UserStats, GameSession, GameAction, SystemStats
+from schemas import AdminStats, UserListItem, UserDetail, UserStatsResponse
+from auth import get_current_admin_user
+
+router = APIRouter(prefix="/api/admin", tags=["Admin"])
+
+
+@router.get("/stats/overview", response_model=AdminStats)
+async def get_admin_stats(
+    current_user: User = Depends(get_current_admin_user),
+    db: Session = Depends(get_db)
+):
+    """Общая статистика для админ-панели"""
+    
+    # Общее количество пользователей
+    total_users = db.query(func.count(User.id)).scalar()
+    
+    # Активные пользователи сегодня (имели сессию за последние 24 часа)
+    today = datetime.utcnow() - timedelta(days=1)
+    active_users_today = db.query(func.count(func.distinct(GameSession.user_id))).filter(
+        GameSession.started_at >= today
+    ).scalar()
+    
+    # Новые пользователи сегодня
+    new_users_today = db.query(func.count(User.id)).filter(
+        User.created_at >= today
+    ).scalar()
+    
+    # Всего сессий
+    total_sessions = db.query(func.count(GameSession.id)).scalar()
+    
+    # Средняя длительность сессии
+    avg_duration = db.query(func.avg(GameSession.duration)).filter(
+        GameSession.ended_at != None
+    ).scalar() or 0
+    
+    # Общее время игры
+    total_playtime = db.query(func.sum(UserStats.total_playtime)).scalar() or 0
+    
+    # Общая статистика по комнатам
+    total_rooms = db.query(func.sum(UserStats.rooms_visited)).scalar() or 0
+    
+    # Общая статистика по предметам
+    total_items = db.query(func.sum(UserStats.items_collected)).scalar() or 0
+    
+    # Общая статистика по врагам
+    total_enemies = db.query(func.sum(UserStats.enemies_defeated)).scalar() or 0
+    
+    return AdminStats(
+        total_users=total_users,
+        active_users_today=active_users_today or 0,
+        new_users_today=new_users_today or 0,
+        total_sessions=total_sessions or 0,
+        avg_session_duration=float(avg_duration),
+        total_playtime=total_playtime,
+        total_rooms_visited=total_rooms,
+        total_items_collected=total_items,
+        total_enemies_defeated=total_enemies
+    )
+
+
+@router.get("/users", response_model=List[UserListItem])
+async def get_all_users(
+    skip: int = 0,
+    limit: int = 100,
+    current_user: User = Depends(get_current_admin_user),
+    db: Session = Depends(get_db)
+):
+    """Список всех пользователей"""
+    users = db.query(User).offset(skip).limit(limit).all()
+    return users
+
+
+@router.get("/users/{user_id}", response_model=UserDetail)
+async def get_user_detail(
+    user_id: int,
+    current_user: User = Depends(get_current_admin_user),
+    db: Session = Depends(get_db)
+):
+    """Детальная информация о пользователе"""
+    user = db.query(User).filter(User.id == user_id).first()
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    
+    return user
+
+
+@router.patch("/users/{user_id}/toggle-active")
+async def toggle_user_active(
+    user_id: int,
+    current_user: User = Depends(get_current_admin_user),
+    db: Session = Depends(get_db)
+):
+    """Активация/деактивация пользователя"""
+    user = db.query(User).filter(User.id == user_id).first()
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    
+    user.is_active = not user.is_active
+    db.commit()
+    
+    return {"message": f"User {'activated' if user.is_active else 'deactivated'}", "is_active": user.is_active}
+
+
+@router.patch("/users/{user_id}/toggle-admin")
+async def toggle_user_admin(
+    user_id: int,
+    current_user: User = Depends(get_current_admin_user),
+    db: Session = Depends(get_db)
+):
+    """Назначение/снятие прав администратора"""
+    user = db.query(User).filter(User.id == user_id).first()
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    
+    if user.id == current_user.id:
+        raise HTTPException(status_code=400, detail="Cannot modify your own admin status")
+    
+    user.is_admin = not user.is_admin
+    db.commit()
+    
+    return {"message": f"Admin rights {'granted' if user.is_admin else 'revoked'}", "is_admin": user.is_admin}
+
+
+@router.delete("/users/{user_id}")
+async def delete_user(
+    user_id: int,
+    current_user: User = Depends(get_current_admin_user),
+    db: Session = Depends(get_db)
+):
+    """Удаление пользовате��я"""
+    user = db.query(User).filter(User.id == user_id).first()
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    
+    if user.id == current_user.id:
+        raise HTTPException(status_code=400, detail="Cannot delete yourself")
+    
+    db.delete(user)
+    db.commit()
+    
+    return {"message": "User deleted successfully"}
+
+
+@router.get("/stats/top-players")
+async def get_top_players(
+    metric: str = "level",
+    limit: int = 10,
+    current_user: User = Depends(get_current_admin_user),
+    db: Session = Depends(get_db)
+):
+    """Топ игроков по различным метрикам"""
+    
+    valid_metrics = ["level", "experience", "total_playtime", "enemies_defeated", "items_collected", "coins"]
+    if metric not in valid_metrics:
+        raise HTTPException(status_code=400, detail=f"Invalid metric. Choose from: {valid_metrics}")
+    
+    # Получаем топ игроков
+    query = db.query(User, UserStats).join(UserStats).order_by(desc(getattr(UserStats, metric))).limit(limit)
+    
+    results = []
+    for user, stats in query:
+        results.append({
+            "user_id": user.id,
+            "username": user.username,
+            "metric_value": getattr(stats, metric),
+            "level": stats.level,
+            "experience": stats.experience
+        })
+    
+    return {"metric": metric, "top_players": results}
+
+
+@router.get("/stats/sessions-timeline")
+async def get_sessions_timeline(
+    days: int = 7,
+    current_user: User = Depends(get_current_admin_user),
+    db: Session = Depends(get_db)
+):
+    """Временная шкала сессий за последние N дней"""
+    
+    start_date = datetime.utcnow() - timedelta(days=days)
+    
+    # Группировка по дням
+    sessions_by_day = db.query(
+        func.date(GameSession.started_at).label('date'),
+        func.count(GameSession.id).label('count'),
+        func.avg(GameSession.duration).label('avg_duration')
+    ).filter(
+        GameSession.started_at >= start_date
+    ).group_by(
+        func.date(GameSession.started_at)
+    ).all()
+    
+    timeline = []
+    for day in sessions_by_day:
+        timeline.append({
+            "date": str(day.date),
+            "sessions_count": day.count,
+            "avg_duration": float(day.avg_duration) if day.avg_duration else 0
+        })
+    
+    return {"days": days, "timeline": timeline}
+
+
+@router.get("/stats/activity-heatmap")
+async def get_activity_heatmap(
+    current_user: User = Depends(get_current_admin_user),
+    db: Session = Depends(get_db)
+):
+    """Тепловая карта активности игроков по часам"""
+    
+    # Группировка по часам дня
+    activity = db.query(
+        func.extract('hour', GameSession.started_at).label('hour'),
+        func.count(GameSession.id).label('count')
+    ).group_by(
+        func.extract('hour', GameSession.started_at)
+    ).all()
+    
+    heatmap = {int(hour): count for hour, count in activity}
+    
+    # Заполняем отсутствующие часы нулями
+    full_heatmap = {hour: heatmap.get(hour, 0) for hour in range(24)}
+    
+    return {"heatmap": full_heatmap}
+
+
+@router.get("/stats/user-retention")
+async def get_user_retention(
+    current_user: User = Depends(get_current_admin_user),
+    db: Session = Depends(get_db)
+):
+    """Статистика удержания пользователей"""
+    
+    # Пользователи, зарегистрированные в последние 30 дней
+    thirty_days_ago = datetime.utcnow() - timedelta(days=30)
+    new_users = db.query(User).filter(User.created_at >= thirty_days_ago).all()
+    
+    # Из них активных в последние 7 дней
+    seven_days_ago = datetime.utcnow() - timedelta(days=7)
+    active_new_users = 0
+    
+    for user in new_users:
+        has_recent_session = db.query(GameSession).filter(
+            GameSession.user_id == user.id,
+            GameSession.started_at >= seven_days_ago
+        ).first()
+        if has_recent_session:
+            active_new_users += 1
+    
+    retention_rate = (active_new_users / len(new_users) * 100) if new_users else 0
+    
+    return {
+        "new_users_30d": len(new_users),
+        "active_users_7d": active_new_users,
+        "retention_rate": round(retention_rate, 2)
+    }
+
+
+@router.get("/stats/game-metrics")
+async def get_game_metrics(
+    current_user: User = Depends(get_current_admin_user),
+    db: Session = Depends(get_db)
+):
+    """Метрики игрового процесса"""
+    
+    # Средние показатели
+    avg_stats = db.query(
+        func.avg(UserStats.level).label('avg_level'),
+        func.avg(UserStats.energy).label('avg_energy'),
+        func.avg(UserStats.hunger).label('avg_hunger'),
+        func.avg(UserStats.coins).label('avg_coins'),
+        func.avg(UserStats.deaths).label('avg_deaths')
+    ).first()
+    
+    # Общие показатели
+    total_stats = db.query(
+        func.sum(UserStats.rooms_visited).label('total_rooms'),
+        func.sum(UserStats.items_collected).label('total_items'),
+        func.sum(UserStats.enemies_defeated).label('total_enemies'),
+        func.sum(UserStats.deaths).label('total_deaths')
+    ).first()
+    
+    return {
+        "averages": {
+            "level": float(avg_stats.avg_level) if avg_stats.avg_level else 0,
+            "energy": float(avg_stats.avg_energy) if avg_stats.avg_energy else 0,
+            "hunger": float(avg_stats.avg_hunger) if avg_stats.avg_hunger else 0,
+            "coins": float(avg_stats.avg_coins) if avg_stats.avg_coins else 0,
+            "deaths": float(avg_stats.avg_deaths) if avg_stats.avg_deaths else 0
+        },
+        "totals": {
+            "rooms_visited": total_stats.total_rooms or 0,
+            "items_collected": total_stats.total_items or 0,
+            "enemies_defeated": total_stats.total_enemies or 0,
+            "deaths": total_stats.total_deaths or 0
+        }
+    }
+
+
+@router.get("/actions/recent")
+async def get_recent_actions(
+    limit: int = 50,
+    current_user: User = Depends(get_current_admin_user),
+    db: Session = Depends(get_db)
+):
+    """Последние действия игроков"""
+    
+    actions = db.query(GameAction, User).join(User).order_by(
+        desc(GameAction.timestamp)
+    ).limit(limit).all()
+    
+    results = []
+    for action, user in actions:
+        results.append({
+            "id": action.id,
+            "username": user.username,
+            "action_type": action.action_type,
+            "action_data": action.action_data,
+            "timestamp": action.timestamp
+        })
+    
+    return {"recent_actions": results}

routes/auth_routes.py

@@ -0,0 +1,67 @@
+from datetime import timedelta
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordRequestForm
+from sqlalchemy.orm import Session
+from database import get_db
+from schemas import UserCreate, UserResponse, Token
+from auth import (
+    authenticate_user,
+    create_access_token,
+    create_user,
+    get_current_active_user
+)
+from config import get_settings
+from models import User
+
+settings = get_settings()
+router = APIRouter(prefix="/api/auth", tags=["Authentication"])
+
+
+@router.post("/register", response_model=UserResponse, status_code=status.HTTP_201_CREATED)
+async def register(user_data: UserCreate, db: Session = Depends(get_db)):
+    """Регистрация нового пользователя"""
+    user = create_user(
+        db=db,
+        username=user_data.username,
+        email=user_data.email,
+        password=user_data.password
+    )
+    return user
+
+
+@router.post("/login", response_model=Token)
+async def login(
+    form_data: OAuth2PasswordRequestForm = Depends(),
+    db: Session = Depends(get_db)
+):
+    """Вход в систему"""
+    user = authenticate_user(db, form_data.username, form_data.password)
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    
+    # Обновление времени последнего входа
+    from datetime import datetime
+    user.last_login = datetime.utcnow()
+    db.commit()
+    
+    access_token_expires = timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
+    access_token = create_access_token(
+        data={"sub": user.username}, expires_delta=access_token_expires
+    )
+    return {"access_token": access_token, "token_type": "bearer"}
+
+
+@router.get("/me", response_model=UserResponse)
+async def read_users_me(current_user: User = Depends(get_current_active_user)):
+    """Получение информации о текущем пользователе"""
+    return current_user
+
+
+@router.post("/logout")
+async def logout(current_user: User = Depends(get_current_active_user)):
+    """Выход из системы"""
+    return {"message": "Successfully logged out"}

routes/game.py

@@ -0,0 +1,210 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from sqlalchemy import func
+from typing import List
+from datetime import datetime, timedelta
+from database import get_db
+from models import User, UserStats, GameSession, GameAction
+from schemas import (
+    UserStatsResponse,
+    UserStatsUpdate,
+    GameSessionCreate,
+    GameSessionResponse
+)
+from auth import get_current_active_user
+
+router = APIRouter(prefix="/api/game", tags=["Game"])
+
+
+@router.get("/stats", response_model=UserStatsResponse)
+async def get_user_stats(
+    current_user: User = Depends(get_current_active_user),
+    db: Session = Depends(get_db)
+):
+    """Получение статистики пользователя"""
+    stats = db.query(UserStats).filter(UserStats.user_id == current_user.id).first()
+    if not stats:
+        # Создаем статистику если не существует
+        stats = UserStats(user_id=current_user.id)
+        db.add(stats)
+        db.commit()
+        db.refresh(stats)
+    return stats
+
+
+@router.patch("/stats", response_model=UserStatsResponse)
+async def update_user_stats(
+    stats_update: UserStatsUpdate,
+    current_user: User = Depends(get_current_active_user),
+    db: Session = Depends(get_db)
+):
+    """Обновление статистики пользователя"""
+    stats = db.query(UserStats).filter(UserStats.user_id == current_user.id).first()
+    if not stats:
+        raise HTTPException(status_code=404, detail="Stats not found")
+    
+    # Обновление полей
+    update_data = stats_update.dict(exclude_unset=True)
+    for field, value in update_data.items():
+        setattr(stats, field, value)
+    
+    # Автоматический расчет уровня на основе опыта
+    if stats_update.experience is not None:
+        stats.level = 1 + (stats.experience // 100)
+    
+    db.commit()
+    db.refresh(stats)
+    return stats
+
+
+@router.post("/stats/consume-energy")
+async def consume_energy(
+    amount: float,
+    current_user: User = Depends(get_current_active_user),
+    db: Session = Depends(get_db)
+):
+    """Расход энергии"""
+    stats = db.query(UserStats).filter(UserStats.user_id == current_user.id).first()
+    if not stats:
+        raise HTTPException(status_code=404, detail="Stats not found")
+    
+    stats.energy = max(0, stats.energy - amount)
+    db.commit()
+    
+    return {"energy": stats.energy, "message": f"Consumed {amount} energy"}
+
+
+@router.post("/stats/restore-energy")
+async def restore_energy(
+    amount: float,
+    current_user: User = Depends(get_current_active_user),
+    db: Session = Depends(get_db)
+):
+    """Восстановление энергии"""
+    stats = db.query(UserStats).filter(UserStats.user_id == current_user.id).first()
+    if not stats:
+        raise HTTPException(status_code=404, detail="Stats not found")
+    
+    stats.energy = min(stats.max_energy, stats.energy + amount)
+    db.commit()
+    
+    return {"energy": stats.energy, "message": f"Restored {amount} energy"}
+
+
+@router.post("/stats/consume-hunger")
+async def consume_hunger(
+    amount: float,
+    current_user: User = Depends(get_current_active_user),
+    db: Session = Depends(get_db)
+):
+    """Расход сытости"""
+    stats = db.query(UserStats).filter(UserStats.user_id == current_user.id).first()
+    if not stats:
+        raise HTTPException(status_code=404, detail="Stats not found")
+    
+    stats.hunger = max(0, stats.hunger - amount)
+    db.commit()
+    
+    return {"hunger": stats.hunger, "message": f"Consumed {amount} hunger"}
+
+
+@router.post("/stats/restore-hunger")
+async def restore_hunger(
+    amount: float,
+    current_user: User = Depends(get_current_active_user),
+    db: Session = Depends(get_db)
+):
+    """Восстановление сытости (еда)"""
+    stats = db.query(UserStats).filter(UserStats.user_id == current_user.id).first()
+    if not stats:
+        raise HTTPException(status_code=404, detail="Stats not found")
+    
+    stats.hunger = min(stats.max_hunger, stats.hunger + amount)
+    db.commit()
+    
+    return {"hunger": stats.hunger, "message": f"Restored {amount} hunger"}
+
+
+@router.post("/session/start", response_model=GameSessionResponse)
+async def start_game_session(
+    current_user: User = Depends(get_current_active_user),
+    db: Session = Depends(get_db)
+):
+    """Начало игровой сессии"""
+    # Проверка активной сессии
+    active_session = db.query(GameSession).filter(
+        GameSession.user_id == current_user.id,
+        GameSession.ended_at == None
+    ).first()
+    
+    if active_session:
+        return active_session
+    
+    # Создание новой сессии
+    session = GameSession(user_id=current_user.id)
+    db.add(session)
+    db.commit()
+    db.refresh(session)
+    
+    return session
+
+
+@router.post("/session/end", response_model=GameSessionResponse)
+async def end_game_session(
+    current_user: User = Depends(get_current_active_user),
+    db: Session = Depends(get_db)
+):
+    """Завершение игровой сессии"""
+    session = db.query(GameSession).filter(
+        GameSession.user_id == current_user.id,
+        GameSession.ended_at == None
+    ).first()
+    
+    if not session:
+        raise HTTPException(status_code=404, detail="No active session found")
+    
+    session.ended_at = datetime.utcnow()
+    session.duration = int((session.ended_at - session.started_at).total_seconds())
+    
+    # Обновление общей статистики
+    stats = db.query(UserStats).filter(UserStats.user_id == current_user.id).first()
+    if stats:
+        stats.total_playtime += session.duration
+    
+    db.commit()
+    db.refresh(session)
+    
+    return session
+
+
+@router.get("/sessions", response_model=List[GameSessionResponse])
+async def get_user_sessions(
+    limit: int = 10,
+    current_user: User = Depends(get_current_active_user),
+    db: Session = Depends(get_db)
+):
+    """Получение истории игровых сессий"""
+    sessions = db.query(GameSession).filter(
+        GameSession.user_id == current_user.id
+    ).order_by(GameSession.started_at.desc()).limit(limit).all()
+    
+    return sessions
+
+
+@router.post("/action/{action_type}")
+async def log_game_action(
+    action_type: str,
+    action_data: str = None,
+    current_user: User = Depends(get_current_active_user),
+    db: Session = Depends(get_db)
+):
+    """Логирование игрового действия"""
+    action = GameAction(
+        user_id=current_user.id,
+        action_type=action_type,
+        action_data=action_data
+    )
+    db.add(action)
+    db.commit()
+    
+    return {"message": "Action logged", "action_type": action_type}

schemas.py

@@ -0,0 +1,127 @@
+from pydantic import BaseModel, EmailStr, Field
+from typing import Optional
+from datetime import datetime
+
+
+# User schemas
+class UserBase(BaseModel):
+    username: str = Field(..., min_length=3, max_length=50)
+    email: EmailStr
+
+
+class UserCreate(UserBase):
+    password: str = Field(..., min_length=6)
+
+
+class UserResponse(UserBase):
+    id: int
+    is_active: bool
+    is_admin: bool
+    created_at: datetime
+    last_login: Optional[datetime] = None
+
+    class Config:
+        from_attributes = True
+
+
+# Auth schemas
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+
+class TokenData(BaseModel):
+    username: Optional[str] = None
+
+
+class LoginRequest(BaseModel):
+    username: str
+    password: str
+
+
+# UserStats schemas
+class UserStatsBase(BaseModel):
+    energy: float = 100.0
+    max_energy: float = 100.0
+    hunger: float = 100.0
+    max_hunger: float = 100.0
+    level: int = 1
+    experience: int = 0
+    coins: int = 0
+
+
+class UserStatsResponse(UserStatsBase):
+    id: int
+    user_id: int
+    total_playtime: int
+    rooms_visited: int
+    items_collected: int
+    enemies_defeated: int
+    deaths: int
+    updated_at: datetime
+
+    class Config:
+        from_attributes = True
+
+
+class UserStatsUpdate(BaseModel):
+    energy: Optional[float] = None
+    hunger: Optional[float] = None
+    experience: Optional[int] = None
+    coins: Optional[int] = None
+    rooms_visited: Optional[int] = None
+    items_collected: Optional[int] = None
+    enemies_defeated: Optional[int] = None
+    deaths: Optional[int] = None
+
+
+# GameSession schemas
+class GameSessionCreate(BaseModel):
+    pass
+
+
+class GameSessionResponse(BaseModel):
+    id: int
+    user_id: int
+    started_at: datetime
+    ended_at: Optional[datetime] = None
+    duration: int
+    energy_consumed: float
+    hunger_consumed: float
+    rooms_visited_session: int
+    items_collected_session: int
+    enemies_defeated_session: int
+    deaths_session: int
+
+    class Config:
+        from_attributes = True
+
+
+# Admin schemas
+class AdminStats(BaseModel):
+    total_users: int
+    active_users_today: int
+    new_users_today: int
+    total_sessions: int
+    avg_session_duration: float
+    total_playtime: int
+    total_rooms_visited: int
+    total_items_collected: int
+    total_enemies_defeated: int
+
+
+class UserListItem(BaseModel):
+    id: int
+    username: str
+    email: str
+    is_active: bool
+    is_admin: bool
+    created_at: datetime
+    last_login: Optional[datetime] = None
+    
+    class Config:
+        from_attributes = True
+
+
+class UserDetail(UserListItem):
+    stats: Optional[UserStatsResponse] = None

test_api.py

@@ -0,0 +1,189 @@
+import requests
+import json
+from time import sleep
+
+BASE_URL = "http://localhost:8000"
+
+def print_response(title, response):
+    """Красивый вывод ответа"""
+    print(f"\n{'='*60}")
+    print(f"🔹 {title}")
+    print(f"{'='*60}")
+    print(f"Status: {response.status_code}")
+    try:
+        print(json.dumps(response.json(), indent=2, ensure_ascii=False))
+    except:
+        print(response.text)
+
+def test_api():
+    """Тестирование всех эндпоинтов API"""
+    
+    # 1. Проверка корневого эндпоинта
+    print("\n🚀 НАЧАЛО ТЕСТИРОВАНИЯ API")
+    response = requests.get(f"{BASE_URL}/")
+    print_response("GET / - Корневой эндпоинт", response)
+    
+    # 2. Health check
+    response = requests.get(f"{BASE_URL}/health")
+    print_response("GET /health - Проверка здоровья", response)
+    
+    # 3. Регистрация нового пользователя
+    user_data = {
+        "username": "testuser",
+        "email": "test@example.com",
+        "password": "password123"
+    }
+    response = requests.post(f"{BASE_URL}/api/auth/register", json=user_data)
+    print_response("POST /api/auth/register - Регистрация", response)
+    
+    # 4. Вход пользователя
+    login_data = {
+        "username": "testuser",
+        "password": "password123"
+    }
+    response = requests.post(
+        f"{BASE_URL}/api/auth/login",
+        data=login_data,
+        headers={"Content-Type": "application/x-www-form-urlencoded"}
+    )
+    print_response("POST /api/auth/login - Вход пользователя", response)
+    
+    if response.status_code == 200:
+        user_token = response.json()["access_token"]
+        print(f"✅ Получен токен пользователя")
+    else:
+        print("❌ Не удалось получить токен")
+        return
+    
+    # 5. Информация о текущем пользователе
+    headers = {"Authorization": f"Bearer {user_token}"}
+    response = requests.get(f"{BASE_URL}/api/auth/me", headers=headers)
+    print_response("GET /api/auth/me - Текущий пользователь", response)
+    
+    # 6. Получение статистики игрока
+    response = requests.get(f"{BASE_URL}/api/game/stats", headers=headers)
+    print_response("GET /api/game/stats - Статистика игрока", response)
+    
+    # 7. Начало игровой сессии
+    response = requests.post(f"{BASE_URL}/api/game/session/start", headers=headers)
+    print_response("POST /api/game/session/start - Начало сессии", response)
+    
+    # 8. Расход энергии
+    response = requests.post(f"{BASE_URL}/api/game/stats/consume-energy?amount=10", headers=headers)
+    print_response("POST /api/game/stats/consume-energy - Расход энергии", response)
+    
+    # 9. Восстановление энергии
+    response = requests.post(f"{BASE_URL}/api/game/stats/restore-energy?amount=5", headers=headers)
+    print_response("POST /api/game/stats/restore-energy - Восстановление энергии", response)
+    
+    # 10. Расход сытости
+    response = requests.post(f"{BASE_URL}/api/game/stats/consume-hunger?amount=15", headers=headers)
+    print_response("POST /api/game/stats/consume-hunger - Расход сытости", response)
+    
+    # 11. Восстановление сытости (еда)
+    response = requests.post(f"{BASE_URL}/api/game/stats/restore-hunger?amount=20", headers=headers)
+    print_response("POST /api/game/stats/restore-hunger - Еда", response)
+    
+    # 12. Обновление статистики
+    stats_update = {
+        "experience": 50,
+        "coins": 100,
+        "rooms_visited": 5,
+        "items_collected": 10,
+        "enemies_defeated": 3
+    }
+    response = requests.patch(f"{BASE_URL}/api/game/stats", json=stats_update, headers=headers)
+    print_response("PATCH /api/game/stats - Обновление статистики", response)
+    
+    # 13. Логирование действия
+    response = requests.post(
+        f"{BASE_URL}/api/game/action/move?action_data=room_1_to_room_2",
+        headers=headers
+    )
+    print_response("POST /api/game/action/move - Логирование действия", response)
+    
+    # Подождем 2 секунды для сессии
+    print("\n⏳ Ждем 2 секунды для статистики сессии...")
+    sleep(2)
+    
+    # 14. Завершение сессии
+    response = requests.post(f"{BASE_URL}/api/game/session/end", headers=headers)
+    print_response("POST /api/game/session/end - Завершение сессии", response)
+    
+    # 15. История сессий
+    response = requests.get(f"{BASE_URL}/api/game/sessions?limit=5", headers=headers)
+    print_response("GET /api/game/sessions - История сессий", response)
+    
+    # ТЕСТИРОВАНИЕ АДМИНКИ
+    print("\n" + "="*60)
+    print("👨‍💼 ТЕСТИРОВАНИЕ АДМИН-ПАНЕЛИ")
+    print("="*60)
+    
+    # 16. Вход администратора
+    admin_login = {
+        "username": "admin",
+        "password": "admin123"
+    }
+    response = requests.post(
+        f"{BASE_URL}/api/auth/login",
+        data=admin_login,
+        headers={"Content-Type": "application/x-www-form-urlencoded"}
+    )
+    print_response("POST /api/auth/login - Вход администратора", response)
+    
+    if response.status_code == 200:
+        admin_token = response.json()["access_token"]
+        print(f"✅ Получен токен администратора")
+    else:
+        print("❌ Не удалось получить токен администратора")
+        return
+    
+    admin_headers = {"Authorization": f"Bearer {admin_token}"}
+    
+    # 17. Общая статистика
+    response = requests.get(f"{BASE_URL}/api/admin/stats/overview", headers=admin_headers)
+    print_response("GET /api/admin/stats/overview - Общая статистика", response)
+    
+    # 18. Список пользователей
+    response = requests.get(f"{BASE_URL}/api/admin/users", headers=admin_headers)
+    print_response("GET /api/admin/users - Список пользователей", response)
+    
+    # 19. Топ игроков
+    response = requests.get(f"{BASE_URL}/api/admin/stats/top-players?metric=level&limit=5", headers=admin_headers)
+    print_response("GET /api/admin/stats/top-players - Топ по уровню", response)
+    
+    # 20. График сессий
+    response = requests.get(f"{BASE_URL}/api/admin/stats/sessions-timeline?days=7", headers=admin_headers)
+    print_response("GET /api/admin/stats/sessions-timeline - График сессий", response)
+    
+    # 21. Тепловая карта активности
+    response = requests.get(f"{BASE_URL}/api/admin/stats/activity-heatmap", headers=admin_headers)
+    print_response("GET /api/admin/stats/activity-heatmap - Тепловая карта", response)
+    
+    # 22. Удержание пользователей
+    response = requests.get(f"{BASE_URL}/api/admin/stats/user-retention", headers=admin_headers)
+    print_response("GET /api/admin/stats/user-retention - Удержание", response)
+    
+    # 23. Игровые метрики
+    response = requests.get(f"{BASE_URL}/api/admin/stats/game-metrics", headers=admin_headers)
+    print_response("GET /api/admin/stats/game-metrics - Игровые метрики", response)
+    
+    # 24. Последние действия
+    response = requests.get(f"{BASE_URL}/api/admin/actions/recent?limit=10", headers=admin_headers)
+    print_response("GET /api/admin/actions/recent - Последние действия", response)
+    
+    # Итоги
+    print("\n" + "="*60)
+    print("✅ ТЕСТИРОВАНИЕ ЗАВЕРШЕНО!")
+    print("="*60)
+    print("\n📊 Проверьте документацию API: http://localhost:8000/docs")
+    print("📊 Альтернативная документация: http://localhost:8000/redoc")
+
+if __name__ == "__main__":
+    try:
+        test_api()
+    except requests.exceptions.ConnectionError:
+        print("\n❌ Ошибка: Не удалось подключиться к серверу")
+        print("Убедитесь, что сервер запущен на http://localhost:8000")
+    except Exception as e:
+        print(f"\n❌ Ошибка: {e}")