282 lines
11 KiB
Python
282 lines
11 KiB
Python
"""Профиль курсанта и прогресс.
|
||
|
||
«Контроль подготовленности» из ТЗ — не таблица оценок, а инструмент планирования
|
||
подготовки: радар компетенций, история попыток и дельта между ними
|
||
(docs/product/MODES.md#профиль-курсанта). Считается по журналу занятий.
|
||
"""
|
||
|
||
from datetime import datetime
|
||
from uuid import UUID
|
||
|
||
from fastapi import APIRouter, Depends, HTTPException, Request, Response
|
||
from pydantic import BaseModel
|
||
from sqlalchemy import exists, func, or_, select
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
|
||
from app.api.auth import DEMO_TRAINEE_ID, audit_required, require
|
||
from app.config import get_settings
|
||
from app.domain.roles import Role
|
||
from app.db.base import get_session, get_sessionmaker
|
||
from app.db.models import Group, Score, Session, Trainee, User
|
||
from app.domain.taxonomy import ERRORS, ErrorCode
|
||
from app.scoring.export import certificate_pdf
|
||
from app.scoring.group import RECOMMENDATIONS
|
||
from app.voice.recording import recording_path
|
||
|
||
router = APIRouter(prefix="/api/trainees", tags=["trainees"])
|
||
|
||
|
||
@router.get("/{trainee_id}/certificate.pdf")
|
||
async def certificate(
|
||
trainee_id: UUID, request: Request, db: AsyncSession = Depends(get_session)
|
||
) -> Response:
|
||
who = require(request)
|
||
if who.role is Role.TRAINEE and who.trainee_id != trainee_id:
|
||
raise HTTPException(status_code=403, detail="not_your_certificate")
|
||
if who.role is Role.INSTRUCTOR:
|
||
owns_trainee = await db.scalar(
|
||
select(Session.id)
|
||
.where(Session.trainee_id == trainee_id, Session.owner_login == who.login)
|
||
.limit(1)
|
||
)
|
||
if owns_trainee is None:
|
||
raise HTTPException(status_code=404, detail="trainee_not_found")
|
||
trainee = await db.get(Trainee, trainee_id)
|
||
if trainee is None:
|
||
raise HTTPException(status_code=404, detail="trainee_not_found")
|
||
group = await db.get(Group, trainee.group_id) if trainee.group_id else None
|
||
if who.role is Role.INSTRUCTOR and group is not None and group.owner_login != who.login:
|
||
group = None
|
||
scores_query = (
|
||
select(func.count(Score.id), func.avg(Score.score_final), func.max(Score.created_at))
|
||
.join(Session, Session.id == Score.session_id)
|
||
.where(Session.trainee_id == trainee_id)
|
||
)
|
||
if who.role is Role.INSTRUCTOR:
|
||
scores_query = scores_query.where(Session.owner_login == who.login)
|
||
result = await db.execute(scores_query)
|
||
attempts, average_score, completed_at = result.one()
|
||
if not attempts:
|
||
raise HTTPException(status_code=409, detail="no_scored_attempts")
|
||
try:
|
||
content = certificate_pdf(
|
||
trainee_name=trainee.name,
|
||
trainee_id=trainee.id,
|
||
group_name=group.name if group else None,
|
||
attempts=int(attempts),
|
||
average_score=float(average_score),
|
||
issued_at=completed_at.date().isoformat(),
|
||
)
|
||
except RuntimeError as exc:
|
||
raise HTTPException(status_code=503, detail=str(exc)) from exc
|
||
await audit_required(
|
||
who.login, who.role.value, "trainee.certificate.export.pdf", str(trainee_id)
|
||
)
|
||
return Response(
|
||
content=content,
|
||
media_type="application/pdf",
|
||
headers={"Content-Disposition": f'attachment; filename="trainee-{trainee_id}-certificate.pdf"'},
|
||
)
|
||
|
||
|
||
class TraineeOut(BaseModel):
|
||
id: UUID
|
||
name: str
|
||
group: str | None = None
|
||
service: str | None = None
|
||
|
||
|
||
class AttemptOut(BaseModel):
|
||
session_id: UUID
|
||
scenario_id: str
|
||
mode: str
|
||
attempt: int
|
||
created_at: datetime
|
||
score: float | None = None
|
||
interview_ms: int | None = None
|
||
facts_got: int | None = None
|
||
facts_required: int | None = None
|
||
hints: int | None = None
|
||
codes: dict[str, int] = {}
|
||
recording_available: bool = False
|
||
|
||
|
||
class DeltaOut(BaseModel):
|
||
"""Что изменилось от попытки к попытке — измеримый цикл работы над ошибками."""
|
||
|
||
scenario_id: str
|
||
from_attempt: int
|
||
to_attempt: int
|
||
score: float | None = None
|
||
interview_ms: int | None = None
|
||
facts_got: int | None = None
|
||
|
||
|
||
class RecommendationOut(BaseModel):
|
||
code: str
|
||
title: str
|
||
recommendation: str
|
||
occurrences: int
|
||
|
||
|
||
class ProfileOut(BaseModel):
|
||
trainee: TraineeOut
|
||
attempts: list[AttemptOut]
|
||
competencies: dict[str, float]
|
||
deltas: list[DeltaOut]
|
||
recommendations: list[RecommendationOut]
|
||
hints_total: int
|
||
|
||
|
||
def _personal_recommendations(codes: dict[str, int]) -> list[RecommendationOut]:
|
||
"""Следующие упражнения опираются на коды последней оценённой попытки."""
|
||
recommendations = []
|
||
for code, count in codes.items():
|
||
if code not in RECOMMENDATIONS or not isinstance(count, int) or count <= 0:
|
||
continue
|
||
error = ERRORS[ErrorCode(code)]
|
||
recommendations.append(RecommendationOut(
|
||
code=code,
|
||
title=error.title,
|
||
recommendation=RECOMMENDATIONS[code],
|
||
occurrences=count,
|
||
))
|
||
return sorted(recommendations, key=lambda item: (-item.occurrences, item.code))[:5]
|
||
|
||
|
||
@router.get("", response_model=list[TraineeOut])
|
||
async def listing(request: Request) -> list[TraineeOut]:
|
||
"""Список курсантов — преподавателю и администратору: обучающемуся он
|
||
не нужен, а чужие фамилии из него видны."""
|
||
who = require(request, Role.INSTRUCTOR, Role.ADMIN)
|
||
if get_settings().demo_no_db:
|
||
return [TraineeOut(id=DEMO_TRAINEE_ID, name="Демо-курсант", service="Служба 101")]
|
||
async with get_sessionmaker()() as db:
|
||
query = (
|
||
select(Trainee, Group.name, Group.owner_login, User.service)
|
||
.join(Group, Group.id == Trainee.group_id, isouter=True)
|
||
.join(User, User.trainee_id == Trainee.id, isouter=True)
|
||
)
|
||
if who.role is Role.INSTRUCTOR:
|
||
has_owned_attempt = exists(
|
||
select(Session.id).where(
|
||
Session.trainee_id == Trainee.id,
|
||
Session.owner_login == who.login,
|
||
)
|
||
)
|
||
query = query.where(
|
||
or_(
|
||
Trainee.group_id.is_(None),
|
||
Group.owner_login == who.login,
|
||
has_owned_attempt,
|
||
)
|
||
)
|
||
rows = await db.execute(query)
|
||
return [
|
||
TraineeOut(
|
||
id=trainee.id,
|
||
name=trainee.name,
|
||
group=(group if who.role is not Role.INSTRUCTOR or group_owner == who.login else None),
|
||
service=service,
|
||
)
|
||
for trainee, group, group_owner, service in rows
|
||
]
|
||
|
||
|
||
@router.get("/{trainee_id}/profile", response_model=ProfileOut)
|
||
async def profile(
|
||
trainee_id: UUID, request: Request, db: AsyncSession = Depends(get_session)
|
||
) -> ProfileOut:
|
||
who = require(request)
|
||
if who.role is Role.TRAINEE and who.trainee_id != trainee_id:
|
||
raise HTTPException(status_code=403, detail="not_your_profile")
|
||
if who.role is Role.INSTRUCTOR:
|
||
owns_trainee = await db.scalar(
|
||
select(Session.id)
|
||
.where(Session.trainee_id == trainee_id, Session.owner_login == who.login)
|
||
.limit(1)
|
||
)
|
||
if owns_trainee is None:
|
||
raise HTTPException(status_code=404, detail="trainee_not_found")
|
||
trainee = await db.get(Trainee, trainee_id)
|
||
if trainee is None:
|
||
raise HTTPException(status_code=404, detail="trainee_not_found")
|
||
group = await db.get(Group, trainee.group_id) if trainee.group_id else None
|
||
if who.role is Role.INSTRUCTOR and group is not None and group.owner_login != who.login:
|
||
group = None
|
||
|
||
attempts_query = (
|
||
select(Session, Score)
|
||
.join(Score, Score.session_id == Session.id, isouter=True)
|
||
.where(Session.trainee_id == trainee_id)
|
||
.order_by(Session.created_at)
|
||
)
|
||
if who.role is Role.INSTRUCTOR:
|
||
attempts_query = attempts_query.where(Session.owner_login == who.login)
|
||
rows = await db.execute(attempts_query)
|
||
attempts: list[AttemptOut] = []
|
||
competency_sums: dict[str, list[float]] = {}
|
||
latest_scored_codes: dict[str, int] = {}
|
||
for session, score in rows:
|
||
summary = (score.report or {}).get("summary", {}) if score else {}
|
||
if score is not None:
|
||
latest_scored_codes = summary.get("codes", {})
|
||
attempts.append(
|
||
AttemptOut(
|
||
session_id=session.id,
|
||
scenario_id=session.scenario_id,
|
||
mode=session.mode,
|
||
attempt=session.attempt,
|
||
created_at=session.created_at,
|
||
score=score.score_final if score else None,
|
||
interview_ms=summary.get("interview_ms"),
|
||
facts_got=summary.get("facts_got"),
|
||
facts_required=summary.get("facts_required"),
|
||
hints=summary.get("hints"),
|
||
codes=summary.get("codes", {}),
|
||
recording_available=recording_path(session.id).is_file(),
|
||
)
|
||
)
|
||
for item in (score.report or {}).get("competencies", []) if score else []:
|
||
competency_sums.setdefault(item["competency"], []).append(item["value"])
|
||
|
||
# Радар — среднее по попыткам: одна неудачная попытка не определяет курсанта.
|
||
competencies = {
|
||
name: round(sum(values) / len(values), 3) for name, values in competency_sums.items()
|
||
}
|
||
|
||
deltas: list[DeltaOut] = []
|
||
by_scenario: dict[str, list[AttemptOut]] = {}
|
||
for attempt in attempts:
|
||
by_scenario.setdefault(attempt.scenario_id, []).append(attempt)
|
||
for scenario_id, items in by_scenario.items():
|
||
for previous, current in zip(items, items[1:]):
|
||
deltas.append(
|
||
DeltaOut(
|
||
scenario_id=scenario_id,
|
||
from_attempt=previous.attempt,
|
||
to_attempt=current.attempt,
|
||
score=_diff(previous.score, current.score),
|
||
interview_ms=_diff(previous.interview_ms, current.interview_ms),
|
||
facts_got=_diff(previous.facts_got, current.facts_got),
|
||
)
|
||
)
|
||
|
||
result = ProfileOut(
|
||
trainee=TraineeOut(id=trainee.id, name=trainee.name, group=group.name if group else None),
|
||
attempts=attempts,
|
||
competencies=competencies,
|
||
deltas=deltas,
|
||
recommendations=_personal_recommendations(latest_scored_codes),
|
||
hints_total=sum(attempt.hints or 0 for attempt in attempts),
|
||
)
|
||
await audit_required(
|
||
who.login, who.role.value, "trainee.profile.read", str(trainee_id)
|
||
)
|
||
return result
|
||
|
||
|
||
def _diff(before, after):
|
||
if before is None or after is None:
|
||
return None
|
||
return round(after - before, 3)
|