feat: Freelancer Match — AI-матчинг, escrow, milestones, portfolio, skill-tests, verification

backend/app/api/ai.py

@@ -0,0 +1,34 @@
+"""AI endpoints: матчинг, рекомендации."""
+
+import logging
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.database import get_db
+from app.schemas.ai_match import AIMatchRequest, AIMatchResponse
+from app.services.ai_service import find_matches
+
+logger = logging.getLogger(__name__)
+router = APIRouter(prefix="/api/ai", tags=["ai"])
+
+
+@router.post("/match-project", response_model=list[AIMatchResponse])
+async def match_project(data: AIMatchRequest, db: AsyncSession = Depends(get_db)):
+    """Подобрать фрилансеров для проекта через AI."""
+    
+    matches = await find_matches(
+        db=db, project_id=data.project_id, limit=data.limit, min_score=data.min_score
+    )
+    
+    return [AIMatchResponse(**m) for m in matches]
+
+
+@router.post("/generate-cover-letter")
+async def generate_cover_letter(project_title: str, freelancer_skills: list[str]):
+    """Сгенерировать сопроводительное письмо для заявки."""
+    
+    # Placeholder — в продакшене вызов LLM
+    return {
+        "cover_letter": f"Здравствуйте! Я заинтересован в проекте '{project_title}'. Мой опыт работы с [{', '.join(freelancer_skills)}] позволяет качественно выполнить задачу."
+    }

backend/app/api/auth.py

@@ -0,0 +1,84 @@
+"""Auth endpoints: регистрация, логин, OAuth."""
+
+import logging
+from datetime import timedelta
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+
+from app.core.database import get_db
+from app.core.security import (
+    hash_password, verify_password, create_access_token, create_refresh_token, get_current_user
+)
+from app.schemas.user import UserCreate, UserLogin
+from app.schemas.auth import TokenPair
+from app.models.user import User, FreelancerProfile
+
+logger = logging.getLogger(__name__)
+router = APIRouter(prefix="/api/auth", tags=["auth"])
+
+
+@router.post("/register", response_model=TokenPair)
+async def register(data: UserCreate, db: AsyncSession = Depends(get_db)):
+    """Регистрация нового пользователя."""
+    
+    # Проверка email
+    result = await db.execute(select(User).where(User.email == data.email))
+    if result.scalar_one_or_none():
+        raise HTTPException(status_code=409, detail="Email уже зарегистрирован")
+    
+    # Создание пользователя
+    user = User(
+        email=data.email,
+        password_hash=hash_password(data.password),
+        role=data.role,
+        full_name=data.full_name,
+    )
+    db.add(user)
+    await db.commit()
+    await db.refresh(user)
+    
+    # Создаём профиль фрилансера по умолчанию
+    if data.role in ("freelancer", "both"):
+        profile = FreelancerProfile(
+            user_id=user.id,
+            skills=data.full_name or [],  # заполняется позже
+        )
+        db.add(profile)
+        await db.commit()
+    
+    # Генерация токенов
+    access_token = create_access_token({"sub": str(user.id), "role": data.role})
+    refresh_token = create_refresh_token({"sub": str(user.id)})
+    
+    return TokenPair(access_token=access_token, refresh_token=refresh_token)
+
+
+@router.post("/login", response_model=TokenPair)
+async def login(data: UserLogin, db: AsyncSession = Depends(get_db)):
+    """Логин пользователя."""
+    
+    result = await db.execute(select(User).where(User.email == data.email))
+    user = result.scalar_one_or_none()
+    
+    if not user or not verify_password(data.password, user.password_hash):
+        raise HTTPException(status_code=401, detail="Неверный email или пароль")
+    
+    access_token = create_access_token({"sub": str(user.id), "role": user.role})
+    refresh_token = create_refresh_token({"sub": str(user.id)})
+    
+    return TokenPair(access_token=access_token, refresh_token=refresh_token)
+
+
+@router.post("/refresh", response_model=TokenPair)
+async def refresh(token: dict = Depends(get_current_user)):
+    """Обновление access-токена."""
+    new_access = create_access_token({"sub": token["id"], "role": token["role"]})
+    return TokenPair(access_token=new_access, refresh_token="")
+
+
+@router.get("/me", response_model=dict)
+async def me(user: dict = Depends(get_current_user)):
+    """Получить текущего пользователя."""
+    return {"user_id": user["id"], "role": user["role"]}

backend/app/api/escrow.py

@@ -0,0 +1,82 @@
+"""Escrow endpoints (гарант)."""
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+
+from app.core.database import get_db
+from app.schemas.escrow import EscrowCreate, EscrowRelease
+from app.models.escrow import EscrowTransaction
+from app.models.project import Project
+
+router = APIRouter(prefix="/api/escrow", tags=["escrow"])
+
+
+@router.post("/create")
+async def create_escrow(data: EscrowCreate, db: AsyncSession = Depends(get_db)):
+    """Создать escrow-транзакцию."""
+    
+    result = await db.execute(select(Project).where(Project.id == data.project_id))
+    project = result.scalar_one_or_none()
+    
+    if not project:
+        raise HTTPException(status_code=404, detail="Проект не найден")
+    
+    transaction = EscrowTransaction(
+        project_id=data.project_id,
+        client_id=data.client_id,
+        freelancer_id=data.freelancer_id,
+        amount=data.amount,
+        status="pending",
+    )
+    db.add(transaction)
+    await db.commit()
+    await db.refresh(transaction)
+    
+    return {
+        "id": str(transaction.id),
+        "status": transaction.status,
+        "amount": float(transaction.amount),
+        "payment_url": f"https://stripe.com/pay/{transaction.id}",  # Stripe redirect
+    }
+
+
+@router.post("/release")
+async def release_escrow(data: EscrowRelease, db: AsyncSession = Depends(get_db)):
+    """Освободить средства фрилансеру."""
+    
+    result = await db.execute(select(EscrowTransaction).where(EscrowTransaction.id == data.transaction_id))
+    transaction = result.scalar_one_or_none()
+    
+    if not transaction or transaction.status != "locked":
+        raise HTTPException(status_code=400, detail="Транзакция не может быть разблокирована")
+    
+    # Комиссия платформы 10%
+    commission = transaction.amount * 0.10
+    freelancer_amount = transaction.amount - commission
+    
+    transaction.status = "released"
+    await db.commit()
+    
+    return {
+        "id": str(transaction.id),
+        "status": "released",
+        "freelancer_payout": float(freelancer_amount),
+        "platform_commission": float(commission),
+    }
+
+
+@router.post("/dispute")
+async def dispute_escrow(transaction_id: str, db: AsyncSession = Depends(get_db)):
+    """Открыть спор по escrow."""
+    
+    result = await db.execute(select(EscrowTransaction).where(EscrowTransaction.id == transaction_id))
+    transaction = result.scalar_one_or_none()
+    
+    if not transaction:
+        raise HTTPException(status_code=404, detail="Транзакция не найдена")
+    
+    transaction.status = "disputed"
+    await db.commit()
+    
+    return {"status": "dispute_opened", "transaction_id": str(transaction.id)}

backend/app/api/milestones.py

@@ -0,0 +1,71 @@
+"""Endpoints для Milestone-платежей (Upwork-style)."""
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+
+from app.core.database import get_db
+from app.core.security import get_current_user
+from app.models.project import Project
+from app.models.milestone import Milestone
+from app.models.escrow import EscrowTransaction
+
+router = APIRouter(prefix="/api/projects/{project_id}/milestones", tags=["milestones"])
+
+
+@router.post("", response_model=dict)
+async def create_milestone(
+    project_id: str, data: dict, db: AsyncSession = Depends(get_db), user: dict = Depends(get_current_user)
+):
+    """Создать milestone для проекта."""
+    
+    result = await db.execute(select(Project).where(Project.id == project_id))
+    project = result.scalar_one_or_none()
+    
+    if not project or project.client_id != user["id"]:
+        raise HTTPException(status_code=403, detail="Только владелец проекта может создавать milestones")
+    
+    milestone = Milestone(
+        project_id=project_id,
+        title=data.get("title", ""),
+        description=data.get("description"),
+        amount=float(data.get("amount")),
+        due_date=None,  # ISO format string
+    )
+    db.add(milestone)
+    await db.commit()
+    await db.refresh(milestone)
+    
+    return {"id": str(milestone.id), "status": milestone.status}
+
+
+@router.patch("/{milestone_id}/submit")
+async def submit_milestone(milestone_id: str, db: AsyncSession = Depends(get_db)):
+    """Фрилансер завершает milestone."""
+    
+    result = await db.execute(select(Milestone).where(Milestone.id == milestone_id))
+    milestone = result.scalar_one_or_none()
+    
+    if not milestone or milestone.status != "funded":
+        raise HTTPException(status_code=400, detail="Milestone не может быть завершён")
+    
+    milestone.status = "submitted"
+    await db.commit()
+    
+    return {"status": "submitted", "milestone_id": str(milestone.id)}
+
+
+@router.patch("/{milestone_id}/approve")
+async def approve_milestone(milestone_id: str, user: dict = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
+    """Клиент одобряет milestone."""
+    
+    result = await db.execute(select(Milestone).where(Milestone.id == milestone_id))
+    milestone = result.scalar_one_or_none()
+    
+    if not milestone or milestone.status != "submitted":
+        raise HTTPException(status_code=400, detail="Milestone не может быть одобрен")
+    
+    milestone.status = "approved"
+    await db.commit()
+    
+    return {"status": "approved", "milestone_id": str(milestone.id)}

backend/app/api/portfolio.py

@@ -0,0 +1,67 @@
+"""Endpoints для портфолио фрилансера."""
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+
+from app.core.database import get_db
+from app.core.security import get_current_user
+from app.models.portfolio import PortfolioItem
+from app.models.user import User
+
+router = APIRouter(prefix="/api/portfolio", tags=["portfolio"])
+
+
+@router.post("")
+async def create_portfolio_item(data: dict, db: AsyncSession = Depends(get_db), user: dict = Depends(get_current_user)):
+    """Добавить работу в портфолио."""
+    
+    item = PortfolioItem(
+        freelancer_id=user["id"],
+        title=data.get("title", ""),
+        description=data.get("description"),
+        image_url=data.get("image_url"),
+        live_url=data.get("live_url"),
+        technologies=data.get("technologies", []),
+    )
+    db.add(item)
+    await db.commit()
+    await db.refresh(item)
+    
+    return {"id": str(item.id)}
+
+
+@router.get("/user/{user_id}")
+async def list_portfolio(user_id: str, db: AsyncSession = Depends(get_db)):
+    """Список работ в портфолио пользователя."""
+    
+    result = await db.execute(select(PortfolioItem).where(PortfolioItem.freelancer_id == user_id))
+    items = result.scalars().all()
+    
+    return [
+        {
+            "id": str(i.id),
+            "title": i.title,
+            "description": i.description,
+            "image_url": i.image_url,
+            "live_url": i.live_url,
+            "technologies": i.technologies,
+            "created_at": str(i.created_at),
+        } for i in items
+    ]
+
+
+@router.delete("/{item_id}")
+async def delete_portfolio_item(item_id: str, user: dict = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
+    """Удалить работу из портфолио."""
+    
+    result = await db.execute(select(PortfolioItem).where(PortfolioItem.id == item_id))
+    item = result.scalar_one_or_none()
+    
+    if not item or item.freelancer_id != user["id"]:
+        raise HTTPException(status_code=403, detail="Нет доступа")
+    
+    await db.delete(item)
+    await db.commit()
+    
+    return {"status": "deleted"}

backend/app/api/projects.py

@@ -0,0 +1,122 @@
+"""Endpoints для проектов."""
+
+import logging
+from typing import Any
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, desc
+
+from app.core.database import get_db
+from app.core.security import get_current_user
+from app.schemas.project import ProjectCreate, ProjectUpdate, ProjectResponse
+from app.models.user import User
+from app.models.project import Project
+
+logger = logging.getLogger(__name__)
+router = APIRouter(prefix="/api/projects", tags=["projects"])
+
+
+@router.post("", response_model=ProjectResponse)
+async def create_project(data: ProjectCreate, db: AsyncSession = Depends(get_db), user: dict = Depends(get_current_user)):
+    """Создать новый проект."""
+    
+    project = Project(
+        client_id=user["id"],
+        title=data.title,
+        description=data.description,
+        category=data.category,
+        required_skills=data.required_skills,
+        budget_min=data.budget_min,
+        budget_max=data.budget_max,
+        deadline=data.deadline,
+    )
+    db.add(project)
+    await db.commit()
+    await db.refresh(project)
+    
+    return ProjectResponse(
+        id=str(project.id),
+        title=project.title,
+        description=project.description,
+        category=project.category,
+        required_skills=project.required_skills,
+        budget_min=float(project.budget_min) if project.budget_min else None,
+        budget_max=float(project.budget_max) if project.budget_max else None,
+        status=project.status,
+        deadline=str(project.deadline) if project.deadline else None,
+        created_at=str(project.created_at),
+        updated_at=str(project.updated_at),
+    )
+
+
+@router.get("", response_model=list[ProjectResponse])
+async def list_projects(
+    db: AsyncSession = Depends(get_db),
+    status_filter: str | None = Query(None, alias="status"),
+    category: str | None = None,
+    page: int = 1,
+    limit: int = 20,
+):
+    """Список проектов с фильтрацией."""
+    
+    stmt = select(Project)
+    
+    if status_filter:
+        stmt = stmt.where(Project.status == status_filter)
+    if category:
+        stmt = stmt.where(Project.category == category)
+    
+    stmt = stmt.order_by(desc(Project.created_at)).offset((page - 1) * limit).limit(limit)
+    
+    result = await db.execute(stmt)
+    projects = result.scalars().all()
+    
+    return [ProjectResponse(
+        id=str(p.id), title=p.title, description=p.description, category=p.category,
+        required_skills=p.required_skills, budget_min=float(p.budget_min) if p.budget_min else None,
+        budget_max=float(p.budget_max) if p.budget_max else None, status=p.status,
+        deadline=str(p.deadline) if p.deadline else None, created_at=str(p.created_at), updated_at=str(p.updated_at),
+    ) for p in projects]
+
+
+@router.get("/{project_id}", response_model=ProjectResponse)
+async def get_project(project_id: str, db: AsyncSession = Depends(get_db)):
+    """Получить проект по ID."""
+    
+    result = await db.execute(select(Project).where(Project.id == project_id))
+    project = result.scalar_one_or_none()
+    
+    if not project:
+        raise HTTPException(status_code=404, detail="Проект не найден")
+    
+    return ProjectResponse(
+        id=str(project.id), title=project.title, description=project.description, category=project.category,
+        required_skills=project.required_skills, budget_min=float(project.budget_min) if project.budget_min else None,
+        budget_max=float(project.budget_max) if project.budget_max else None, status=project.status,
+        deadline=str(project.deadline) if project.deadline else None, created_at=str(project.created_at), updated_at=str(project.updated_at),
+    )
+
+
+@router.put("/{project_id}", response_model=ProjectResponse)
+async def update_project(project_id: str, data: ProjectUpdate, db: AsyncSession = Depends(get_db)):
+    """Обновить проект."""
+    
+    result = await db.execute(select(Project).where(Project.id == project_id))
+    project = result.scalar_one_or_none()
+    
+    if not project:
+        raise HTTPException(status_code=404, detail="Проект не найден")
+    
+    for field, value in data.model_dump(exclude_unset=True).items():
+        setattr(project, field, value)
+    
+    await db.commit()
+    await db.refresh(project)
+    
+    return ProjectResponse(
+        id=str(project.id), title=project.title, description=project.description, category=project.category,
+        required_skills=project.required_skills, budget_min=float(project.budget_min) if project.budget_min else None,
+        budget_max=float(project.budget_max) if project.budget_max else None, status=project.status,
+        deadline=str(project.deadline) if project.deadline else None, created_at=str(project.created_at), updated_at=str(project.updated_at),
+    )

backend/app/api/proposals.py

@@ -0,0 +1,73 @@
+"""Endpoints для заявок фрилансеров."""
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, desc
+
+from app.core.database import get_db
+from app.core.security import get_current_user
+from app.schemas.proposal import ProposalCreate, ProposalResponse
+from app.models.project import Project
+from app.models.proposal import Proposal
+
+router = APIRouter(prefix="/api/projects/{project_id}/proposals", tags=["proposals"])
+
+
+@router.post("", response_model=ProposalResponse)
+async def create_proposal(
+    project_id: str, data: ProposalCreate, db: AsyncSession = Depends(get_db), user: dict = Depends(get_current_user)
+):
+    """Фрилансер подаёт заявку на проект."""
+    
+    result = await db.execute(select(Project).where(Project.id == project_id))
+    project = result.scalar_one_or_none()
+    
+    if not project:
+        raise HTTPException(status_code=404, detail="Проект не найден")
+    
+    proposal = Proposal(
+        project_id=project_id,
+        freelancer_id=user["id"],
+        cover_letter=data.cover_letter,
+        proposed_price=data.proposed_price,
+        estimated_days=data.estimated_days,
+    )
+    db.add(proposal)
+    await db.commit()
+    await db.refresh(proposal)
+    
+    return ProposalResponse(
+        id=str(proposal.id), project_id=project_id, freelancer_id=user["id"],
+        cover_letter=proposal.cover_letter, proposed_price=float(proposal.proposed_price) if proposal.proposed_price else None,
+        estimated_days=proposal.estimated_days, status=proposal.status, created_at=str(proposal.created_at),
+    )
+
+
+@router.get("", response_model=list[ProposalResponse])
+async def list_proposals(project_id: str, db: AsyncSession = Depends(get_db)):
+    """Список заявок на проект."""
+    
+    result = await db.execute(select(Proposal).where(Proposal.project_id == project_id).order_by(desc(Proposal.created_at)))
+    proposals = result.scalars().all()
+    
+    return [ProposalResponse(
+        id=str(p.id), project_id=p.project_id, freelancer_id=p.freelancer_id, cover_letter=p.cover_letter,
+        proposed_price=float(p.proposed_price) if p.proposed_price else None, estimated_days=p.estimated_days,
+        status=p.status, created_at=str(p.created_at),
+    ) for p in proposals]
+
+
+@router.patch("/{proposal_id}/status")
+async def update_proposal_status(proposal_id: str, status: str, db: AsyncSession = Depends(get_db)):
+    """Обновить статус заявки (accept/reject)."""
+    
+    result = await db.execute(select(Proposal).where(Proposal.id == proposal_id))
+    proposal = result.scalar_one_or_none()
+    
+    if not proposal:
+        raise HTTPException(status_code=404, detail="Заявка не найдена")
+    
+    proposal.status = status
+    await db.commit()
+    
+    return {"status": "updated", "proposal_id": str(proposal.id)}

backend/app/api/reviews.py

@@ -0,0 +1,80 @@
+"""Endpoints для отзывов и рейтингов."""
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, func
+
+from app.core.database import get_db
+from app.core.security import get_current_user
+from app.schemas.review import ReviewCreate, ReviewResponse
+from app.models.project import Project
+from app.models.review import Review
+from app.models.user import User
+
+router = APIRouter(prefix="/api/reviews", tags=["reviews"])
+
+
+@router.post("", response_model=ReviewResponse)
+async def create_review(data: ReviewCreate, db: AsyncSession = Depends(get_db), user: dict = Depends(get_current_user)):
+    """Оставить отзыв на проект."""
+    
+    result = await db.execute(select(Project).where(Project.id == data.project_id))
+    project = result.scalar_one_or_none()
+    
+    if not project:
+        raise HTTPException(status_code=404, detail="Проект не найден")
+    
+    # Проверка что пользователь участвовал в проекте
+    if user["id"] != project.client_id and user["id"] != project.proposals[0].freelancer_id if project.proposals else True:
+        raise HTTPException(status_code=403, detail="Только участники проекта могут оставить отзыв")
+    
+    review = Review(
+        project_id=data.project_id,
+        reviewer_id=user["id"],
+        reviewee_id=data.reviewee_id,
+        rating=data.rating,
+        comment=data.comment,
+    )
+    db.add(review)
+    await db.commit()
+    await db.refresh(review)
+    
+    # Обновляем рейтинг пользователя
+    result = await db.execute(select(func.avg(Review.rating)).where(Review.reviewee_id == data.reviewee_id))
+    avg_rating = float(result.scalar_one_or_none()) or 0.0
+    
+    return ReviewResponse(
+        id=str(review.id),
+        project_id=review.project_id,
+        reviewer_name="Аноним",
+        reviewee_name="Аноним",
+        rating=review.rating,
+        comment=review.comment,
+        created_at=str(review.created_at),
+    )
+
+
+@router.get("/project/{project_id}", response_model=list[ReviewResponse])
+async def list_reviews(project_id: str, db: AsyncSession = Depends(get_db)):
+    """Список отзывов по проекту."""
+    
+    result = await db.execute(select(Review).where(Review.project_id == project_id))
+    reviews = result.scalars().all()
+    
+    return [ReviewResponse(
+        id=str(r.id), project_id=r.project_id, reviewer_name="Аноним", reviewee_name="Аноним",
+        rating=r.rating, comment=r.comment, created_at=str(r.created_at)
+    ) for r in reviews]
+
+
+@router.get("/user/{user_id}", response_model=dict)
+async def get_user_rating(user_id: str, db: AsyncSession = Depends(get_db)):
+    """Получить рейтинг пользователя."""
+    
+    result = await db.execute(select(func.avg(Review.rating)).where(Review.reviewee_id == user_id))
+    avg_rating = float(result.scalar_one_or_none()) or 0.0
+    
+    result2 = await db.execute(select(func.count(Review.id)).where(Review.reviewee_id == user_id))
+    total_reviews = int(result2.scalar_one_or_none()) or 0
+    
+    return {"user_id": user_id, "rating": round(avg_rating, 1), "total_reviews": total_reviews}

backend/app/api/skill_tests.py

@@ -0,0 +1,106 @@
+"""Endpoints для Skill Tests (сертификация навыков)."""
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+
+from app.core.database import get_db
+from app.core.security import get_current_user
+from app.models.skill_test import SkillTest, SkillTestResult
+from app.models.user import User
+
+router = APIRouter(prefix="/api/skill-tests", tags=["skill-tests"])
+
+
+@router.get("")
+async def list_tests(db: AsyncSession = Depends(get_db)):
+    """Список доступных тестов навыков."""
+    
+    result = await db.execute(select(SkillTest))
+    tests = result.scalars().all()
+    
+    return [
+        {
+            "id": str(t.id),
+            "name": t.name,
+            "category": t.category,
+            "questions_count": t.questions_count,
+            "passing_score": t.passing_score,
+        } for t in tests
+    ]
+
+
+@router.post("/take/{test_id}")
+async def take_test(test_id: str, user: dict = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
+    """Начать тест навыков."""
+    
+    result = await db.execute(select(SkillTest).where(SkillTest.id == test_id))
+    test = result.scalar_one_or_none()
+    
+    if not test:
+        raise HTTPException(status_code=404, detail="Тест не найден")
+    
+    # Генерация вопросов (placeholder — в продакшене реальные вопросы)
+    questions = [
+        {"id": i + 1, "question": f"Вопрос {i+1} по теме '{test.name}'", "options": ["A", "B", "C", "D"], "correct": 0}
+        for i in range(test.questions_count)
+    ]
+    
+    return {"test_id": str(test.id), "questions": questions, "time_limit_minutes": test.questions_count * 2}
+
+
+@router.post("/submit/{test_id}")
+async def submit_test(test_id: str, answers: dict, user: dict = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
+    """Отправить ответы на тест."""
+    
+    result = await db.execute(select(SkillTest).where(SkillTest.id == test_id))
+    test = result.scalar_one_or_none()
+    
+    if not test:
+        raise HTTPException(status_code=404, detail="Тест не найден")
+    
+    # Подсчёт баллов (placeholder)
+    score = 75.0  # В продакшене реальный подсчёт
+    
+    passed = score >= test.passing_score
+    
+    result2 = await db.execute(select(SkillTestResult).where(
+        SkillTestResult.user_id == user["id"],
+        SkillTestResult.skill_test_id == test_id,
+    ))
+    existing = result2.scalar_one_or_none()
+    
+    if existing:
+        existing.score = score
+        existing.passed = passed
+        existing.completed_at = None  # TODO: datetime.now(timezone.utc)
+    else:
+        new_result = SkillTestResult(
+            user_id=user["id"],
+            skill_test_id=test_id,
+            score=score,
+            passed=passed,
+            completed_at=None,
+        )
+        db.add(new_result)
+    
+    await db.commit()
+    
+    return {"score": score, "passed": passed}
+
+
+@router.get("/user/{user_id}")
+async def get_user_tests(user_id: str, db: AsyncSession = Depends(get_db)):
+    """Получить результаты тестов пользователя."""
+    
+    result = await db.execute(select(SkillTestResult).where(SkillTestResult.user_id == user_id))
+    results = result.scalars().all()
+    
+    return [
+        {
+            "test_name": r.skill_test.name if hasattr(r, 'skill_test') else "Unknown",
+            "score": r.score,
+            "passed": r.passed,
+            "completed_at": str(r.completed_at) if r.completed_at else None,
+        } for r in results
+    ]

backend/app/api/verification.py

@@ -0,0 +1,72 @@
+"""Endpoints для верификации профиля."""
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select
+
+from app.core.database import get_db
+from app.core.security import get_current_user
+from app.models.verification import Verification
+
+router = APIRouter(prefix="/api/verification", tags=["verification"])
+
+
+@router.get("/me")
+async def me_verification(user: dict = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
+    """Получить статус верификации текущего пользователя."""
+    
+    result = await db.execute(select(Verification).where(Verification.user_id == user["id"]))
+    verification = result.scalar_one_or_none()
+    
+    if not verification:
+        return {
+            "user_id": user["id"],
+            "is_email_verified": False,
+            "is_phone_verified": False,
+            "is_id_verified": False,
+            "is_bank_verified": False,
+            "verified_at": None,
+        }
+    
+    return {
+        "user_id": verification.user_id,
+        "is_email_verified": verification.is_email_verified,
+        "is_phone_verified": verification.is_phone_verified,
+        "is_id_verified": verification.is_id_verified,
+        "is_bank_verified": verification.is_bank_verified,
+        "verified_at": str(verification.verified_at) if verification.verified_at else None,
+    }
+
+
+@router.post("/email/verify")
+async def verify_email(user: dict = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
+    """Подтвердить email."""
+    
+    result = await db.execute(select(Verification).where(Verification.user_id == user["id"]))
+    verification = result.scalar_one_or_none()
+    
+    if not verification:
+        verification = Verification(user_id=user["id"])
+        db.add(verification)
+    
+    verification.is_email_verified = True
+    await db.commit()
+    
+    return {"status": "email_verified"}
+
+
+@router.post("/phone/verify")
+async def verify_phone(user: dict = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
+    """Подтвердить телефон."""
+    
+    result = await db.execute(select(Verification).where(Verification.user_id == user["id"]))
+    verification = result.scalar_one_or_none()
+    
+    if not verification:
+        verification = Verification(user_id=user["id"])
+        db.add(verification)
+    
+    verification.is_phone_verified = True
+    await db.commit()
+    
+    return {"status": "phone_verified"}