Merge branch 'feat/finding-review'
lct-35: разбор по отметкам — подтвердить, снять, добавить с пересчётом балла
This commit is contained in:
GGlamer
GitHub
commit
c1a67badbf
24 changed files with 1409 additions and 27 deletions
|
|
@ -23,14 +23,26 @@ from app.db import repo
|
|||
from app.db.base import get_session
|
||||
from app.db.models import Group, Score, Session, Trainee
|
||||
from app.domain.events import Exercise, SessionMode, SessionReport
|
||||
from app.domain.taxonomy import (
|
||||
ERRORS,
|
||||
ErrorCode,
|
||||
Finding,
|
||||
FindingDecision,
|
||||
FindingReview,
|
||||
FindingSource,
|
||||
)
|
||||
from app.domain.roles import Role
|
||||
from app.domain.statuses import SERVICE_STATUS_LABELS, DdsQueueCard, StationSnapshot, current
|
||||
from app.domain.timers import TimerCode, TimerState
|
||||
from app.scoring.export import to_csv, to_pdf
|
||||
from app.scoring.report import build as build_report
|
||||
from app.scoring.review import has_finding
|
||||
from app.scoring.taxonomy import METRIC_MAP
|
||||
from app.session.access import can_access
|
||||
from app.session.checkpoint import load_state
|
||||
from app.session.finish import override_score
|
||||
from app.session.finish import change_findings, override_score
|
||||
from app.session.store import FindingAdded, FindingReviewed
|
||||
from app.session.timers import now_utc
|
||||
from app.session.score import scoring_scenario
|
||||
from app.session.hub import hub
|
||||
from app.session.state import SessionState
|
||||
|
|
@ -649,6 +661,157 @@ async def override(
|
|||
return SessionReport.model_validate(report["full_report"])
|
||||
|
||||
|
||||
def _required_text(value: str) -> str:
|
||||
cleaned = value.strip()
|
||||
if not cleaned:
|
||||
raise ValueError("поле обязательно")
|
||||
return cleaned
|
||||
|
||||
|
||||
class FindingReviewIn(BaseModel):
|
||||
"""Решение по отметке: причина обязательна и остаётся в разборе."""
|
||||
|
||||
decision: FindingDecision
|
||||
reason: str = Field(min_length=1, max_length=1000)
|
||||
|
||||
_reason = field_validator("reason")(_required_text)
|
||||
|
||||
|
||||
class FindingIn(BaseModel):
|
||||
"""Отметка преподавателя: код, факт и норма — то же обоснование, что у автоматической."""
|
||||
|
||||
code: ErrorCode
|
||||
fact: str = Field(min_length=1, max_length=1000)
|
||||
norm: str = Field(min_length=1, max_length=1000)
|
||||
#: Номер карточки очереди ДДС (с 1); без него отметка относится к занятию.
|
||||
card: int | None = Field(default=None, ge=1)
|
||||
#: Ключ идемпотентности с клиента: повтор запроса не добавит отметку второй раз.
|
||||
client_id: UUID | None = None
|
||||
|
||||
_fact = field_validator("fact")(_required_text)
|
||||
_norm = field_validator("norm")(_required_text)
|
||||
|
||||
|
||||
async def _change_findings(
|
||||
session_id: UUID, who, db: AsyncSession | None, make,
|
||||
) -> SessionReport:
|
||||
"""Общий путь решений по отметкам — тот же, что у правки итога.
|
||||
|
||||
`make(who, score)` строит запись изменения по сохранённой оценке или
|
||||
отвечает HTTP-ошибкой. Роль проверяет маршрут: администратору сюда нельзя,
|
||||
как и к правке балла.
|
||||
"""
|
||||
state = hub.get(session_id)
|
||||
if state is not None:
|
||||
_require_access(who, state)
|
||||
if state.score is None:
|
||||
raise HTTPException(status_code=409, detail="score_not_ready")
|
||||
scenario = scoring_scenario(state)
|
||||
if scenario is None:
|
||||
raise HTTPException(status_code=409, detail="scenario_not_found")
|
||||
change = make(who, state.score)
|
||||
async with hub.operation(session_id):
|
||||
if not _repeated(state.score, change):
|
||||
change_findings(state, change)
|
||||
return build_report(session_id, state, scenario)
|
||||
|
||||
if db is None:
|
||||
raise HTTPException(status_code=404, detail="session_not_found")
|
||||
session = await repo.get_session(db, session_id)
|
||||
if session is None:
|
||||
raise HTTPException(status_code=404, detail="session_not_found")
|
||||
_require_access(who, session)
|
||||
score = await db.scalar(select(Score).where(Score.session_id == session_id))
|
||||
if score is None:
|
||||
raise HTTPException(status_code=409, detail="score_not_ready")
|
||||
if (score.report or {}).get("full_report") is None:
|
||||
raise HTTPException(status_code=409, detail="report_not_archived")
|
||||
current = dict(score.report)
|
||||
change = make(who, current)
|
||||
await db.rollback() # чтение закончено; запись — одной транзакцией хранилища
|
||||
if not _repeated(current, change):
|
||||
await hub.store.commit_archived(session_id, [change])
|
||||
# Ответ — по строке после commit: пересчёт шёл под блокировкой и мог учесть
|
||||
# решение из соседней вкладки, которого не было в прочитанном выше отчёте.
|
||||
score = await db.scalar(
|
||||
select(Score).where(Score.session_id == session_id)
|
||||
.execution_options(populate_existing=True)
|
||||
)
|
||||
report = SessionReport.model_validate(score.report["full_report"])
|
||||
await db.rollback()
|
||||
return report
|
||||
|
||||
|
||||
def _repeated(report: dict, change: FindingReviewed | FindingAdded) -> bool:
|
||||
return isinstance(change, FindingAdded) and has_finding(report, change.finding.client_id)
|
||||
|
||||
|
||||
@router.post("/{session_id}/findings/{index}/review", response_model=SessionReport)
|
||||
async def review_finding(
|
||||
session_id: UUID,
|
||||
index: int,
|
||||
body: FindingReviewIn,
|
||||
request: Request,
|
||||
db: AsyncSession | None = Depends(optional_session),
|
||||
) -> SessionReport:
|
||||
"""Подтвердить или снять отметку; снятая не штрафует свою метрику."""
|
||||
who = require(request, Role.INSTRUCTOR)
|
||||
|
||||
def make(who, score: dict) -> FindingReviewed:
|
||||
if not 0 <= index < len(score.get("findings", [])):
|
||||
raise HTTPException(status_code=404, detail="finding_not_found")
|
||||
return FindingReviewed(index=index, role=who.role.value, review=FindingReview(
|
||||
decision=body.decision, reason=body.reason, author=who.login, at=now_utc(),
|
||||
))
|
||||
|
||||
return await _change_findings(session_id, who, db, make)
|
||||
|
||||
|
||||
@router.post("/{session_id}/findings", response_model=SessionReport)
|
||||
async def add_finding(
|
||||
session_id: UUID,
|
||||
body: FindingIn,
|
||||
request: Request,
|
||||
db: AsyncSession | None = Depends(optional_session),
|
||||
) -> SessionReport:
|
||||
"""Отметка преподавателя штрафует связанную метрику по той же методике."""
|
||||
who = require(request, Role.INSTRUCTOR)
|
||||
|
||||
def make(who, score: dict) -> FindingAdded:
|
||||
service = None
|
||||
prefix = ""
|
||||
exercise = (score.get("full_report") or {}).get("exercise")
|
||||
# E1–E6 в связке 112 → ДДС — ошибки приёма вызова: их метрики у занятия,
|
||||
# а не у карточки очереди. С номером карточки отметка не нашла бы свою
|
||||
# метрику 112 и штрафовала бы отдельной метрикой преподавателя.
|
||||
if (body.card is not None and body.code.value.startswith("E")
|
||||
and exercise != Exercise.DDS.value):
|
||||
raise HTTPException(status_code=422, detail="call_code_without_card")
|
||||
if body.card is not None:
|
||||
cards = score.get("card_results") or []
|
||||
if body.card > len(cards):
|
||||
raise HTTPException(status_code=422, detail="card_not_found")
|
||||
service = cards[body.card - 1].get("managed_service")
|
||||
prefix = f"Карточка {body.card}: " + (f"{service}: " if service else "")
|
||||
competency = next((item for code, item in METRIC_MAP.values() if code is body.code), None)
|
||||
return FindingAdded(role=who.role.value, finding=Finding(
|
||||
code=body.code,
|
||||
source=FindingSource.INSTRUCTOR,
|
||||
summary=f"{prefix}{ERRORS[body.code].title}",
|
||||
fact=body.fact,
|
||||
norm=body.norm,
|
||||
ref="отметка преподавателя на разборе",
|
||||
competency=competency,
|
||||
at=now_utc(),
|
||||
card=body.card,
|
||||
service=service,
|
||||
author=who.login,
|
||||
client_id=body.client_id,
|
||||
))
|
||||
|
||||
return await _change_findings(session_id, who, db, make)
|
||||
|
||||
|
||||
@router.get("", response_model=list[SessionOut])
|
||||
async def listing(
|
||||
request: Request,
|
||||
|
|
|
|||
|
|
@ -23,7 +23,7 @@ from app.domain.roles import Role
|
|||
from app.domain.statuses import ServiceStatus, StationSnapshot
|
||||
from app.domain.taxonomy import Finding
|
||||
from app.domain.timers import TimerSnapshot
|
||||
from app.scoring.taxonomy import METRIC_MAP
|
||||
from app.scoring.taxonomy import INSTRUCTOR_METRIC, METRIC_MAP
|
||||
|
||||
|
||||
class SessionMode(StrEnum):
|
||||
|
|
@ -60,7 +60,7 @@ class LessonCriteria(BaseModel):
|
|||
@field_validator("score_weights")
|
||||
@classmethod
|
||||
def validate_score_weights(cls, weights: dict[str, float]) -> dict[str, float]:
|
||||
unknown = weights.keys() - METRIC_MAP.keys()
|
||||
unknown = weights.keys() - METRIC_MAP.keys() - {INSTRUCTOR_METRIC}
|
||||
if unknown:
|
||||
raise ValueError(f"неизвестные метрики весов: {', '.join(sorted(unknown))}")
|
||||
if any(not 0 <= weight <= 10 for weight in weights.values()):
|
||||
|
|
@ -692,6 +692,12 @@ class Metric(BaseModel):
|
|||
passed: bool
|
||||
weight: float = 1.0
|
||||
credit: float | None = Field(default=None, ge=0, le=1)
|
||||
#: Номер карточки очереди ДДС (с 1) и служба — область метрики для разбора.
|
||||
card: int | None = None
|
||||
service: str | None = None
|
||||
#: Автоматический вердикт, если его изменило решение преподавателя по отметке.
|
||||
passed_auto: bool | None = None
|
||||
credit_auto: float | None = Field(default=None, ge=0, le=1)
|
||||
|
||||
|
||||
class CompetencyScore(BaseModel):
|
||||
|
|
@ -741,6 +747,8 @@ class DdsCardReport(BaseModel):
|
|||
card_id: UUID
|
||||
scenario_id: str
|
||||
score_auto: float
|
||||
#: Балл карточки после решений преподавателя по отметкам; None — решений не было.
|
||||
score_reviewed: float | None = None
|
||||
reply_text: str
|
||||
metrics: list[Metric]
|
||||
findings: list[Finding]
|
||||
|
|
@ -780,6 +788,8 @@ class SessionReport(BaseModel):
|
|||
self_assessment_diff: SelfAssessmentDiff | None = None
|
||||
notes: list[InstructorNoteShown] = []
|
||||
score_auto: float
|
||||
#: Балл после решений преподавателя по отметкам; None — решений не было.
|
||||
score_reviewed: float | None = None
|
||||
score_final: float
|
||||
overridden_by: str | None = None
|
||||
override_comment: str | None = None
|
||||
|
|
|
|||
|
|
@ -7,8 +7,10 @@
|
|||
|
||||
from datetime import datetime
|
||||
from enum import StrEnum
|
||||
from typing import Any
|
||||
from uuid import UUID
|
||||
|
||||
from pydantic import BaseModel
|
||||
from pydantic import BaseModel, model_validator
|
||||
|
||||
|
||||
class ErrorCode(StrEnum):
|
||||
|
|
@ -152,6 +154,22 @@ COMPETENCY_LABELS: dict[Competency, str] = {
|
|||
}
|
||||
|
||||
|
||||
class FindingDecision(StrEnum):
|
||||
"""Решение преподавателя по отметке на разборе."""
|
||||
|
||||
CONFIRMED = "confirmed"
|
||||
DISMISSED = "dismissed"
|
||||
|
||||
|
||||
class FindingReview(BaseModel):
|
||||
"""Кто, когда и почему подтвердил или снял отметку. Сама отметка остаётся."""
|
||||
|
||||
decision: FindingDecision
|
||||
reason: str
|
||||
author: str
|
||||
at: datetime
|
||||
|
||||
|
||||
class Finding(BaseModel):
|
||||
"""Отметка в разборе. `fact` и `norm` — то самое обоснование."""
|
||||
|
||||
|
|
@ -164,3 +182,32 @@ class Finding(BaseModel):
|
|||
competency: Competency | None = None
|
||||
transcript_ref: str | None = None
|
||||
at: datetime | None = None
|
||||
#: Метрика, чей провал объясняет отметка. Без неё связь с метриками идёт
|
||||
#: по методике METRIC_MAP в пределах той же карточки и службы.
|
||||
metric_key: str | None = None
|
||||
#: Номер карточки очереди ДДС (с 1) и служба, к которым относится отметка.
|
||||
card: int | None = None
|
||||
service: str | None = None
|
||||
#: Автор ручной отметки преподавателя (`source=instructor`).
|
||||
author: str | None = None
|
||||
#: Ключ идемпотентности ручной отметки: повтор запроса не добавляет её снова.
|
||||
client_id: UUID | None = None
|
||||
#: Все решения по отметке по порядку; действует последнее. Прежние не
|
||||
#: затираются: «кто, когда, почему» нужно по каждой правке, а не по итогу.
|
||||
reviews: list[FindingReview] = []
|
||||
|
||||
@model_validator(mode="before")
|
||||
@classmethod
|
||||
def _single_review(cls, data: Any) -> Any:
|
||||
# Разборы, сохранённые до истории решений, хранили одно поле `review`.
|
||||
if isinstance(data, dict) and "review" in data:
|
||||
data = dict(data)
|
||||
single = data.pop("review")
|
||||
if single and not data.get("reviews"):
|
||||
data["reviews"] = [single]
|
||||
return data
|
||||
|
||||
@property
|
||||
def review(self) -> FindingReview | None:
|
||||
"""Действующее решение — последнее."""
|
||||
return self.reviews[-1] if self.reviews else None
|
||||
|
|
|
|||
|
|
@ -30,6 +30,7 @@ def evaluate_card(scenario: Scenario, kio: KIO) -> GostResult:
|
|||
source=FindingSource.KIO if code.value == "E5" else FindingSource.GROUND_TRUTH,
|
||||
summary=f"{title}: {fact}; требуется {norm}",
|
||||
fact=fact, norm=norm, ref=ref, competency=competency,
|
||||
metric_key=key,
|
||||
))
|
||||
|
||||
if truth.incident_code:
|
||||
|
|
|
|||
|
|
@ -28,8 +28,10 @@ from app.domain.timers import GOST_REF
|
|||
PROGRESS = (ServiceStatus.RESPONDING, ServiceStatus.ARRIVED, ServiceStatus.WORKING)
|
||||
|
||||
|
||||
def _finding(code: ErrorCode, summary: str, fact: str, norm: str | None = None) -> Finding:
|
||||
def _finding(service: str, code: ErrorCode, summary: str, fact: str,
|
||||
norm: str | None = None) -> Finding:
|
||||
return Finding(
|
||||
service=service,
|
||||
code=code,
|
||||
source=FindingSource.DISPATCHER,
|
||||
summary=summary,
|
||||
|
|
@ -117,7 +119,7 @@ def evaluate_dispatcher(
|
|||
]
|
||||
if missing_comment_statuses:
|
||||
findings.append(_finding(
|
||||
ErrorCode.D5,
|
||||
service, ErrorCode.D5,
|
||||
f"{service}: к статусу не добавлены основание и сведения",
|
||||
fact="не заполнены комментарии: " + ", ".join(missing_comment_statuses),
|
||||
norm="к каждой ручной отметке добавить основание и содержание полученных сведений",
|
||||
|
|
@ -132,7 +134,7 @@ def evaluate_dispatcher(
|
|||
]
|
||||
if incomplete_comment_statuses:
|
||||
findings.append(_finding(
|
||||
ErrorCode.D5,
|
||||
service, ErrorCode.D5,
|
||||
f"{service}: комментарии к статусам не разделяют основание и сведения",
|
||||
fact="неполные комментарии: " + ", ".join(incomplete_comment_statuses),
|
||||
norm="в каждом комментарии заполнить отдельные поля «Основание» и «Сведения»",
|
||||
|
|
@ -152,7 +154,7 @@ def evaluate_dispatcher(
|
|||
]
|
||||
if missing_recipients:
|
||||
findings.append(_finding(
|
||||
ErrorCode.D5,
|
||||
service, ErrorCode.D5,
|
||||
f"{service}: отдельный комментарий не указывает получателя сведений",
|
||||
fact="; ".join(missing_recipients)[:500],
|
||||
norm=(
|
||||
|
|
@ -166,7 +168,7 @@ def evaluate_dispatcher(
|
|||
if primary is None:
|
||||
findings.append(
|
||||
_finding(
|
||||
ErrorCode.D1,
|
||||
service, ErrorCode.D1,
|
||||
f"{service}: статус реагирования не проставлен",
|
||||
fact=(
|
||||
f"прошло {elapsed_ms // 1000} с"
|
||||
|
|
@ -181,7 +183,7 @@ def evaluate_dispatcher(
|
|||
if elapsed_ms is None or elapsed_ms > deadline_ms:
|
||||
findings.append(
|
||||
_finding(
|
||||
ErrorCode.D1,
|
||||
service, ErrorCode.D1,
|
||||
f"{service}: первичный статус проставлен с нарушением срока",
|
||||
fact=(
|
||||
f"прошло {elapsed_ms // 1000} с"
|
||||
|
|
@ -197,7 +199,7 @@ def evaluate_dispatcher(
|
|||
if mark.status in REFUSAL_COMMENT_REQUIRED and not mark.comment.strip():
|
||||
findings.append(
|
||||
_finding(
|
||||
ErrorCode.D4,
|
||||
service, ErrorCode.D4,
|
||||
f"{service}: «{SERVICE_STATUS_LABELS[mark.status]}» без комментария",
|
||||
fact="причина отказа не указана",
|
||||
norm="комментарий к отказу обязателен",
|
||||
|
|
@ -209,7 +211,7 @@ def evaluate_dispatcher(
|
|||
if latest is ServiceStatus.DECLINED and expected_decision == "accept":
|
||||
findings.append(
|
||||
_finding(
|
||||
ErrorCode.D3,
|
||||
service, ErrorCode.D3,
|
||||
f"{service}: отказ от происшествия, которое в её компетенции",
|
||||
fact="служба есть в списке оповещения по ЕКП",
|
||||
norm="принять согласно эталону сценария",
|
||||
|
|
@ -218,7 +220,7 @@ def evaluate_dispatcher(
|
|||
elif latest is ServiceStatus.ACCEPTED and expected_decision == "decline":
|
||||
findings.append(
|
||||
_finding(
|
||||
ErrorCode.D2,
|
||||
service, ErrorCode.D2,
|
||||
f"{service}: принято вопреки эталону сценария",
|
||||
fact="карточка принята службой",
|
||||
norm=expected_decision_reason or "отказать с указанной причиной",
|
||||
|
|
@ -232,7 +234,7 @@ def evaluate_dispatcher(
|
|||
if service not in crew_assignments:
|
||||
findings.append(
|
||||
_finding(
|
||||
ErrorCode.D2,
|
||||
service, ErrorCode.D2,
|
||||
f"{service}: «Принята» без назначения бригады и хода реагирования",
|
||||
fact="бригада не выбрана, после приёма статусов не было",
|
||||
norm="необходимую бригаду выбирает ДДС; ход отмечается по факту",
|
||||
|
|
@ -241,7 +243,7 @@ def evaluate_dispatcher(
|
|||
else:
|
||||
findings.append(
|
||||
_finding(
|
||||
ErrorCode.D2,
|
||||
service, ErrorCode.D2,
|
||||
f"{service}: «Принята», но о реагировании ничего не отмечено",
|
||||
fact="после приёма статусов не было",
|
||||
norm="статус должен соответствовать фактическому состоянию заявки",
|
||||
|
|
@ -252,7 +254,7 @@ def evaluate_dispatcher(
|
|||
) and service not in crew_assignments:
|
||||
findings.append(
|
||||
_finding(
|
||||
ErrorCode.D2,
|
||||
service, ErrorCode.D2,
|
||||
f"{service}: ход реагирования без назначения бригады",
|
||||
fact="статусы хода работ проставлены, бригада не выбрана",
|
||||
norm="необходимую бригаду выбирает ДДС; ход отмечается по факту",
|
||||
|
|
@ -268,7 +270,7 @@ def evaluate_dispatcher(
|
|||
missing = ", ".join(SERVICE_STATUS_LABELS[status] for status in missing_progress)
|
||||
findings.append(
|
||||
_finding(
|
||||
ErrorCode.D6,
|
||||
service, ErrorCode.D6,
|
||||
f"{service}: ход реагирования не доведён до конца",
|
||||
fact=(f"не отмечены: {missing}" if missing else "карточка не закрыта"),
|
||||
norm=(
|
||||
|
|
@ -301,7 +303,7 @@ def dispatcher_metrics(
|
|||
|
||||
def add(key: str, title: str, passed: bool, fact: str, norm: str, weight: float = 1.0):
|
||||
metrics.append(Metric(
|
||||
key=key, title=f"{service}: {title}", fact=fact, norm=norm,
|
||||
key=key, title=f"{service}: {title}", fact=fact, norm=norm, service=service,
|
||||
ref=GOST_REF if key == "dds_ack" else "памятка «Работа на АРМ-112», статусы реагирования",
|
||||
passed=passed, weight=weight,
|
||||
))
|
||||
|
|
|
|||
|
|
@ -11,6 +11,7 @@ from html import escape
|
|||
from pathlib import Path
|
||||
|
||||
from app.domain.events import SessionReport
|
||||
from app.domain.taxonomy import Finding, FindingDecision, FindingSource
|
||||
|
||||
|
||||
def _cell(value: object) -> str:
|
||||
|
|
@ -18,12 +19,27 @@ def _cell(value: object) -> str:
|
|||
if value is None:
|
||||
return ""
|
||||
result = str(value)
|
||||
probe = result.lstrip(" \t\r\n\ufeff\u200b")
|
||||
probe = result.lstrip(" \t\r\n\N{ZERO WIDTH NO-BREAK SPACE}\N{ZERO WIDTH SPACE}")
|
||||
if probe.startswith(("=", "+", "-", "@")) or result.startswith(("\t", "\r", "\n")):
|
||||
return "'" + result
|
||||
return result
|
||||
|
||||
|
||||
def _finding_origin(item: Finding) -> str:
|
||||
if item.source is FindingSource.INSTRUCTOR:
|
||||
return f"; добавлена преподавателем {item.author or ''}".rstrip()
|
||||
return ""
|
||||
|
||||
|
||||
def _finding_decision(item: Finding) -> str:
|
||||
"""Решения по отметке рядом с ней, все по порядку: действует последнее."""
|
||||
return "".join(
|
||||
f"; {'снята' if review.decision is FindingDecision.DISMISSED else 'подтверждена'} "
|
||||
f"преподавателем {review.author}: {review.reason}"
|
||||
for review in item.reviews
|
||||
)
|
||||
|
||||
|
||||
def to_csv(report: SessionReport) -> bytes:
|
||||
"""UTF-8 с BOM: кириллица открывается в Excel без выбора кодировки."""
|
||||
output = io.StringIO(newline="")
|
||||
|
|
@ -44,6 +60,7 @@ def to_csv(report: SessionReport) -> bytes:
|
|||
row("Критерии", "", "Нарушенных метрик", report.failed_metrics)
|
||||
row("Критерии", "", "Зачёт", "да" if report.passed else "нет")
|
||||
row("Оценка", "", "Автоматическая", report.score_auto)
|
||||
row("Оценка", "", "После разбора отметок", report.score_reviewed)
|
||||
row("Оценка", "", "Итоговая", report.score_final)
|
||||
row("Оценка", "", "Изменена преподавателем", report.overridden_by)
|
||||
row("Оценка", "", "Причина изменения", report.override_comment)
|
||||
|
|
@ -54,7 +71,9 @@ def to_csv(report: SessionReport) -> bytes:
|
|||
f"Норматив: {item.norm}; результат: {'да' if item.passed else 'нет'}; "
|
||||
f"вес: {item.weight:g}{credit}; источник: {item.ref or ''}")
|
||||
for number, item in enumerate(report.findings, 1):
|
||||
row("Ошибки", number, item.code.value, item.summary, f"Факт: {item.fact}; норматив: {item.norm or ''}; источник: {item.ref or ''}")
|
||||
row("Ошибки", number, item.code.value, item.summary,
|
||||
f"Факт: {item.fact}; норматив: {item.norm or ''}; источник: {item.ref or ''}"
|
||||
f"{_finding_origin(item)}{_finding_decision(item)}")
|
||||
for number, item in enumerate(report.competencies, 1):
|
||||
row("Компетенции", number, item.competency, item.value)
|
||||
for number, item in enumerate(report.transcript, 1):
|
||||
|
|
@ -77,7 +96,7 @@ def to_csv(report: SessionReport) -> bytes:
|
|||
row("Сверка самооценки", "", label, ", ".join(values))
|
||||
for number, item in enumerate(report.notes, 1):
|
||||
row("Пометки преподавателя", number, item.transcript_ref, item.text, item.author)
|
||||
return ("\ufeff" + output.getvalue()).encode("utf-8")
|
||||
return ("\N{ZERO WIDTH NO-BREAK SPACE}" + output.getvalue()).encode("utf-8")
|
||||
|
||||
|
||||
def _font_paths() -> tuple[Path, Path | None]:
|
||||
|
|
@ -160,6 +179,9 @@ def to_pdf(report: SessionReport) -> bytes:
|
|||
("Итоговая оценка", report.score_final),
|
||||
):
|
||||
story.append(Paragraph(f"<b>{escape(label)}:</b> {escape(str(value))}", base))
|
||||
# Когда итог правили вручную, без этой строки не понять, какой балл дал разбор.
|
||||
if report.score_reviewed is not None:
|
||||
story.append(Paragraph(f"<b>После разбора отметок:</b> {report.score_reviewed}", base))
|
||||
if report.overridden_by:
|
||||
story.append(Paragraph(f"<b>Оценка изменена:</b> {escape(report.overridden_by)}", base))
|
||||
if report.override_comment:
|
||||
|
|
@ -183,7 +205,9 @@ def to_pdf(report: SessionReport) -> bytes:
|
|||
story.append(p("Ошибок не выявлено", muted))
|
||||
for item in report.findings:
|
||||
story.append(p(f"{item.code.value} - {item.summary}"))
|
||||
story.append(p(f"Факт: {item.fact}. Норматив: {item.norm or 'не указан'}. Источник: {item.ref or 'не указан'}", muted))
|
||||
story.append(p(f"Факт: {item.fact}. Норматив: {item.norm or 'не указан'}. "
|
||||
f"Источник: {item.ref or 'не указан'}"
|
||||
f"{_finding_origin(item)}{_finding_decision(item)}", muted))
|
||||
|
||||
section("Компетенции")
|
||||
for item in report.competencies:
|
||||
|
|
|
|||
|
|
@ -73,6 +73,7 @@ class _Builder:
|
|||
norm=norm,
|
||||
ref=ref,
|
||||
competency=competency,
|
||||
metric_key=key,
|
||||
)
|
||||
)
|
||||
|
||||
|
|
@ -174,6 +175,7 @@ def evaluate(
|
|||
norm=f"эталонный вопрос: «{question}»" if question else "обязательный факт сценария",
|
||||
ref="чек-лист сценария",
|
||||
competency=Competency.INTERVIEW,
|
||||
metric_key="checklist_completeness",
|
||||
)
|
||||
)
|
||||
|
||||
|
|
|
|||
|
|
@ -106,6 +106,7 @@ def build(session_id: UUID, state, scenario: Scenario) -> SessionReport:
|
|||
self_assessment_diff=difference,
|
||||
notes=[InstructorNoteShown.model_validate(note) for note in state.notes],
|
||||
score_auto=score.get("score_auto", 0.0),
|
||||
score_reviewed=score.get("score_reviewed"),
|
||||
score_final=score.get("score_final", score.get("score_auto", 0.0)),
|
||||
overridden_by=score.get("overridden_by"),
|
||||
override_comment=score.get("override_comment"),
|
||||
|
|
|
|||
193
backend/app/scoring/review.py
Normal file
193
backend/app/scoring/review.py
Normal file
|
|
@ -0,0 +1,193 @@
|
|||
"""Разбор по отметкам: преподаватель подтверждает, снимает и добавляет отметку.
|
||||
|
||||
Баллы по-прежнему считает код. Преподаватель меняет входы — какие отметки
|
||||
действуют, — а не формулу: балл пересчитывается теми же метриками и весами.
|
||||
Связь «отметка → метрика» — методика `METRIC_MAP` в пределах карточки и службы;
|
||||
если генератор знает метрику точно, она записана в `Finding.metric_key`.
|
||||
|
||||
Функции чистые и работают со словарём сохранённой оценки: живое занятие,
|
||||
строка `Score` и архивный разбор меняются одним и тем же путём, как правка
|
||||
итога в `apply_score_override`.
|
||||
"""
|
||||
|
||||
from app.domain.events import Metric
|
||||
from app.domain.taxonomy import Finding, FindingDecision, FindingReview, FindingSource
|
||||
from app.scoring.competency import radar
|
||||
from app.scoring.gost import GostResult
|
||||
from app.scoring.taxonomy import INSTRUCTOR_METRIC, METRIC_MAP
|
||||
|
||||
__all__ = ["INSTRUCTOR_METRIC", "add_finding", "has_finding", "linked", "review_finding",
|
||||
"reviewed_metrics"]
|
||||
|
||||
|
||||
def _in_scope(finding: Finding, metric: Metric) -> bool:
|
||||
if finding.card != metric.card:
|
||||
return False
|
||||
return finding.service is None or metric.service is None or finding.service == metric.service
|
||||
|
||||
|
||||
def linked(finding: Finding, metric: Metric) -> bool:
|
||||
"""Отметка объясняет провал этой метрики."""
|
||||
if not _in_scope(finding, metric):
|
||||
return False
|
||||
if finding.metric_key is not None:
|
||||
return finding.metric_key == metric.key
|
||||
mapping = METRIC_MAP.get(metric.key)
|
||||
return mapping is not None and mapping[0] is finding.code
|
||||
|
||||
|
||||
def _dismissed(finding: Finding) -> bool:
|
||||
return finding.review is not None and finding.review.decision is FindingDecision.DISMISSED
|
||||
|
||||
|
||||
def _credit(metric: Metric) -> float:
|
||||
return metric.credit if metric.credit is not None else float(metric.passed)
|
||||
|
||||
|
||||
def reviewed_metrics(metrics: list[Metric], findings: list[Finding],
|
||||
instructor_weight: float = 1.0) -> list[Metric]:
|
||||
"""Метрики с учётом решений преподавателя.
|
||||
|
||||
Проваленная метрика засчитывается, только если все её автоматические
|
||||
отметки сняты. Ручная отметка проваливает связанные метрики; если их нет,
|
||||
появляется отдельная метрика преподавателя. Исходный вердикт остаётся в
|
||||
`passed_auto`/`credit_auto`, повторный пересчёт начинается с него.
|
||||
"""
|
||||
base = [
|
||||
metric.model_copy(update={
|
||||
"passed": metric.passed_auto if metric.passed_auto is not None else metric.passed,
|
||||
"credit": metric.credit_auto if metric.passed_auto is not None else metric.credit,
|
||||
"passed_auto": None,
|
||||
"credit_auto": None,
|
||||
})
|
||||
for metric in metrics
|
||||
if metric.key != INSTRUCTOR_METRIC
|
||||
]
|
||||
result: list[Metric] = []
|
||||
for metric in base:
|
||||
links = [finding for finding in findings if linked(finding, metric)]
|
||||
manual = [finding for finding in links
|
||||
if finding.source is FindingSource.INSTRUCTOR and not _dismissed(finding)]
|
||||
automatic = [finding for finding in links if finding.source is not FindingSource.INSTRUCTOR]
|
||||
if manual and _credit(metric) > 0:
|
||||
metric = metric.model_copy(update={
|
||||
"passed": False, "credit": 0.0,
|
||||
"passed_auto": metric.passed, "credit_auto": metric.credit,
|
||||
})
|
||||
elif (not manual and _credit(metric) < 1 and automatic
|
||||
and all(_dismissed(finding) for finding in automatic)):
|
||||
metric = metric.model_copy(update={
|
||||
"passed": True, "credit": 1.0,
|
||||
"passed_auto": metric.passed, "credit_auto": metric.credit,
|
||||
})
|
||||
result.append(metric)
|
||||
|
||||
for finding in findings:
|
||||
if (finding.source is FindingSource.INSTRUCTOR and not _dismissed(finding)
|
||||
and not any(linked(finding, metric) for metric in base)):
|
||||
result.append(Metric(
|
||||
key=INSTRUCTOR_METRIC,
|
||||
title=f"Отметка преподавателя: {finding.summary}",
|
||||
fact=finding.fact,
|
||||
norm=finding.norm or "по решению преподавателя",
|
||||
ref=finding.ref,
|
||||
passed=False,
|
||||
weight=instructor_weight,
|
||||
card=finding.card,
|
||||
service=finding.service,
|
||||
))
|
||||
return result
|
||||
|
||||
|
||||
def _instructor_weight(report: dict) -> float:
|
||||
"""Вес метрики преподавателя из весов занятия: веса настраивает преподаватель."""
|
||||
criteria = (report.get("full_report") or {}).get("criteria") or {}
|
||||
return float((criteria.get("score_weights") or {}).get(INSTRUCTOR_METRIC, 1.0))
|
||||
|
||||
|
||||
def _codes(findings: list[Finding]) -> dict[str, int]:
|
||||
"""Коды действующих отметок: по ним строятся частые ошибки группы и профиль."""
|
||||
codes: dict[str, int] = {}
|
||||
for finding in findings:
|
||||
if not _dismissed(finding):
|
||||
codes[finding.code.value] = codes.get(finding.code.value, 0) + 1
|
||||
return codes
|
||||
|
||||
|
||||
def _cards(cards: list[dict], metrics: list[Metric], findings: list[Finding]) -> list[dict]:
|
||||
"""Карточки очереди ДДС с тем же разбором: их метрики — часть метрик занятия."""
|
||||
updated = []
|
||||
for number, card in enumerate(cards, 1):
|
||||
own = [metric for metric in metrics if metric.card == number]
|
||||
updated.append({
|
||||
**card,
|
||||
"metrics": [metric.model_dump(mode="json") for metric in own],
|
||||
"findings": [finding.model_dump(mode="json")
|
||||
for finding in findings if finding.card == number],
|
||||
"score_reviewed": GostResult(metrics=own).score,
|
||||
})
|
||||
return updated
|
||||
|
||||
|
||||
def _rescore(report: dict, findings: list[Finding]) -> dict:
|
||||
metrics = reviewed_metrics(
|
||||
[Metric.model_validate(item) for item in report.get("metrics", [])], findings,
|
||||
_instructor_weight(report),
|
||||
)
|
||||
score = GostResult(metrics=metrics).score
|
||||
fields = {
|
||||
"findings": [finding.model_dump(mode="json") for finding in findings],
|
||||
"metrics": [metric.model_dump(mode="json") for metric in metrics],
|
||||
"competencies": [item.model_dump() for item in radar(metrics)],
|
||||
"score_reviewed": score,
|
||||
}
|
||||
# Правка итога — последнее слово преподавателя; решение по отметке её не отменяет.
|
||||
if not report.get("overridden_by"):
|
||||
fields["score_final"] = score
|
||||
updated = {**report, **fields}
|
||||
if "summary" in report:
|
||||
updated["summary"] = {**(report.get("summary") or {}), "codes": _codes(findings)}
|
||||
if report.get("card_results"):
|
||||
updated["card_results"] = _cards(report["card_results"], metrics, findings)
|
||||
archived = report.get("full_report")
|
||||
if isinstance(archived, dict):
|
||||
failed = sum(not metric.passed and metric.weight > 0 for metric in metrics)
|
||||
allowed = (archived.get("criteria") or {}).get("allowed_errors", 0)
|
||||
updated["full_report"] = {
|
||||
**archived, **fields,
|
||||
"card_results": _cards(archived.get("card_results") or [], metrics, findings),
|
||||
"failed_metrics": failed,
|
||||
"passed": failed <= allowed,
|
||||
"score_final": updated.get("score_final", archived.get("score_final")),
|
||||
}
|
||||
return updated
|
||||
|
||||
|
||||
def _findings(report: dict) -> list[Finding]:
|
||||
return [Finding.model_validate(item) for item in report.get("findings", [])]
|
||||
|
||||
|
||||
def review_finding(report: dict, index: int, review: FindingReview) -> dict:
|
||||
"""Подтвердить или снять отметку. Решение дописывается, действует последнее."""
|
||||
findings = _findings(report)
|
||||
if not 0 <= index < len(findings):
|
||||
raise LookupError(f"нет отметки {index}")
|
||||
findings[index] = findings[index].model_copy(
|
||||
update={"reviews": [*findings[index].reviews, review]})
|
||||
return _rescore(report, findings)
|
||||
|
||||
|
||||
def has_finding(report: dict, client_id) -> bool:
|
||||
"""Ручная отметка с этим ключом уже в разборе — повтор запроса."""
|
||||
return client_id is not None and any(
|
||||
finding.client_id == client_id for finding in _findings(report))
|
||||
|
||||
|
||||
def add_finding(report: dict, finding: Finding) -> dict:
|
||||
"""Добавить отметку преподавателя; она штрафует связанную метрику."""
|
||||
if finding.source is not FindingSource.INSTRUCTOR:
|
||||
raise ValueError("вручную добавляется только отметка преподавателя")
|
||||
# Повтор (ретрай сети, вторая вкладка) не штрафует второй раз.
|
||||
if has_finding(report, finding.client_id):
|
||||
return report
|
||||
return _rescore(report, [*_findings(report), finding])
|
||||
|
|
@ -35,6 +35,11 @@ METRIC_MAP: dict[str, tuple[ErrorCode, Competency]] = {
|
|||
"description_grammar": (ErrorCode.E4, Competency.COMMUNICATION),
|
||||
}
|
||||
|
||||
#: Метрика ручной отметки, которой нечего провалить (у кода нет метрики в
|
||||
#: METRIC_MAP или в карточке она не считалась). Кода у неё нет: код несёт сама
|
||||
#: отметка. Вес задаёт преподаватель в весах занятия, по умолчанию 1.
|
||||
INSTRUCTOR_METRIC = "instructor_finding"
|
||||
|
||||
#: Вес метрики в детерминированной оценке.
|
||||
#:
|
||||
#: **Предварительные значения, требуют утверждения методистом.** Без весов все
|
||||
|
|
|
|||
|
|
@ -95,4 +95,5 @@ def time_metric(
|
|||
norm=norm_text,
|
||||
ref=TIME_REF,
|
||||
competency=Competency.NORMS,
|
||||
metric_key=norm.key,
|
||||
)
|
||||
|
|
|
|||
|
|
@ -26,10 +26,13 @@ from app.session.hub import hub
|
|||
from app.session.score import ScoringSnapshot, score_session, scoring_scenario
|
||||
from app.session.state import DdsCardRecord, DdsLiveCard, now_utc
|
||||
from app.session.store import (
|
||||
FindingAdded,
|
||||
FindingReviewed,
|
||||
LessonEnded,
|
||||
ScoreArchived,
|
||||
ScoreCalculated,
|
||||
ScoreOverridden,
|
||||
apply_finding_change,
|
||||
apply_score_override,
|
||||
)
|
||||
|
||||
|
|
@ -100,9 +103,11 @@ def score_dds_card(state, card: DdsLiveCard) -> DdsCardRecord:
|
|||
card_id=card.card_id,
|
||||
scenario_id=card.scenario.id,
|
||||
reply_text=card.reply_text,
|
||||
metrics=[metric.model_copy(update={"title": f"Карточка {number}: {metric.title}"})
|
||||
metrics=[metric.model_copy(update={"title": f"Карточка {number}: {metric.title}",
|
||||
"card": number})
|
||||
for metric in weighted.metrics],
|
||||
findings=[finding.model_copy(update={"summary": f"Карточка {number}: {finding.summary}"})
|
||||
findings=[finding.model_copy(update={"summary": f"Карточка {number}: {finding.summary}",
|
||||
"card": number})
|
||||
for finding in weighted.findings],
|
||||
actions=actions,
|
||||
duration_ms=max(0, int((now_utc() - card.dispatched_at).total_seconds() * 1000)),
|
||||
|
|
@ -234,3 +239,14 @@ def override_score(state, override: ScoreOverridden) -> None:
|
|||
hub.record(state.session_id, override)
|
||||
state.score = apply_score_override(state.score, override)
|
||||
hub.to_observers(state.session_id, ScoreReady(session_id=state.session_id))
|
||||
|
||||
|
||||
def change_findings(state, change: FindingReviewed | FindingAdded) -> None:
|
||||
"""Решение преподавателя по отметке — тем же путём, что правка итога.
|
||||
|
||||
Вызывается внутри `hub.operation`: отметки, пересчитанный балл, архивный
|
||||
разбор и строка аудита уходят одним commit.
|
||||
"""
|
||||
state.score = apply_finding_change(state.score, change)
|
||||
hub.record(state.session_id, change)
|
||||
hub.to_observers(state.session_id, ScoreReady(session_id=state.session_id))
|
||||
|
|
|
|||
|
|
@ -29,6 +29,8 @@ from app.domain.events import Mood, Speaker, TranscriptEntry
|
|||
from app.session.checkpoint import dump_state, load_state
|
||||
from app.session.state import SessionState, now_utc
|
||||
from app.session.store import (
|
||||
FindingAdded,
|
||||
FindingReviewed,
|
||||
HintRecorded,
|
||||
LessonEnded,
|
||||
LessonIdentity,
|
||||
|
|
@ -42,8 +44,10 @@ from app.session.store import (
|
|||
SelfAssessed,
|
||||
SessionLeaseLost,
|
||||
UtteranceAppended,
|
||||
apply_finding_change,
|
||||
apply_score_override,
|
||||
)
|
||||
from app.scoring.review import has_finding
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
LEASE_SECONDS = 15
|
||||
|
|
@ -239,6 +243,40 @@ class PostgresSessionStore:
|
|||
detail=(f"{score.score_auto} → {record.score_final}; "
|
||||
f"comment_chars={len(record.comment)}"),
|
||||
))
|
||||
case FindingReviewed() | FindingAdded():
|
||||
await db.flush()
|
||||
score = await db.scalar(
|
||||
select(Score).where(Score.session_id == session_id).with_for_update()
|
||||
)
|
||||
if score is None:
|
||||
raise LookupError(f"нет оценки занятия {session_id}")
|
||||
# Повтор ручной отметки под блокировкой: ни изменения, ни второй строки аудита.
|
||||
if (isinstance(record, FindingAdded)
|
||||
and has_finding(score.report or {}, record.finding.client_id)):
|
||||
return
|
||||
before = score.score_final
|
||||
findings = (score.report or {}).get("findings", [])
|
||||
score.report = apply_finding_change(dict(score.report or {}), record)
|
||||
score.score_final = score.report.get("score_final", score.score_final)
|
||||
if isinstance(record, FindingReviewed):
|
||||
code = (findings[record.index].get("code", "?")
|
||||
if 0 <= record.index < len(findings) else "?")
|
||||
actor, action = record.review.author, "finding.review"
|
||||
what = (f"#{record.index} {code} {record.review.decision.value}; "
|
||||
f"причина: {record.review.reason}")
|
||||
else:
|
||||
finding = record.finding
|
||||
actor, action = finding.author or "instructor", "finding.add"
|
||||
where = f", карточка {finding.card}" if finding.card is not None else ""
|
||||
what = (f"{finding.code.value}{where}; факт: {finding.fact}; "
|
||||
f"норма: {finding.norm or ''}")
|
||||
# Решение по отметке меняет чужой балл: аудит сам по себе должен
|
||||
# ответить «кто, когда, что и почему», даже если разбор потом правили.
|
||||
db.add(AuditLog(
|
||||
actor=actor, role=record.role, action=action,
|
||||
object_id=str(session_id),
|
||||
detail=f"{what}; {before} → {score.score_final}",
|
||||
))
|
||||
await db.flush()
|
||||
|
||||
@staticmethod
|
||||
|
|
|
|||
|
|
@ -210,6 +210,7 @@ async def score_session(
|
|||
norm="грамматически корректное описание",
|
||||
ref="критерий занятия; правила русского языка",
|
||||
competency=Competency.COMMUNICATION,
|
||||
metric_key="description_grammar",
|
||||
))
|
||||
# Работа диспетчера — вторая роль и вторая таксономия. Отметки D1–D6 идут
|
||||
# рядом с E1–E6, а не вместо: в живой цепочке 112 → ДДС в одном занятии
|
||||
|
|
|
|||
|
|
@ -16,6 +16,8 @@ from typing import Protocol
|
|||
from uuid import UUID
|
||||
|
||||
from app.domain.events import TranscriptEntry
|
||||
from app.domain.taxonomy import Finding, FindingReview
|
||||
from app.scoring.review import add_finding, review_finding
|
||||
from app.session.checkpoint import dump_state
|
||||
from app.session.state import SessionState
|
||||
|
||||
|
|
@ -83,8 +85,31 @@ class ScoreOverridden:
|
|||
comment: str
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class FindingReviewed:
|
||||
"""Преподаватель подтвердил или снял отметку разбора."""
|
||||
index: int
|
||||
review: FindingReview
|
||||
role: str
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class FindingAdded:
|
||||
"""Преподаватель добавил свою отметку (`source=instructor`)."""
|
||||
finding: Finding
|
||||
role: str
|
||||
|
||||
|
||||
Record = (UtteranceAppended | HintRecorded | NoteAdded | SelfAssessed | LessonStarted
|
||||
| LessonEnded | ScoreCalculated | ScoreArchived | ScoreOverridden)
|
||||
| LessonEnded | ScoreCalculated | ScoreArchived | ScoreOverridden
|
||||
| FindingReviewed | FindingAdded)
|
||||
|
||||
|
||||
def apply_finding_change(report: dict, change: "FindingReviewed | FindingAdded") -> dict:
|
||||
"""Решение по отметке одинаково для живой сессии, строки `Score` и архива."""
|
||||
if isinstance(change, FindingReviewed):
|
||||
return review_finding(report, change.index, change.review)
|
||||
return add_finding(report, change.finding)
|
||||
|
||||
|
||||
def apply_score_override(report: dict, override: ScoreOverridden) -> dict:
|
||||
|
|
@ -200,6 +225,10 @@ class MemorySessionStore:
|
|||
if session_id not in self.scores:
|
||||
raise LookupError(f"нет оценки занятия {session_id}")
|
||||
self.scores[session_id] = apply_score_override(self.scores[session_id], record)
|
||||
elif isinstance(record, FindingReviewed | FindingAdded):
|
||||
if session_id not in self.scores:
|
||||
raise LookupError(f"нет оценки занятия {session_id}")
|
||||
self.scores[session_id] = apply_finding_change(self.scores[session_id], record)
|
||||
self.records.setdefault(session_id, []).extend(records)
|
||||
|
||||
def snapshot(self, session_id: UUID) -> dict | None:
|
||||
|
|
|
|||
644
backend/tests/test_finding_review.py
Normal file
644
backend/tests/test_finding_review.py
Normal file
|
|
@ -0,0 +1,644 @@
|
|||
"""Разбор по отметкам (lct-35): преподаватель подтверждает, снимает и добавляет отметку.
|
||||
|
||||
Балл пересчитывается теми же метриками и весами: снятая отметка не штрафует
|
||||
свою метрику, ручная — штрафует. Автоматическая оценка остаётся рядом.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
from datetime import UTC, datetime
|
||||
from uuid import uuid4
|
||||
|
||||
import pytest
|
||||
from fastapi import HTTPException
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from app.api.auth import Principal
|
||||
from app.api.http import sessions
|
||||
from app.domain.events import Metric
|
||||
from app.domain.roles import Role
|
||||
from app.domain.taxonomy import (
|
||||
ErrorCode,
|
||||
Finding,
|
||||
FindingDecision,
|
||||
FindingReview,
|
||||
FindingSource,
|
||||
)
|
||||
from app.main import app
|
||||
from app.scoring.export import to_csv
|
||||
from app.scoring.review import INSTRUCTOR_METRIC, add_finding, review_finding
|
||||
from app.session import finish as finish_module
|
||||
from app.session.hub import hub
|
||||
from app.session.store import FindingAdded, FindingReviewed, MemorySessionStore
|
||||
|
||||
from tests.test_dds_desk_scores import dds_exercise_early_finish
|
||||
|
||||
AT = datetime(2026, 9, 27, 12, 0, tzinfo=UTC)
|
||||
|
||||
|
||||
def review(decision: FindingDecision) -> FindingReview:
|
||||
return FindingReview(decision=decision, reason="доклад пришёл по рации", author="teacher", at=AT)
|
||||
|
||||
|
||||
def report_with(metrics: list[Metric], findings: list[Finding]) -> dict:
|
||||
return {
|
||||
"score_auto": 50.0,
|
||||
"metrics": [metric.model_dump(mode="json") for metric in metrics],
|
||||
"findings": [finding.model_dump(mode="json") for finding in findings],
|
||||
"full_report": {"criteria": {"allowed_errors": 0}, "score_auto": 50.0,
|
||||
"score_final": 50.0, "failed_metrics": 1, "passed": False},
|
||||
}
|
||||
|
||||
|
||||
def dds_metric(key: str, passed: bool, card: int = 1) -> Metric:
|
||||
return Metric(key=key, title=key, fact="факт", norm="норма", passed=passed,
|
||||
weight=1.0, card=card, service="01")
|
||||
|
||||
|
||||
def dds_finding(code: ErrorCode, card: int = 1) -> Finding:
|
||||
return Finding(code=code, source=FindingSource.DISPATCHER, summary=code.value,
|
||||
fact="факт", norm="норма", card=card, service="01")
|
||||
|
||||
|
||||
def test_dismissed_finding_stops_penalizing_its_metric_but_stays_in_report():
|
||||
report = report_with(
|
||||
[dds_metric("dds_primary", True), dds_metric("dds_progress", False)],
|
||||
[dds_finding(ErrorCode.D6)],
|
||||
)
|
||||
|
||||
updated = review_finding(report, 0, review(FindingDecision.DISMISSED))
|
||||
|
||||
assert updated["score_reviewed"] == 100.0
|
||||
assert updated["score_final"] == 100.0
|
||||
assert updated["score_auto"] == 50.0, "автооценка остаётся рядом"
|
||||
progress = updated["metrics"][1]
|
||||
assert (progress["passed"], progress["passed_auto"]) == (True, False)
|
||||
finding = updated["findings"][0]
|
||||
assert finding["reviews"][-1]["decision"] == "dismissed"
|
||||
assert finding["reviews"][-1]["reason"] == "доклад пришёл по рации"
|
||||
archived = updated["full_report"]
|
||||
assert (archived["score_final"], archived["failed_metrics"], archived["passed"]) == (100.0, 0, True)
|
||||
|
||||
|
||||
def test_confirmed_finding_and_other_card_keep_the_metric_failed():
|
||||
report = report_with(
|
||||
[dds_metric("dds_progress", False, card=1), dds_metric("dds_progress", False, card=2)],
|
||||
[dds_finding(ErrorCode.D6, card=1), dds_finding(ErrorCode.D6, card=2)],
|
||||
)
|
||||
|
||||
confirmed = review_finding(report, 0, review(FindingDecision.CONFIRMED))
|
||||
assert confirmed["score_reviewed"] == 0.0
|
||||
|
||||
dismissed = review_finding(report, 0, review(FindingDecision.DISMISSED))
|
||||
assert [metric["passed"] for metric in dismissed["metrics"]] == [True, False], (
|
||||
"снятие отметки первой карточки не трогает вторую"
|
||||
)
|
||||
|
||||
|
||||
def test_metric_stays_failed_while_one_of_its_findings_is_active():
|
||||
report = report_with(
|
||||
[dds_metric("dds_reply", False)],
|
||||
[dds_finding(ErrorCode.D5), dds_finding(ErrorCode.D5)],
|
||||
)
|
||||
|
||||
updated = review_finding(report, 0, review(FindingDecision.DISMISSED))
|
||||
|
||||
assert updated["metrics"][0]["passed"] is False
|
||||
again = review_finding(updated, 1, review(FindingDecision.DISMISSED))
|
||||
assert again["metrics"][0]["passed"] is True
|
||||
|
||||
|
||||
def test_instructor_finding_penalizes_linked_metric_and_unlinked_code_adds_one():
|
||||
report = report_with([dds_metric("dds_progress", True), dds_metric("dds_primary", True)], [])
|
||||
manual = Finding(code=ErrorCode.D6, source=FindingSource.INSTRUCTOR, summary="Карточка 1: D6",
|
||||
fact="«Прибыла» отмечено до доклада", norm="по факту доклада",
|
||||
card=1, service="01", author="teacher", at=AT)
|
||||
|
||||
updated = add_finding(report, manual)
|
||||
|
||||
assert updated["score_reviewed"] == 50.0
|
||||
assert updated["metrics"][0]["passed"] is False
|
||||
assert updated["metrics"][0]["passed_auto"] is True
|
||||
assert updated["findings"][0]["source"] == "instructor"
|
||||
|
||||
# У D4 в методике нет метрики — ручная отметка всё равно должна штрафовать.
|
||||
no_metric = manual.model_copy(update={"code": ErrorCode.D4})
|
||||
extra = add_finding(report, no_metric)
|
||||
assert [metric["key"] for metric in extra["metrics"]][-1] == INSTRUCTOR_METRIC
|
||||
assert extra["score_reviewed"] == pytest.approx(66.7)
|
||||
|
||||
# Снятая ручная отметка не штрафует, и её метрика исчезает при пересчёте.
|
||||
lifted = review_finding(extra, 0, review(FindingDecision.DISMISSED))
|
||||
assert lifted["score_reviewed"] == 100.0
|
||||
assert INSTRUCTOR_METRIC not in {metric["key"] for metric in lifted["metrics"]}
|
||||
|
||||
|
||||
def test_score_override_stays_final_after_finding_review():
|
||||
report = {**report_with([dds_metric("dds_progress", False)], [dds_finding(ErrorCode.D6)]),
|
||||
"score_final": 70.0, "overridden_by": "teacher"}
|
||||
|
||||
updated = review_finding(report, 0, review(FindingDecision.DISMISSED))
|
||||
|
||||
assert updated["score_reviewed"] == 100.0
|
||||
assert updated["score_final"] == 70.0
|
||||
|
||||
|
||||
def test_unknown_finding_index_is_refused():
|
||||
with pytest.raises(LookupError):
|
||||
review_finding(report_with([], []), 0, review(FindingDecision.DISMISSED))
|
||||
|
||||
|
||||
# ── HTTP: живое занятие ДДС ──
|
||||
|
||||
@pytest.fixture
|
||||
def lesson(monkeypatch):
|
||||
"""Завершённое занятие ДДС преподавателя `dev` в памяти узла."""
|
||||
|
||||
class NoCoaching:
|
||||
def model_dump(self, **_kwargs):
|
||||
return {}
|
||||
|
||||
async def no_coach(_metrics):
|
||||
return NoCoaching()
|
||||
|
||||
async def audit_in_memory(*_args, **_kwargs):
|
||||
return None
|
||||
|
||||
async def no_database():
|
||||
yield None
|
||||
|
||||
# Живое занятие в памяти: чтение отчёта не должно ходить в PostgreSQL.
|
||||
monkeypatch.setattr(finish_module, "coach", no_coach)
|
||||
monkeypatch.setattr(sessions, "audit_required", audit_in_memory)
|
||||
monkeypatch.setitem(app.dependency_overrides, sessions.optional_session, no_database)
|
||||
store = MemorySessionStore()
|
||||
monkeypatch.setattr(hub, "store", store)
|
||||
state = dds_exercise_early_finish()
|
||||
state.owner_login = "dev"
|
||||
with TestClient(app) as browser:
|
||||
browser.post("/api/auth/dev-token")
|
||||
hub.store = store
|
||||
hub.register(state)
|
||||
yield browser, state, store
|
||||
|
||||
|
||||
def as_role(monkeypatch, role: Role, login: str = "dev") -> None:
|
||||
def require(_request, *roles):
|
||||
if roles and role not in roles:
|
||||
raise HTTPException(status_code=403, detail="forbidden")
|
||||
return Principal(login=login, full_name="Проверка", role=role,
|
||||
trainee_id=uuid4() if role is Role.TRAINEE else None)
|
||||
|
||||
monkeypatch.setattr(sessions, "require", require)
|
||||
|
||||
|
||||
def test_owner_dismisses_and_adds_finding_through_http(lesson):
|
||||
browser, state, store = lesson
|
||||
session_id = state.session_id
|
||||
before = browser.get(f"/api/sessions/{session_id}/report").json()
|
||||
target = next(index for index, finding in enumerate(before["findings"])
|
||||
if finding["code"] == "D1")
|
||||
|
||||
dismissed = browser.post(
|
||||
f"/api/sessions/{session_id}/findings/{target}/review",
|
||||
json={"decision": "dismissed", "reason": "карточку выдали с опозданием"},
|
||||
)
|
||||
assert dismissed.status_code == 200, dismissed.text
|
||||
body = dismissed.json()
|
||||
assert body["findings"][target]["reviews"][-1]["decision"] == "dismissed"
|
||||
assert body["findings"][target]["reviews"][-1]["author"] == "dev"
|
||||
assert body["score_auto"] == before["score_auto"]
|
||||
assert body["score_reviewed"] >= before["score_auto"]
|
||||
|
||||
added = browser.post(
|
||||
f"/api/sessions/{session_id}/findings",
|
||||
json={"code": "D5", "fact": "в комментарии нет адресата", "norm": "назвать адресата",
|
||||
"card": 1},
|
||||
)
|
||||
assert added.status_code == 200, added.text
|
||||
manual = added.json()["findings"][-1]
|
||||
assert (manual["source"], manual["card"], manual["author"]) == ("instructor", 1, "dev")
|
||||
assert manual["summary"].startswith("Карточка 1: ")
|
||||
|
||||
records = [record for _, batch in store.commits for record in batch]
|
||||
assert [type(record) for record in records[-2:]] == [FindingReviewed, FindingAdded]
|
||||
assert store.scores[session_id]["findings"][target]["reviews"][-1]["decision"] == "dismissed"
|
||||
|
||||
rows = to_csv(sessions.SessionReport.model_validate(added.json())).decode("utf-8-sig")
|
||||
assert "карточку выдали с опозданием" in rows
|
||||
assert "в комментарии нет адресата" in rows
|
||||
|
||||
|
||||
def test_review_requires_reason_and_existing_card(lesson):
|
||||
browser, state, _store = lesson
|
||||
session_id = state.session_id
|
||||
|
||||
blank = browser.post(f"/api/sessions/{session_id}/findings/0/review",
|
||||
json={"decision": "dismissed", "reason": " "})
|
||||
assert blank.status_code == 422
|
||||
missing = browser.post(f"/api/sessions/{session_id}/findings/999/review",
|
||||
json={"decision": "confirmed", "reason": "проверено"})
|
||||
assert missing.status_code == 404
|
||||
card = browser.post(f"/api/sessions/{session_id}/findings",
|
||||
json={"code": "D1", "fact": "факт", "norm": "норма", "card": 99})
|
||||
assert card.status_code == 422
|
||||
|
||||
|
||||
@pytest.mark.parametrize("role, login, status", [
|
||||
(Role.TRAINEE, "trainee", 403),
|
||||
(Role.INSTRUCTOR, "someone-else", 404),
|
||||
])
|
||||
def test_trainee_and_foreign_instructor_cannot_review(lesson, monkeypatch, role, login, status):
|
||||
browser, state, store = lesson
|
||||
commits = len(store.commits)
|
||||
as_role(monkeypatch, role, login)
|
||||
|
||||
reviewed = browser.post(f"/api/sessions/{state.session_id}/findings/0/review",
|
||||
json={"decision": "dismissed", "reason": "не согласен"})
|
||||
added = browser.post(f"/api/sessions/{state.session_id}/findings",
|
||||
json={"code": "D1", "fact": "факт", "norm": "норма"})
|
||||
|
||||
assert (reviewed.status_code, added.status_code) == (status, status)
|
||||
assert len(store.commits) == commits, "отказ ничего не пишет"
|
||||
|
||||
|
||||
def test_finding_review_is_audited_in_postgres(postgres_access):
|
||||
"""Решение и аудит — одна транзакция: строка Score и AuditLog вместе."""
|
||||
from sqlalchemy import select
|
||||
|
||||
from app.db.base import get_sessionmaker
|
||||
from app.db.models import AuditLog, Score
|
||||
from app.session.pg_store import PostgresSessionStore
|
||||
from app.session.store import LessonRequest
|
||||
|
||||
store = PostgresSessionStore(get_sessionmaker())
|
||||
session_id = uuid4()
|
||||
report = report_with([dds_metric("dds_progress", False)], [dds_finding(ErrorCode.D6)])
|
||||
|
||||
async def scenario():
|
||||
from app.session.state import SessionState
|
||||
from app.domain.events import Exercise, SessionMode
|
||||
|
||||
def build(_identity):
|
||||
return SessionState(session_id=session_id, scenario_id="fire-apartment-l2",
|
||||
scenario_title="Пожар", level="L2", mode=SessionMode.TRAINING,
|
||||
exercise=Exercise.DDS)
|
||||
|
||||
await store.open(LessonRequest(
|
||||
session_id=session_id, scenario_id="fire-apartment-l2", mode="training",
|
||||
trainee_name=None, trainee_id=None, owner_login="teacher", backend_node_id=None,
|
||||
), build)
|
||||
from app.session.store import ScoreCalculated
|
||||
await store.commit_archived(session_id, [ScoreCalculated(50.0, report)])
|
||||
await store.commit_archived(session_id, [FindingReviewed(
|
||||
index=0, role="instructor", review=review(FindingDecision.DISMISSED),
|
||||
)])
|
||||
async with get_sessionmaker()() as db:
|
||||
score = await db.scalar(select(Score).where(Score.session_id == session_id))
|
||||
audit = await db.scalar(select(AuditLog).where(
|
||||
AuditLog.object_id == str(session_id), AuditLog.action == "finding.review",
|
||||
))
|
||||
return score, audit
|
||||
|
||||
score, audit = asyncio.run(scenario())
|
||||
assert score.score_auto == 50.0
|
||||
assert score.score_final == 100.0
|
||||
assert score.report["findings"][0]["reviews"][-1]["decision"] == "dismissed"
|
||||
assert audit is not None and audit.actor == "teacher"
|
||||
assert "dismissed" in audit.detail and "50.0 → 100.0" in audit.detail
|
||||
|
||||
|
||||
# ── История решений, коды, карточки, веса ──
|
||||
|
||||
def test_repeated_decision_keeps_history_and_last_one_applies():
|
||||
report = report_with([dds_metric("dds_progress", False)], [dds_finding(ErrorCode.D6)])
|
||||
|
||||
dismissed = review_finding(report, 0, review(FindingDecision.DISMISSED))
|
||||
confirmed = review_finding(dismissed, 0, FindingReview(
|
||||
decision=FindingDecision.CONFIRMED, reason="перепроверил запись", author="head", at=AT,
|
||||
))
|
||||
|
||||
reviews = confirmed["findings"][0]["reviews"]
|
||||
assert [(item["decision"], item["author"], item["reason"]) for item in reviews] == [
|
||||
("dismissed", "teacher", "доклад пришёл по рации"),
|
||||
("confirmed", "head", "перепроверил запись"),
|
||||
]
|
||||
assert confirmed["score_reviewed"] == 0.0, "действует последнее решение"
|
||||
|
||||
|
||||
def test_report_saved_with_single_review_reads_as_history():
|
||||
legacy = dds_finding(ErrorCode.D6).model_dump(mode="json")
|
||||
legacy["review"] = review(FindingDecision.DISMISSED).model_dump(mode="json")
|
||||
|
||||
finding = Finding.model_validate(legacy)
|
||||
|
||||
assert [item.decision for item in finding.reviews] == [FindingDecision.DISMISSED]
|
||||
assert finding.review.decision is FindingDecision.DISMISSED
|
||||
|
||||
|
||||
def test_call_code_in_handoff_penalizes_call_metric_not_instructor_metric():
|
||||
"""Связка 112 → ДДС: E1 без карточки проваливает метрику 112, а не добавляет свою."""
|
||||
call = Metric(key="checklist_completeness", title="Полнота опроса", fact="все", norm="все",
|
||||
passed=True, weight=1.0)
|
||||
report = report_with([call, dds_metric("dds_progress", True)], [])
|
||||
manual = Finding(code=ErrorCode.E1, source=FindingSource.INSTRUCTOR, summary="E1",
|
||||
fact="не уточнён подъезд", norm="уточнить подъезд", author="teacher", at=AT)
|
||||
|
||||
updated = add_finding(report, manual)
|
||||
|
||||
assert [metric["passed"] for metric in updated["metrics"]] == [False, True]
|
||||
assert INSTRUCTOR_METRIC not in {metric["key"] for metric in updated["metrics"]}
|
||||
assert updated["score_reviewed"] == 50.0
|
||||
|
||||
|
||||
def test_codes_and_card_scores_follow_the_review():
|
||||
card = {"card_id": str(uuid4()), "scenario_id": "s", "score_auto": 50.0, "reply_text": "",
|
||||
"metrics": [dds_metric("dds_primary", True).model_dump(mode="json"),
|
||||
dds_metric("dds_progress", False).model_dump(mode="json")],
|
||||
"findings": [dds_finding(ErrorCode.D6).model_dump(mode="json")]}
|
||||
report = {**report_with([dds_metric("dds_primary", True), dds_metric("dds_progress", False)],
|
||||
[dds_finding(ErrorCode.D6)]),
|
||||
"summary": {"hints": 2, "codes": {"D6": 1}}, "card_results": [card]}
|
||||
report["full_report"]["card_results"] = [card]
|
||||
|
||||
dismissed = review_finding(report, 0, review(FindingDecision.DISMISSED))
|
||||
|
||||
assert dismissed["summary"] == {"hints": 2, "codes": {}}, "снятая отметка не ошибка группы"
|
||||
for cards in (dismissed["card_results"], dismissed["full_report"]["card_results"]):
|
||||
assert cards[0]["score_auto"] == 50.0
|
||||
assert cards[0]["score_reviewed"] == 100.0
|
||||
assert cards[0]["metrics"][1]["passed"] is True
|
||||
assert cards[0]["findings"][0]["reviews"][-1]["decision"] == "dismissed"
|
||||
|
||||
manual = Finding(code=ErrorCode.D4, source=FindingSource.INSTRUCTOR, summary="D4",
|
||||
fact="отказ без причины", norm="причина обязательна", card=1,
|
||||
author="teacher", at=AT)
|
||||
added = add_finding(dismissed, manual)
|
||||
assert added["summary"]["codes"] == {"D4": 1}
|
||||
assert added["card_results"][0]["score_reviewed"] == pytest.approx(66.7)
|
||||
|
||||
|
||||
def test_instructor_metric_weight_comes_from_lesson_weights():
|
||||
report = report_with([dds_metric("dds_primary", True)], [])
|
||||
report["full_report"]["criteria"]["score_weights"] = {INSTRUCTOR_METRIC: 3.0}
|
||||
manual = Finding(code=ErrorCode.D4, source=FindingSource.INSTRUCTOR, summary="D4",
|
||||
fact="отказ без причины", norm="причина обязательна", card=1,
|
||||
author="teacher", at=AT)
|
||||
|
||||
updated = add_finding(report, manual)
|
||||
|
||||
assert updated["metrics"][-1]["weight"] == 3.0
|
||||
assert updated["score_reviewed"] == 25.0
|
||||
|
||||
|
||||
def test_lesson_criteria_accept_instructor_metric_weight():
|
||||
from app.domain.events import LessonCriteria
|
||||
|
||||
assert LessonCriteria(score_weights={INSTRUCTOR_METRIC: 2.0}).score_weights == {
|
||||
INSTRUCTOR_METRIC: 2.0}
|
||||
|
||||
|
||||
def test_repeated_manual_finding_with_same_key_is_added_once():
|
||||
report = report_with([dds_metric("dds_primary", True)], [])
|
||||
manual = Finding(code=ErrorCode.D4, source=FindingSource.INSTRUCTOR, summary="D4",
|
||||
fact="отказ без причины", norm="причина обязательна", card=1,
|
||||
author="teacher", at=AT, client_id=uuid4())
|
||||
|
||||
once = add_finding(report, manual)
|
||||
twice = add_finding(once, manual)
|
||||
|
||||
assert len(twice["findings"]) == 1
|
||||
assert twice["score_reviewed"] == once["score_reviewed"] == 50.0
|
||||
|
||||
|
||||
def test_pdf_shows_score_after_review(monkeypatch):
|
||||
from reportlab import platypus
|
||||
|
||||
from app.scoring.export import to_pdf
|
||||
from tests.test_report_export import sample_report
|
||||
|
||||
texts: list[str] = []
|
||||
|
||||
class Recorded(platypus.Paragraph):
|
||||
def __init__(self, text, *args, **kwargs):
|
||||
texts.append(text)
|
||||
super().__init__(text, *args, **kwargs)
|
||||
|
||||
# Абзацы перехватываются до вёрстки: извлечь текст из PDF нечем без poppler.
|
||||
monkeypatch.setattr(platypus, "Paragraph", Recorded)
|
||||
assert to_pdf(sample_report().model_copy(update={"score_reviewed": 91.5})).startswith(b"%PDF-")
|
||||
|
||||
assert "<b>После разбора отметок:</b> 91.5" in texts
|
||||
|
||||
|
||||
# ── HTTP: связка 112 → ДДС, идемпотентность, занятие из истории ──
|
||||
|
||||
def test_call_code_with_queue_card_is_refused_in_handoff(lesson):
|
||||
browser, state, store = lesson
|
||||
commits = len(store.commits)
|
||||
state.score["full_report"]["exercise"] = "call"
|
||||
|
||||
refused = browser.post(f"/api/sessions/{state.session_id}/findings",
|
||||
json={"code": "E1", "fact": "факт", "norm": "норма", "card": 1})
|
||||
|
||||
assert refused.status_code == 422
|
||||
assert refused.json()["detail"] == "call_code_without_card"
|
||||
assert len(store.commits) == commits
|
||||
|
||||
|
||||
def test_repeated_add_request_does_not_add_second_finding(lesson):
|
||||
browser, state, store = lesson
|
||||
body = {"code": "D5", "fact": "нет адресата", "norm": "назвать адресата", "card": 1,
|
||||
"client_id": str(uuid4())}
|
||||
|
||||
first = browser.post(f"/api/sessions/{state.session_id}/findings", json=body)
|
||||
commits = len(store.commits)
|
||||
second = browser.post(f"/api/sessions/{state.session_id}/findings", json=body)
|
||||
|
||||
assert first.status_code == second.status_code == 200
|
||||
assert len(second.json()["findings"]) == len(first.json()["findings"])
|
||||
assert second.json()["score_reviewed"] == first.json()["score_reviewed"]
|
||||
assert not [record for _, batch in store.commits[commits:] for record in batch], (
|
||||
"повтор ничего не пишет")
|
||||
|
||||
|
||||
def test_archived_lesson_is_reviewed_through_http(monkeypatch):
|
||||
"""Занятия нет в памяти узла: решение идёт через commit_archived, ответ — по строке после записи."""
|
||||
from types import SimpleNamespace
|
||||
|
||||
from app.session.pg_store import PostgresSessionStore
|
||||
from tests.test_report_export import sample_report
|
||||
|
||||
archived = sample_report().model_dump(mode="json")
|
||||
archived["findings"] = [dds_finding(ErrorCode.D6).model_dump(mode="json")]
|
||||
archived["metrics"] = [dds_metric("dds_progress", False).model_dump(mode="json")]
|
||||
archived.update(score_final=0.0, overridden_by=None, override_comment=None, score_auto=0.0)
|
||||
session_id = archived["session_id"]
|
||||
session_row = SimpleNamespace(id=session_id, trainee_id=uuid4(), owner_login="dev")
|
||||
score_row = SimpleNamespace(
|
||||
session_id=session_id, score_auto=0.0, score_final=0.0,
|
||||
report={"score_auto": 0.0, "summary": {"codes": {"D6": 1}},
|
||||
"findings": archived["findings"], "metrics": archived["metrics"],
|
||||
"full_report": archived},
|
||||
)
|
||||
|
||||
class FakeDb:
|
||||
def __init__(self):
|
||||
self.added = []
|
||||
self.commits = 0
|
||||
|
||||
async def get(self, _model, _key):
|
||||
return session_row
|
||||
|
||||
async def scalar(self, _statement):
|
||||
return score_row
|
||||
|
||||
def add(self, row):
|
||||
self.added.append(row)
|
||||
|
||||
async def flush(self):
|
||||
pass
|
||||
|
||||
async def rollback(self):
|
||||
pass
|
||||
|
||||
async def commit(self):
|
||||
self.commits += 1
|
||||
|
||||
async def __aenter__(self):
|
||||
return self
|
||||
|
||||
async def __aexit__(self, *_args):
|
||||
return None
|
||||
|
||||
db = FakeDb()
|
||||
|
||||
async def fake_session():
|
||||
yield db
|
||||
|
||||
monkeypatch.setattr(hub, "store", PostgresSessionStore(lambda: db))
|
||||
monkeypatch.setattr(hub, "get", lambda _session_id: None)
|
||||
monkeypatch.setitem(app.dependency_overrides, sessions.optional_session, fake_session)
|
||||
with TestClient(app) as browser:
|
||||
browser.post("/api/auth/dev-token")
|
||||
hub.store = PostgresSessionStore(lambda: db)
|
||||
response = browser.post(f"/api/sessions/{session_id}/findings/0/review",
|
||||
json={"decision": "dismissed", "reason": "доклад по рации"})
|
||||
|
||||
assert response.status_code == 200, response.text
|
||||
body = response.json()
|
||||
assert body["score_reviewed"] == 100.0 and body["score_final"] == 100.0
|
||||
assert body["findings"][0]["reviews"][-1]["reason"] == "доклад по рации"
|
||||
assert db.commits == 1, "решение и аудит — один commit"
|
||||
assert score_row.score_final == 100.0
|
||||
assert score_row.report["summary"]["codes"] == {}
|
||||
audit = db.added[0]
|
||||
assert audit.action == "finding.review" and audit.actor == "dev"
|
||||
assert "D6 dismissed" in audit.detail and "доклад по рации" in audit.detail
|
||||
|
||||
|
||||
def test_finding_review_is_not_saved_when_audit_fails(postgres_access):
|
||||
"""Fail-closed: строка аудита не записалась — решения и нового балла тоже нет."""
|
||||
from sqlalchemy import select
|
||||
|
||||
from app.db.base import get_sessionmaker
|
||||
from app.db.models import AuditLog, Score
|
||||
from app.domain.events import Exercise, SessionMode
|
||||
from app.session.pg_store import PostgresSessionStore
|
||||
from app.session.state import SessionState
|
||||
from app.session.store import LessonRequest, ScoreCalculated
|
||||
|
||||
store = PostgresSessionStore(get_sessionmaker())
|
||||
session_id = uuid4()
|
||||
report = report_with([dds_metric("dds_progress", False)], [dds_finding(ErrorCode.D6)])
|
||||
# actor в audit_log — String(80): длинный логин роняет INSERT аудита
|
||||
# на стороне PostgreSQL, а Score меняется в той же транзакции.
|
||||
broken = FindingReview(decision=FindingDecision.DISMISSED, reason="доклад по рации",
|
||||
author="x" * 200, at=AT)
|
||||
|
||||
async def scenario():
|
||||
def build(_identity):
|
||||
return SessionState(session_id=session_id, scenario_id="fire-apartment-l2",
|
||||
scenario_title="Пожар", level="L2", mode=SessionMode.TRAINING,
|
||||
exercise=Exercise.DDS)
|
||||
|
||||
await store.open(LessonRequest(
|
||||
session_id=session_id, scenario_id="fire-apartment-l2", mode="training",
|
||||
trainee_name=None, trainee_id=None, owner_login="teacher", backend_node_id=None,
|
||||
), build)
|
||||
await store.commit_archived(session_id, [ScoreCalculated(50.0, report)])
|
||||
with pytest.raises(Exception):
|
||||
await store.commit_archived(session_id, [FindingReviewed(
|
||||
index=0, role="instructor", review=broken,
|
||||
)])
|
||||
async with get_sessionmaker()() as db:
|
||||
score = await db.scalar(select(Score).where(Score.session_id == session_id))
|
||||
audit = await db.scalar(select(AuditLog).where(
|
||||
AuditLog.object_id == str(session_id), AuditLog.action == "finding.review",
|
||||
))
|
||||
return score, audit
|
||||
|
||||
score, audit = asyncio.run(scenario())
|
||||
assert audit is None
|
||||
assert score.score_final == 50.0
|
||||
assert score.report["findings"][0].get("reviews", []) == []
|
||||
assert "score_reviewed" not in score.report
|
||||
|
||||
|
||||
def test_archived_lesson_review_through_http_in_postgres(postgres_access, monkeypatch):
|
||||
"""Тот же маршрут на настоящей PostgreSQL: ответ перечитан после commit под блокировкой."""
|
||||
from sqlalchemy import select
|
||||
|
||||
from app.db.base import get_sessionmaker
|
||||
from app.db.models import AuditLog
|
||||
from app.domain.events import Exercise, SessionMode
|
||||
from app.session.pg_store import PostgresSessionStore
|
||||
from app.session.state import SessionState
|
||||
from app.session.store import LessonRequest, ScoreCalculated
|
||||
from tests.test_report_export import sample_report
|
||||
|
||||
session_id = uuid4()
|
||||
archived = sample_report().model_dump(mode="json")
|
||||
archived.update(session_id=str(session_id), score_final=0.0, score_auto=0.0,
|
||||
overridden_by=None, override_comment=None,
|
||||
findings=[dds_finding(ErrorCode.D6).model_dump(mode="json")],
|
||||
metrics=[dds_metric("dds_progress", False).model_dump(mode="json")])
|
||||
report = {"score_auto": 0.0, "summary": {"codes": {"D6": 1}},
|
||||
"findings": archived["findings"], "metrics": archived["metrics"],
|
||||
"full_report": archived}
|
||||
store = PostgresSessionStore(get_sessionmaker())
|
||||
|
||||
async def prepare():
|
||||
def build(_identity):
|
||||
return SessionState(session_id=session_id, scenario_id="fire-apartment-l2",
|
||||
scenario_title="Пожар", level="L2", mode=SessionMode.TRAINING,
|
||||
exercise=Exercise.DDS)
|
||||
|
||||
await store.open(LessonRequest(
|
||||
session_id=session_id, scenario_id="fire-apartment-l2", mode="training",
|
||||
trainee_name=None, trainee_id=None, owner_login="dev", backend_node_id=None,
|
||||
), build)
|
||||
await store.commit_archived(session_id, [ScoreCalculated(0.0, report)])
|
||||
|
||||
async def audit():
|
||||
async with get_sessionmaker()() as db:
|
||||
return await db.scalar(select(AuditLog).where(
|
||||
AuditLog.object_id == str(session_id), AuditLog.action == "finding.review"))
|
||||
|
||||
monkeypatch.setattr(hub, "get", lambda _session_id: None)
|
||||
# Пул соединений привязан к циклу событий: подготовка и проверка идут
|
||||
# в цикле того же TestClient, что и запрос.
|
||||
with TestClient(app) as browser:
|
||||
browser.post("/api/auth/dev-token")
|
||||
previous, hub.store = hub.store, store
|
||||
try:
|
||||
browser.portal.call(prepare)
|
||||
response = browser.post(f"/api/sessions/{session_id}/findings/0/review",
|
||||
json={"decision": "dismissed", "reason": "доклад по рации"})
|
||||
row = browser.portal.call(audit)
|
||||
finally:
|
||||
hub.store = previous
|
||||
|
||||
assert response.status_code == 200, response.text
|
||||
assert response.json()["score_final"] == 100.0
|
||||
assert response.json()["findings"][0]["reviews"][-1]["reason"] == "доклад по рации"
|
||||
assert row is not None and "доклад по рации" in row.detail
|
||||
|
|
@ -84,6 +84,8 @@ HTTP_ROLE_GATE_POLICY = {
|
|||
("http/sessions.py", "get", "/{session_id}/checklist"): ((),),
|
||||
("http/sessions.py", "get", "/{session_id}/recording.wav"): (("INSTRUCTOR", "TRAINEE"),),
|
||||
("http/sessions.py", "patch", "/{session_id}/report"): (("INSTRUCTOR",),),
|
||||
("http/sessions.py", "post", "/{session_id}/findings/{index}/review"): (("INSTRUCTOR",),),
|
||||
("http/sessions.py", "post", "/{session_id}/findings"): (("INSTRUCTOR",),),
|
||||
("http/sessions.py", "get", ""): ((),),
|
||||
("http/trainees.py", "get", "/{trainee_id}/certificate.pdf"): ((),),
|
||||
("http/trainees.py", "get", ""): (("ADMIN", "INSTRUCTOR"),),
|
||||
|
|
|
|||
|
|
@ -37,6 +37,7 @@ export function Debrief({ report, big = false }: { report: SessionReport; big?:
|
|||
<article className="debrief-stat">
|
||||
<span>Автоматическая оценка</span><strong>{report.score_auto.toFixed(0)}<small> из 100</small></strong>
|
||||
<small>{report.overridden_by ? "до корректировки преподавателя" : "расчёт по критериям занятия"}</small>
|
||||
{report.score_reviewed != null && <small>после разбора отметок: {report.score_reviewed.toFixed(0)}</small>}
|
||||
</article>
|
||||
<article className="debrief-stat">
|
||||
<span>Упражнение</span><strong>{report.exercise === "dds" ? "ДДС" : report.exercise === "card" ? "КИО" : report.exercise === "call" ? "Вызов 112" : "112 → ДДС"}</strong>
|
||||
|
|
@ -89,7 +90,8 @@ export function Debrief({ report, big = false }: { report: SessionReport; big?:
|
|||
{Boolean(report.card_results?.length) && <section className="debrief-card-results">
|
||||
<h3>Карточки занятия ({report.card_results!.length})</h3>
|
||||
{report.card_results!.map((card, index) => <details key={card.card_id}>
|
||||
<summary>Карточка {index + 1}: {card.title || card.scenario_id} · {card.score_auto.toFixed(0)} / 100
|
||||
<summary>Карточка {index + 1}: {card.title || card.scenario_id} · {(card.score_reviewed ?? card.score_auto).toFixed(0)} / 100
|
||||
{card.score_reviewed != null && ` после разбора (автооценка ${card.score_auto.toFixed(0)})`}
|
||||
{card.address ? ` · ${card.address}` : ""}</summary>
|
||||
{card.managed_service && <p><strong>Ответственная служба:</strong> {card.managed_service}</p>}
|
||||
<p><strong>Ответ диспетчера:</strong> {card.reply_text || "не внесён"}</p>
|
||||
|
|
@ -144,6 +146,10 @@ export function Debrief({ report, big = false }: { report: SessionReport; big?:
|
|||
<td>
|
||||
{finding.summary}
|
||||
<div className="ref">{finding.fact}{finding.norm && ` · ${finding.norm}`}</div>
|
||||
{finding.source === "instructor" && <div className="ref">отметка преподавателя {finding.author ?? ""}</div>}
|
||||
{(finding.reviews ?? []).map((review, reviewIndex) => <div className="ref" key={reviewIndex}>
|
||||
{review.decision === "dismissed" ? "снята" : "подтверждена"} преподавателем {review.author}: {review.reason}
|
||||
</div>)}
|
||||
</td>
|
||||
</tr>
|
||||
))}
|
||||
|
|
|
|||
162
frontend/src/features/debrief/FindingReview.tsx
Normal file
162
frontend/src/features/debrief/FindingReview.tsx
Normal file
|
|
@ -0,0 +1,162 @@
|
|||
// Разбор по отметкам: преподаватель подтверждает, снимает и добавляет отметку.
|
||||
//
|
||||
// Балл пересчитывает сервер теми же метриками и весами (lct-35): здесь только
|
||||
// решение и его причина. Причина обязательна — она остаётся в отчёте и в CSV/PDF.
|
||||
|
||||
import { useRef, useState } from "react";
|
||||
|
||||
import type { ErrorCode, FindingDecision, SessionReport } from "@/shared/types/generated";
|
||||
|
||||
const DDS_CODES: ErrorCode[] = ["D1", "D2", "D3", "D4", "D5", "D6"];
|
||||
const CALL_CODES: ErrorCode[] = ["E1", "E2", "E3", "E4", "E5", "E6"];
|
||||
|
||||
async function send(url: string, body: unknown): Promise<SessionReport> {
|
||||
const response = await fetch(url, {
|
||||
method: "POST",
|
||||
credentials: "same-origin",
|
||||
headers: { "Content-Type": "application/json" },
|
||||
body: JSON.stringify(body),
|
||||
});
|
||||
const data = await response.json().catch(() => null);
|
||||
if (!response.ok) {
|
||||
const detail = data && typeof data === "object" && "detail" in data ? data.detail : response.statusText;
|
||||
throw new Error(typeof detail === "string" ? detail : "Не удалось сохранить решение.");
|
||||
}
|
||||
return data as SessionReport;
|
||||
}
|
||||
|
||||
export function FindingReview({ report, onChange }: {
|
||||
report: SessionReport;
|
||||
onChange: (report: SessionReport) => void;
|
||||
}) {
|
||||
const cards = report.card_results ?? [];
|
||||
const codes = report.exercise === "dds" ? DDS_CODES
|
||||
: cards.length ? [...CALL_CODES, ...DDS_CODES] : CALL_CODES;
|
||||
const [reasons, setReasons] = useState<Record<number, string>>({});
|
||||
const [code, setCode] = useState<ErrorCode>(codes[0]);
|
||||
// В ДДС все метрики принадлежат карточкам очереди. В связке 112 → ДДС
|
||||
// E-коды относятся к занятию, а D-код без карточки — к живой карточке звонка.
|
||||
const [card, setCard] = useState(report.exercise === "dds" && cards.length ? "1" : "");
|
||||
const cardChoice = cards.length > 0 && (report.exercise === "dds" || code.startsWith("D"));
|
||||
// Один ключ на отметку, пока она не сохранена: повтор после сбоя сети
|
||||
// не добавит её второй раз.
|
||||
const pendingId = useRef<string | null>(null);
|
||||
const [fact, setFact] = useState("");
|
||||
const [norm, setNorm] = useState("");
|
||||
const [busy, setBusy] = useState(false);
|
||||
const [error, setError] = useState("");
|
||||
const base = `/api/sessions/${report.session_id}/findings`;
|
||||
|
||||
async function run(action: () => Promise<SessionReport>) {
|
||||
setBusy(true);
|
||||
setError("");
|
||||
try {
|
||||
onChange(await action());
|
||||
} catch (cause) {
|
||||
setError(cause instanceof Error ? cause.message : "Не удалось сохранить решение.");
|
||||
} finally {
|
||||
setBusy(false);
|
||||
}
|
||||
}
|
||||
|
||||
function decide(index: number, decision: FindingDecision) {
|
||||
const reason = (reasons[index] ?? "").trim();
|
||||
if (!reason) {
|
||||
setError("Укажите причину решения по отметке.");
|
||||
return;
|
||||
}
|
||||
void run(async () => {
|
||||
const updated = await send(`${base}/${index}/review`, { decision, reason });
|
||||
setReasons((current) => ({ ...current, [index]: "" }));
|
||||
return updated;
|
||||
});
|
||||
}
|
||||
|
||||
function addFinding() {
|
||||
if (!fact.trim() || !norm.trim()) {
|
||||
setError("Для отметки нужны факт и норма.");
|
||||
return;
|
||||
}
|
||||
pendingId.current ??= crypto.randomUUID();
|
||||
const clientId = pendingId.current;
|
||||
void run(async () => {
|
||||
const updated = await send(base, {
|
||||
code, fact: fact.trim(), norm: norm.trim(), card: cardChoice && card ? Number(card) : null,
|
||||
client_id: clientId,
|
||||
});
|
||||
pendingId.current = null;
|
||||
setFact("");
|
||||
setNorm("");
|
||||
return updated;
|
||||
});
|
||||
}
|
||||
|
||||
return (
|
||||
<section className="debrief finding-review">
|
||||
<h2>Разбор по отметкам</h2>
|
||||
<p className="ref">
|
||||
Снятая отметка не штрафует свою метрику, добавленная — штрафует. Балл пересчитывается
|
||||
по тем же критериям и весам; автоматическая оценка ({report.score_auto.toFixed(1)}) сохраняется рядом.
|
||||
{report.score_reviewed != null && ` После разбора: ${report.score_reviewed.toFixed(1)}.`}
|
||||
</p>
|
||||
<table className="grid">
|
||||
<tbody>
|
||||
{report.findings.map((finding, index) => (
|
||||
<tr key={index}>
|
||||
<th>{finding.code}</th>
|
||||
<td>
|
||||
{finding.summary}
|
||||
<div className="ref">{finding.fact}{finding.norm && ` · ${finding.norm}`}</div>
|
||||
{(finding.reviews ?? []).map((review, reviewIndex, all) => <div key={reviewIndex}
|
||||
className={reviewIndex < all.length - 1 || review.decision === "dismissed" ? "ref" : "state-violated"}>
|
||||
{review.decision === "dismissed" ? "Снята" : "Подтверждена"} ({review.author},{" "}
|
||||
{new Date(review.at).toLocaleString("ru-RU")}): {review.reason}
|
||||
</div>)}
|
||||
<div className="finding-review-actions">
|
||||
<input aria-label={`Причина решения по отметке ${index + 1}`} maxLength={1000}
|
||||
placeholder="Причина решения" value={reasons[index] ?? ""}
|
||||
onChange={(event) => setReasons((current) => ({ ...current, [index]: event.target.value }))} />
|
||||
<button type="button" disabled={busy} onClick={() => decide(index, "confirmed")}>Подтвердить</button>
|
||||
<button type="button" disabled={busy} onClick={() => decide(index, "dismissed")}>Снять</button>
|
||||
</div>
|
||||
</td>
|
||||
</tr>
|
||||
))}
|
||||
{report.findings.length === 0 && <tr><td colSpan={2}>Автоматических отметок нет.</td></tr>}
|
||||
</tbody>
|
||||
</table>
|
||||
|
||||
<h3>Добавить отметку</h3>
|
||||
<div className="finding-review-form">
|
||||
<label>Код
|
||||
<select value={code} onChange={(event) => {
|
||||
pendingId.current = null;
|
||||
setCode(event.target.value as ErrorCode);
|
||||
}}>
|
||||
{codes.map((item) => <option key={item} value={item}>{item}</option>)}
|
||||
</select>
|
||||
</label>
|
||||
{cardChoice && <label>Карточка
|
||||
<select value={card} onChange={(event) => { pendingId.current = null; setCard(event.target.value); }}>
|
||||
{report.exercise !== "dds" && <option value="">занятие (без карточки)</option>}
|
||||
{cards.map((item, index) => <option key={item.card_id} value={String(index + 1)}>
|
||||
{index + 1}: {item.title || item.scenario_id}
|
||||
</option>)}
|
||||
</select>
|
||||
</label>}
|
||||
<label>Факт
|
||||
<input maxLength={1000} value={fact} onChange={(event) => { pendingId.current = null; setFact(event.target.value); }}
|
||||
placeholder="Что сделал курсант" />
|
||||
</label>
|
||||
<label>Норма
|
||||
<input maxLength={1000} value={norm} onChange={(event) => { pendingId.current = null; setNorm(event.target.value); }}
|
||||
placeholder="Как требовалось" />
|
||||
</label>
|
||||
<button type="button" disabled={busy || !fact.trim() || !norm.trim()} onClick={addFinding}>
|
||||
{busy ? "Сохраняем…" : "Добавить отметку"}
|
||||
</button>
|
||||
</div>
|
||||
{error && <p className="violated" role="alert">{error}</p>}
|
||||
</section>
|
||||
);
|
||||
}
|
||||
|
|
@ -39,6 +39,10 @@ const CARD_METRICS = OPERATOR_METRICS.filter(({ key }) => [
|
|||
"required_fields", "description_grammar", "card_fill_time",
|
||||
].includes(key));
|
||||
const CALL_METRICS = OPERATOR_METRICS.filter(({ key }) => key !== "card_fill_time");
|
||||
// Метрика появляется, только когда ручной отметке преподавателя нечего провалить.
|
||||
const REVIEW_METRICS: MetricOption[] = [
|
||||
{ key: "instructor_finding", label: "Отметка преподавателя", hint: "Ручная отметка на разборе без связанной метрики (например, D4)." },
|
||||
];
|
||||
|
||||
export function ScoreWeightsEditor({
|
||||
exercise,
|
||||
|
|
@ -57,6 +61,7 @@ export function ScoreWeightsEditor({
|
|||
: exercise === "card_dds"
|
||||
? [["Карточка КИО", CARD_METRICS], ["Реагирование ДДС", DDS_METRICS]]
|
||||
: [["Опрос 112", CALL_METRICS], ["Реагирование ДДС", DDS_METRICS]];
|
||||
groups.push(["Разбор", REVIEW_METRICS]);
|
||||
|
||||
function setWeight(key: string, raw: string) {
|
||||
const next = { ...values };
|
||||
|
|
|
|||
|
|
@ -384,7 +384,8 @@ export function Dds() {
|
|||
{Boolean(report.card_results?.length) && <>
|
||||
<h3>Результаты по карточкам</h3>
|
||||
{report.card_results?.map((item, index) => <details className="dds-details" key={item.card_id}>
|
||||
<summary>Карточка {index + 1} · {item.scenario_id} · {item.score_auto.toFixed(0)} / 100</summary>
|
||||
<summary>Карточка {index + 1} · {item.scenario_id} · {(item.score_reviewed ?? item.score_auto).toFixed(0)} / 100
|
||||
{item.score_reviewed != null && ` после разбора (автооценка ${item.score_auto.toFixed(0)})`}</summary>
|
||||
<p><b>Ответ диспетчера:</b> {item.reply_text || "не внесён"}</p>
|
||||
{item.metrics.filter((metric) => !metric.passed || (metric.credit != null && metric.credit < 1)).map((metric) =>
|
||||
<p key={metric.key} className={metric.passed ? "ref" : "state-violated"}>
|
||||
|
|
|
|||
|
|
@ -7,6 +7,7 @@
|
|||
import { useEffect, useRef, useState } from "react";
|
||||
|
||||
import { Debrief } from "@/features/debrief/Debrief";
|
||||
import { FindingReview } from "@/features/debrief/FindingReview";
|
||||
import { Director } from "@/features/instructor/Director";
|
||||
import { ScoreWeightsEditor } from "@/features/instructor/ScoreWeightsEditor";
|
||||
import { ScenarioEditor } from "@/features/instructor/ScenarioEditor";
|
||||
|
|
@ -814,6 +815,8 @@ export function Instructor() {
|
|||
{session.report && <>
|
||||
<Debrief report={overrideReport?.session_id === session.report.session_id
|
||||
? overrideReport : session.report} />
|
||||
<FindingReview report={overrideReport?.session_id === session.report.session_id
|
||||
? overrideReport : session.report} onChange={setOverrideReport} />
|
||||
<section className="debrief debrief-score-override">
|
||||
<h2>Ручная корректировка оценки</h2>
|
||||
<p className="ref">Автоматическая оценка: {session.report.score_auto.toFixed(1)} из 100. Меняйте её только при необходимости: причина сохранится в журнале вместе с вашим логином.</p>
|
||||
|
|
|
|||
|
|
@ -177,6 +177,7 @@ export interface DdsCardReport {
|
|||
card_id: string;
|
||||
scenario_id: string;
|
||||
score_auto: number;
|
||||
score_reviewed?: number | null;
|
||||
reply_text: string;
|
||||
metrics: Array<Metric>;
|
||||
findings: Array<Finding>;
|
||||
|
|
@ -267,6 +268,23 @@ export interface Finding {
|
|||
competency?: Competency | null;
|
||||
transcript_ref?: string | null;
|
||||
at?: string | null;
|
||||
metric_key?: string | null;
|
||||
card?: number | null;
|
||||
service?: string | null;
|
||||
author?: string | null;
|
||||
client_id?: string | null;
|
||||
reviews?: Array<FindingReview>;
|
||||
}
|
||||
|
||||
/** Решение преподавателя по отметке на разборе. */
|
||||
export type FindingDecision = "confirmed" | "dismissed";
|
||||
|
||||
/** Кто, когда и почему подтвердил или снял отметку. Сама отметка остаётся. */
|
||||
export interface FindingReview {
|
||||
decision: FindingDecision;
|
||||
reason: string;
|
||||
author: string;
|
||||
at: string;
|
||||
}
|
||||
|
||||
/** Источник объяснимой отметки; `judge` оставлен для старых отчётов. */
|
||||
|
|
@ -409,6 +427,10 @@ export interface Metric {
|
|||
passed: boolean;
|
||||
weight?: number;
|
||||
credit?: number | null;
|
||||
card?: number | null;
|
||||
service?: string | null;
|
||||
passed_auto?: boolean | null;
|
||||
credit_auto?: number | null;
|
||||
}
|
||||
|
||||
export interface ModeSet {
|
||||
|
|
@ -610,6 +632,7 @@ export interface SessionReport {
|
|||
self_assessment_diff?: SelfAssessmentDiff | null;
|
||||
notes?: Array<InstructorNoteShown>;
|
||||
score_auto: number;
|
||||
score_reviewed?: number | null;
|
||||
score_final: number;
|
||||
overridden_by?: string | null;
|
||||
override_comment?: string | null;
|
||||
|
|
|
|||
|
|
@ -197,6 +197,9 @@ button:disabled { opacity: 0.5; cursor: default; }
|
|||
.debrief-stat > strong { font-size: 24px; line-height: 1.15; overflow-wrap: anywhere; }
|
||||
.debrief-stat > strong small { font-size: 14px; font-weight: 500; }
|
||||
.debrief-stat > small { color: #5a6068; font-size: 12px; }
|
||||
.finding-review-actions { display: flex; flex-wrap: wrap; gap: 6px; margin-top: 6px; }
|
||||
.finding-review-actions input { flex: 1 1 200px; min-width: 0; }
|
||||
.finding-review-form { display: grid; grid-template-columns: repeat(auto-fit, minmax(180px, 1fr)); gap: 8px; align-items: end; }
|
||||
.debrief-stat.is-passed { border-left-color: var(--ok); }
|
||||
.debrief-stat.is-failed { border-left-color: var(--violated); }
|
||||
.debrief-next-step { margin: 12px 0 18px; padding: 12px 15px; border: 1px solid var(--line); border-left: 4px solid #6b7780; border-radius: 5px; background: #fff; }
|
||||
|
|
|
|||
Loading…
Reference in a new issue