600 lines
28 KiB
Python
600 lines
28 KiB
Python
import json
|
|
from pathlib import Path
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException
|
|
from fastapi.responses import FileResponse
|
|
from pydantic import BaseModel, Field, field_validator, model_validator
|
|
from sqlalchemy import func, select
|
|
from sqlalchemy.orm import Session
|
|
|
|
from . import services
|
|
from .services import found, audit
|
|
from .config import get_settings
|
|
from .db import get_db
|
|
from .evidence import CONTENT_ALLOWED
|
|
from .exports import (BATCH_STATUS_LABELS, batch_projects, export_excel,
|
|
export_project_pdf, page_type_label, project_result)
|
|
from .knowledge_pages import page_image_path, page_links
|
|
from .models import (AuditLog, Course, CourseVersion, CriterionScore, ExportTask,
|
|
IndexTask, KnowledgeChunk, KnowledgeDocument, KnowledgePage, Project, RubricVersion, ScoringBatch,
|
|
Student, SubmissionFile, TeacherRevision)
|
|
from .materialized import sync_course_entities, sync_rubric_entities
|
|
from .rules import RubricData
|
|
from .scoring import ATTENTION_STATUSES
|
|
from .settings_store import key_configured, model_config, save_model_config
|
|
from .storage import CATEGORIES, directories, scan
|
|
|
|
router = APIRouter(prefix="/api")
|
|
|
|
|
|
def version_dict(item):
|
|
return {key: getattr(item, key) for key in ("id", "course_id", "version", "title", "objectives", "indicators", "directions", "prompts", "templates", "published", "created_at")}
|
|
|
|
|
|
def rubric_dict(item):
|
|
return {key: getattr(item, key) for key in ("id", "course_version_id", "version", "criteria", "weights", "published", "created_at")}
|
|
|
|
|
|
class CourseInput(BaseModel):
|
|
name: str = Field(min_length=1)
|
|
code: str = Field(min_length=1)
|
|
|
|
|
|
class VersionInput(BaseModel):
|
|
title: str = Field(min_length=1)
|
|
source_version_id: int | None = None
|
|
|
|
|
|
class VersionEdit(BaseModel):
|
|
title: str = Field(min_length=1)
|
|
objectives: list[dict]
|
|
indicators: list[dict]
|
|
directions: list[dict]
|
|
prompts: dict[str, str]
|
|
templates: list[str]
|
|
|
|
|
|
class ImportScan(BaseModel):
|
|
relative_dir: str
|
|
|
|
|
|
class FileConfirm(BaseModel):
|
|
relative_path: str
|
|
category: str
|
|
sha256: str
|
|
status: str = "recognized"
|
|
|
|
|
|
class ProjectConfirm(BaseModel):
|
|
relative_dir: str
|
|
student_no: str = Field(pattern=r"^[0-9]{5,20}$")
|
|
name: str = Field(min_length=1)
|
|
topic: str = Field(min_length=1)
|
|
direction: str = ""
|
|
files: list[FileConfirm] = Field(min_length=1)
|
|
|
|
@field_validator("student_no", "name", "topic", "direction", mode="before")
|
|
@classmethod
|
|
def trim_identity(cls, value):
|
|
return value.strip() if isinstance(value, str) else value
|
|
|
|
@model_validator(mode="after")
|
|
def validate_selection(self):
|
|
selected = [file for file in self.files if file.status != "ignored"]
|
|
if not selected:
|
|
raise ValueError("至少选择1份资料")
|
|
categories = [file.category for file in selected]
|
|
if any(category not in CATEGORIES for category in categories):
|
|
raise ValueError("请选择有效材料类型")
|
|
if len(set(categories)) != len(categories):
|
|
raise ValueError("每类材料只允许选择1份，其余请设为忽略")
|
|
return self
|
|
|
|
|
|
class ImportConfirm(BaseModel):
|
|
course_version_id: int
|
|
projects: list[ProjectConfirm] = Field(min_length=1)
|
|
|
|
|
|
class BatchInput(BaseModel):
|
|
course_version_id: int
|
|
rubric_version_id: int
|
|
project_ids: list[int] | None = Field(default=None, min_length=1)
|
|
|
|
|
|
class ReviewInput(BaseModel):
|
|
score: float = Field(ge=0)
|
|
comment: str = Field(min_length=1)
|
|
reason: str = ""
|
|
|
|
|
|
class ModelSettingsInput(BaseModel):
|
|
base_url: str | None = None
|
|
model: str | None = None
|
|
timeout_seconds: int | None = Field(default=None, ge=10, le=600)
|
|
concurrency: int | None = Field(default=None, ge=1, le=16)
|
|
retries: int | None = Field(default=None, ge=0, le=5)
|
|
api_key: str | None = None
|
|
|
|
|
|
@router.get("/dashboard")
|
|
def dashboard(db: Session = Depends(get_db)):
|
|
"""Overview counts. Items awaiting teacher review are counted as attention needed.
|
|
|
|
A ``needs_review`` item is not a failure: retrieval ran and found only navigation
|
|
pages where the rule requires body content, so a teacher decides it.
|
|
"""
|
|
counts = dict(db.execute(select(CriterionScore.status, func.count(CriterionScore.id))
|
|
.group_by(CriterionScore.status)).all())
|
|
return {"courses": db.scalar(select(func.count(Course.id))), "projects": db.scalar(select(func.count(Project.id))),
|
|
"batches": db.scalar(select(func.count(ScoringBatch.id))),
|
|
"needs_attention": sum(counts.get(status, 0) for status in ATTENTION_STATUSES),
|
|
"needs_review": counts.get("needs_review", 0),
|
|
"unscorable": counts.get("unscorable", 0),
|
|
"failed": counts.get("failed", 0),
|
|
"status_counts": counts}
|
|
|
|
|
|
@router.get("/courses")
|
|
def list_courses(db: Session = Depends(get_db)):
|
|
return [{"id": c.id, "name": c.name, "code": c.code} for c in db.scalars(select(Course).order_by(Course.id))]
|
|
|
|
|
|
@router.post("/courses")
|
|
def create_course(data: CourseInput, db: Session = Depends(get_db)):
|
|
if db.scalar(select(Course.id).where((Course.code == data.code) | (Course.name == data.name))):
|
|
raise HTTPException(409, "课程名称或代码已存在")
|
|
course = Course(**data.model_dump())
|
|
db.add(course)
|
|
db.flush()
|
|
version = CourseVersion(course_id=course.id, version=1, title="初始草稿", objectives=[], indicators=[], directions=[], prompts={}, templates=[])
|
|
db.add(version)
|
|
db.flush()
|
|
sync_course_entities(db, version)
|
|
audit(db, "create", "course", course.id)
|
|
db.commit()
|
|
return {"id": course.id}
|
|
|
|
|
|
@router.get("/courses/{course_id}/versions")
|
|
def list_versions(course_id: int, db: Session = Depends(get_db)):
|
|
found(db, Course, course_id)
|
|
return [version_dict(v) for v in db.scalars(select(CourseVersion).where(CourseVersion.course_id == course_id).order_by(CourseVersion.version.desc()))]
|
|
|
|
|
|
@router.get("/course-versions/{version_id}")
|
|
def get_version(version_id: int, db: Session = Depends(get_db)):
|
|
return version_dict(found(db, CourseVersion, version_id))
|
|
|
|
|
|
@router.post("/courses/{course_id}/versions")
|
|
def copy_version(course_id: int, data: VersionInput, db: Session = Depends(get_db)):
|
|
found(db, Course, course_id)
|
|
source = found(db, CourseVersion, data.source_version_id) if data.source_version_id else db.scalar(select(CourseVersion).where(CourseVersion.course_id == course_id).order_by(CourseVersion.version.desc()))
|
|
if source and source.course_id != course_id:
|
|
raise HTTPException(400, "源版本不属于课程")
|
|
next_version = (db.scalar(select(func.max(CourseVersion.version)).where(CourseVersion.course_id == course_id)) or 0) + 1
|
|
fields = {key: json.loads(json.dumps(getattr(source, key))) if source else ([] if key != "prompts" else {}) for key in ("objectives", "indicators", "directions", "prompts", "templates")}
|
|
version = CourseVersion(course_id=course_id, version=next_version, title=data.title, published=False, **fields)
|
|
db.add(version)
|
|
db.flush()
|
|
sync_course_entities(db, version)
|
|
if source:
|
|
rubric = db.scalar(select(RubricVersion).where(RubricVersion.course_version_id == source.id).order_by(RubricVersion.version.desc()))
|
|
if rubric:
|
|
copied = RubricVersion(course_version_id=version.id, version=1, criteria=rubric.criteria, weights=rubric.weights, published=False)
|
|
db.add(copied)
|
|
db.flush()
|
|
sync_rubric_entities(db, copied)
|
|
audit(db, "copy", "course_version", version.id, {"source_id": source.id if source else None})
|
|
db.commit()
|
|
return version_dict(version)
|
|
|
|
|
|
@router.put("/course-versions/{version_id}")
|
|
def edit_version(version_id: int, data: VersionEdit, db: Session = Depends(get_db)):
|
|
version = found(db, CourseVersion, version_id)
|
|
if version.published:
|
|
raise HTTPException(409, "已发布版本不可修改，请复制新版本")
|
|
for key, value in data.model_dump().items():
|
|
setattr(version, key, value)
|
|
sync_course_entities(db, version)
|
|
audit(db, "edit", "course_version", version.id)
|
|
db.commit()
|
|
return version_dict(version)
|
|
|
|
|
|
@router.post("/course-versions/{version_id}/publish")
|
|
def publish_version(version_id: int, db: Session = Depends(get_db)):
|
|
version = found(db, CourseVersion, version_id)
|
|
if not version.objectives or not version.indicators or not all(k in version.prompts for k in ("facts", "score", "consistency")):
|
|
raise HTTPException(400, "课程目标、指标点和三个Prompt不能为空")
|
|
version.published = True
|
|
audit(db, "publish", "course_version", version.id)
|
|
db.commit()
|
|
return version_dict(version)
|
|
|
|
|
|
@router.get("/course-versions/{version_id}/rubrics")
|
|
def list_rubrics(version_id: int, db: Session = Depends(get_db)):
|
|
found(db, CourseVersion, version_id)
|
|
return [rubric_dict(r) for r in db.scalars(select(RubricVersion).where(RubricVersion.course_version_id == version_id).order_by(RubricVersion.version.desc()))]
|
|
|
|
|
|
@router.post("/course-versions/{version_id}/rubrics")
|
|
def create_rubric(version_id: int, data: RubricData, db: Session = Depends(get_db)):
|
|
found(db, CourseVersion, version_id)
|
|
next_version = (db.scalar(select(func.max(RubricVersion.version)).where(RubricVersion.course_version_id == version_id)) or 0) + 1
|
|
rubric = RubricVersion(course_version_id=version_id, version=next_version, criteria=[c.model_dump() for c in data.criteria], weights=data.weights)
|
|
db.add(rubric)
|
|
db.flush()
|
|
sync_rubric_entities(db, rubric)
|
|
db.commit()
|
|
return rubric_dict(rubric)
|
|
|
|
|
|
@router.post("/course-versions/{version_id}/rubrics/copy-from/{source_id}")
|
|
def create_rubric_from_source(version_id: int, source_id: int, db: Session = Depends(get_db)):
|
|
found(db, CourseVersion, version_id)
|
|
source = found(db, RubricVersion, source_id)
|
|
next_version = (db.scalar(select(func.max(RubricVersion.version)).where(RubricVersion.course_version_id == version_id)) or 0) + 1
|
|
rubric = RubricVersion(course_version_id=version_id, version=next_version,
|
|
criteria=json.loads(json.dumps(source.criteria)), weights=dict(source.weights), published=False)
|
|
db.add(rubric)
|
|
db.flush()
|
|
sync_rubric_entities(db, rubric)
|
|
audit(db, "copy", "rubric", rubric.id, {"source_id": source.id})
|
|
db.commit()
|
|
return rubric_dict(rubric)
|
|
|
|
|
|
@router.get("/rubrics/catalog")
|
|
def rubric_catalog(db: Session = Depends(get_db)):
|
|
return [{"id": r.id, "course_version_id": r.course_version_id, "version": r.version,
|
|
"criteria_count": len(r.criteria)} for r in db.scalars(select(RubricVersion).where(RubricVersion.published.is_(True)).order_by(RubricVersion.id))]
|
|
|
|
|
|
@router.get("/rubrics/{rubric_id}")
|
|
def get_rubric(rubric_id: int, db: Session = Depends(get_db)):
|
|
return rubric_dict(found(db, RubricVersion, rubric_id))
|
|
|
|
|
|
@router.post("/rubrics/{rubric_id}/copy")
|
|
def copy_rubric(rubric_id: int, db: Session = Depends(get_db)):
|
|
source = found(db, RubricVersion, rubric_id)
|
|
next_version = (db.scalar(select(func.max(RubricVersion.version)).where(RubricVersion.course_version_id == source.course_version_id)) or 0) + 1
|
|
rubric = RubricVersion(course_version_id=source.course_version_id, version=next_version,
|
|
criteria=json.loads(json.dumps(source.criteria)), weights=dict(source.weights), published=False)
|
|
db.add(rubric)
|
|
db.flush()
|
|
sync_rubric_entities(db, rubric)
|
|
audit(db, "copy", "rubric", rubric.id, {"source_id": source.id})
|
|
db.commit()
|
|
return rubric_dict(rubric)
|
|
|
|
|
|
@router.put("/rubrics/{rubric_id}")
|
|
def edit_rubric(rubric_id: int, data: RubricData, db: Session = Depends(get_db)):
|
|
rubric = found(db, RubricVersion, rubric_id)
|
|
if rubric.published:
|
|
raise HTTPException(409, "已发布规则不可修改，请复制新版本")
|
|
rubric.criteria, rubric.weights = [c.model_dump() for c in data.criteria], data.weights
|
|
sync_rubric_entities(db, rubric)
|
|
audit(db, "edit", "rubric", rubric.id)
|
|
db.commit()
|
|
return rubric_dict(rubric)
|
|
|
|
|
|
@router.post("/rubrics/{rubric_id}/publish")
|
|
def publish_rubric(rubric_id: int, db: Session = Depends(get_db)):
|
|
rubric = found(db, RubricVersion, rubric_id)
|
|
data = RubricData(criteria=rubric.criteria, weights=rubric.weights)
|
|
version = found(db, CourseVersion, rubric.course_version_id)
|
|
objective_codes = {str(item.get("code")) for item in version.objectives}
|
|
indicator_codes = {str(item.get("code")) for item in version.indicators}
|
|
for criterion in data.criteria:
|
|
if not set(criterion.linked_objectives) <= objective_codes or not set(criterion.linked_outcomes) <= indicator_codes:
|
|
raise HTTPException(400, f"{criterion.criterion_id}关联了课程版本不存在的目标或指标点")
|
|
rubric.published = True
|
|
audit(db, "publish", "rubric", rubric.id)
|
|
db.commit()
|
|
return rubric_dict(rubric)
|
|
|
|
|
|
@router.get("/storage/directories")
|
|
def list_directories(relative: str = "."):
|
|
return directories(relative)
|
|
|
|
|
|
@router.post("/import/scan")
|
|
def scan_import(data: ImportScan):
|
|
return scan(data.relative_dir)
|
|
|
|
|
|
@router.post("/import/confirm")
|
|
def confirm_import(data: ImportConfirm, db: Session = Depends(get_db)):
|
|
return services.confirm_import(data, db)
|
|
|
|
|
|
@router.get("/projects")
|
|
def list_projects(course_version_id: int | None = None, db: Session = Depends(get_db)):
|
|
query = select(Project).order_by(Project.id.desc())
|
|
if course_version_id:
|
|
query = query.where(Project.course_version_id == course_version_id)
|
|
result = []
|
|
for project in db.scalars(query):
|
|
student = db.get(Student, project.student_id)
|
|
files = db.scalars(select(SubmissionFile).where(SubmissionFile.project_id == project.id)).all()
|
|
result.append({"id": project.id, "student_no": student.student_no, "name": student.name, "topic": project.topic,
|
|
"course_version_id": project.course_version_id, "status": project.status,
|
|
"missing": [category for category in CATEGORIES if not any(file.category == category and file.recognition_status == "recognized" for file in files)],
|
|
"materials": [{"id": file.id, "file_name": Path(file.relative_path).name,
|
|
"category": file.category, "parse_status": file.parse_status,
|
|
"parse_error": file.parse_error}
|
|
for file in files if file.recognition_status == "recognized"],
|
|
"parse_errors": [file.parse_error for file in files if file.parse_error]})
|
|
return result
|
|
|
|
|
|
@router.get("/projects/{project_id}")
|
|
def get_project(project_id: int, db: Session = Depends(get_db)):
|
|
project = found(db, Project, project_id)
|
|
student = db.get(Student, project.student_id)
|
|
files = db.scalars(select(SubmissionFile).where(SubmissionFile.project_id == project.id)).all()
|
|
return {"id": project.id, "student_no": student.student_no, "name": student.name, "topic": project.topic,
|
|
"course_version_id": project.course_version_id, "direction": project.direction, "facts": project.facts,
|
|
"files": [{**{key: getattr(file, key) for key in ("id", "category", "relative_path", "sha256", "parse_status", "parse_error", "recognition_status")},
|
|
"warnings": [{"page": page["page_number"], "message": message}
|
|
for page in (file.parsed or {}).get("pages", [])
|
|
for message in ([page.get("text_quality", {}).get("warning")] +
|
|
[table.get("warning") for table in page.get("tables", [])])
|
|
if message]}
|
|
for file in files]}
|
|
|
|
|
|
@router.get("/knowledge")
|
|
def knowledge(course_version_id: int, project_id: int | None = None, db: Session = Depends(get_db)):
|
|
query = select(KnowledgeDocument).where(KnowledgeDocument.course_version_id == course_version_id,
|
|
KnowledgeDocument.project_id == project_id)
|
|
documents = db.scalars(query).all()
|
|
counts = dict(db.execute(select(KnowledgeChunk.document_id, func.count(KnowledgeChunk.id))
|
|
.where(KnowledgeChunk.document_id.in_(query.with_only_columns(KnowledgeDocument.id)))
|
|
.group_by(KnowledgeChunk.document_id)).all()) if documents else {}
|
|
return [{"id": doc.id, "title": doc.title, "type": doc.document_type, "status": doc.status,
|
|
"index_version": doc.index_version, "revision": doc.revision,
|
|
"requires_reindex": doc.status != "superseded" and (doc.index_version != services.INDEX_VERSION or doc.status != "ready"),
|
|
"chunks": counts.get(doc.id, 0)} for doc in documents]
|
|
|
|
|
|
@router.get("/knowledge/documents/{document_id}/pages/{page}")
|
|
def knowledge_page(document_id: int, page: int, db: Session = Depends(get_db)):
|
|
doc = found(db, KnowledgeDocument, document_id)
|
|
record = db.get(KnowledgePage, (document_id, page))
|
|
if not record:
|
|
raise HTTPException(404, "资料页面不存在")
|
|
return {"document_id": doc.id, "title": doc.title, "course_version_id": doc.course_version_id,
|
|
"project_id": doc.project_id, "page": page,
|
|
"text": record.text,
|
|
"page_type": record.page_type or "unknown",
|
|
"page_type_label": page_type_label(record.page_type),
|
|
"mixed": bool(record.mixed),
|
|
"section": record.section or "", "chapter": record.chapter or "",
|
|
"confidence": record.confidence,
|
|
"classification": record.classification or {},
|
|
"content_allowed": (record.page_type or "unknown") in CONTENT_ALLOWED,
|
|
"image_url": page_links(db, document_id, page)["image_url"]}
|
|
|
|
|
|
@router.get("/knowledge/documents/{document_id}/pages")
|
|
def knowledge_document_pages(document_id: int, db: Session = Depends(get_db)):
|
|
"""Page inventory with types, so the teacher can see how a document was classified."""
|
|
doc = found(db, KnowledgeDocument, document_id)
|
|
records = db.scalars(select(KnowledgePage).where(KnowledgePage.document_id == document_id)
|
|
.order_by(KnowledgePage.page)).all()
|
|
return {"document_id": doc.id, "title": doc.title, "index_version": doc.index_version,
|
|
"pages": [{"page": item.page, "page_type": item.page_type or "unknown",
|
|
"page_type_label": page_type_label(item.page_type),
|
|
"mixed": bool(item.mixed), "section": item.section or "",
|
|
"chapter": item.chapter or "", "confidence": item.confidence,
|
|
"classification": item.classification or {},
|
|
"content_allowed": (item.page_type or "unknown") in CONTENT_ALLOWED}
|
|
for item in records]}
|
|
|
|
|
|
@router.get("/knowledge/documents/{document_id}/pages/{page}/image")
|
|
def knowledge_page_image(document_id: int, page: int, db: Session = Depends(get_db)):
|
|
doc = found(db, KnowledgeDocument, document_id)
|
|
path = page_image_path(db, doc, page)
|
|
if not path:
|
|
raise HTTPException(404, "页面图像不存在")
|
|
return FileResponse(path, media_type="image/png")
|
|
|
|
|
|
@router.post("/knowledge/ingest-course/{course_version_id}")
|
|
def ingest_course(course_version_id: int, db: Session = Depends(get_db)):
|
|
return services.ingest_course(course_version_id, db)
|
|
|
|
|
|
@router.get("/knowledge/stale/{course_version_id}")
|
|
def stale_knowledge(course_version_id: int, db: Session = Depends(get_db)):
|
|
"""Documents still on an older index; they are excluded from retrieval until rebuilt."""
|
|
from .indexing import stale_documents
|
|
from .rag import INDEX_VERSION
|
|
found(db, CourseVersion, course_version_id)
|
|
documents = stale_documents(db, course_version_id)
|
|
return {"index_version": INDEX_VERSION,
|
|
"documents": [{"id": item.id, "title": item.title, "type": item.document_type,
|
|
"project_id": item.project_id, "index_version": item.index_version,
|
|
"status": item.status} for item in documents]}
|
|
|
|
|
|
@router.post("/knowledge/reindex/{course_version_id}")
|
|
def reindex_knowledge(course_version_id: int, db: Session = Depends(get_db)):
|
|
"""Queue a rebuild of every stale index for this course version."""
|
|
from .indexing import create_reindex_task
|
|
found(db, CourseVersion, course_version_id)
|
|
task = create_reindex_task(db, course_version_id)
|
|
return get_index_task(task.id, db)
|
|
|
|
|
|
@router.get("/index-tasks")
|
|
def list_index_tasks(project_id: int | None = None, db: Session = Depends(get_db)):
|
|
query = select(IndexTask).order_by(IndexTask.id.desc()).limit(100)
|
|
if project_id is not None:
|
|
file_ids = select(SubmissionFile.id).where(SubmissionFile.project_id == project_id)
|
|
query = query.where(IndexTask.submission_file_id.in_(file_ids))
|
|
return [{key: getattr(task, key) for key in ("id", "course_version_id", "submission_file_id", "kind", "status", "result", "error", "created_at", "updated_at")}
|
|
for task in db.scalars(query)]
|
|
|
|
|
|
@router.get("/index-tasks/{task_id}")
|
|
def get_index_task(task_id: int, db: Session = Depends(get_db)):
|
|
task = found(db, IndexTask, task_id)
|
|
return {key: getattr(task, key) for key in ("id", "course_version_id", "submission_file_id", "kind", "status", "result", "error", "created_at", "updated_at")}
|
|
|
|
|
|
@router.post("/index-tasks/{task_id}/retry")
|
|
def retry_index_task(task_id: int, db: Session = Depends(get_db)):
|
|
retry = services.retry_index_task(db, task_id)
|
|
return get_index_task(retry.id, db)
|
|
|
|
|
|
@router.post("/scoring-batches")
|
|
def create_batch(data: BatchInput, db: Session = Depends(get_db)):
|
|
return services.create_batch(data, db)
|
|
|
|
|
|
def batch_status_counts(db, batch_id: int) -> dict:
|
|
rows = db.execute(select(CriterionScore.status, func.count(CriterionScore.id))
|
|
.where(CriterionScore.batch_id == batch_id).group_by(CriterionScore.status)).all()
|
|
counts = {status: count for status, count in rows}
|
|
return {"status_counts": counts, "needs_review": counts.get("needs_review", 0),
|
|
"unscorable": counts.get("unscorable", 0), "failed": counts.get("failed", 0)}
|
|
|
|
def batch_version_metadata(batch: ScoringBatch) -> dict:
|
|
"""Display the immutable rule/course versions, not their database IDs."""
|
|
return {"course_version": batch.course_snapshot.get("version"),
|
|
"course_title": batch.course_snapshot.get("title", ""),
|
|
"rubric_version": batch.rubric_snapshot.get("version"),
|
|
"criterion_count": len(batch.rubric_snapshot.get("criteria", []))}
|
|
|
|
|
|
@router.get("/scoring-batches")
|
|
def list_batches(db: Session = Depends(get_db)):
|
|
return [{**{key: getattr(batch, key) for key in ("id", "course_version_id", "rubric_version_id", "status", "progress_done", "progress_total", "error", "created_at", "finished_at")},
|
|
"status_label": BATCH_STATUS_LABELS.get(batch.status, batch.status),
|
|
"project_ids": batch.project_ids, "legacy_membership": batch.project_ids is None,
|
|
**batch_version_metadata(batch),
|
|
**batch_status_counts(db, batch.id)}
|
|
for batch in db.scalars(select(ScoringBatch).order_by(ScoringBatch.id.desc()))]
|
|
|
|
|
|
@router.get("/scoring-batches/{batch_id}/progress")
|
|
def batch_progress(batch_id: int, db: Session = Depends(get_db)):
|
|
batch = found(db, ScoringBatch, batch_id)
|
|
return {**{key: getattr(batch, key) for key in ("id", "status", "progress_done", "progress_total", "error", "created_at", "finished_at")},
|
|
"status_label": BATCH_STATUS_LABELS.get(batch.status, batch.status),
|
|
"project_ids": batch.project_ids, "legacy_membership": batch.project_ids is None,
|
|
**batch_version_metadata(batch),
|
|
**batch_status_counts(db, batch_id)}
|
|
|
|
|
|
@router.post("/scoring-batches/{batch_id}/start")
|
|
def start_batch(batch_id: int, db: Session = Depends(get_db)):
|
|
return services.start_batch(batch_id, db)
|
|
|
|
|
|
@router.get("/scoring-batches/{batch_id}/scores")
|
|
def batch_scores(batch_id: int, db: Session = Depends(get_db)):
|
|
batch = found(db, ScoringBatch, batch_id)
|
|
projects = batch_projects(db, batch)
|
|
return [project_result(db, batch, project) for project in projects]
|
|
|
|
|
|
@router.get("/projects/{project_id}/scores")
|
|
def project_scores(project_id: int, batch_id: int, db: Session = Depends(get_db)):
|
|
batch, project = found(db, ScoringBatch, batch_id), found(db, Project, project_id)
|
|
if project.course_version_id != batch.course_version_id:
|
|
raise HTTPException(400, "项目不属于评分批次课程版本")
|
|
if batch.project_ids is not None and project.id not in batch.project_ids:
|
|
raise HTTPException(400, "项目不属于该批次固定项目清单")
|
|
return project_result(db, batch, project)
|
|
|
|
|
|
@router.put("/criterion-scores/{score_id}/review")
|
|
def review_score(score_id: int, data: ReviewInput, db: Session = Depends(get_db)):
|
|
return services.review_score(score_id, data, db)
|
|
|
|
|
|
@router.get("/criterion-scores/{score_id}/revisions")
|
|
def revisions(score_id: int, db: Session = Depends(get_db)):
|
|
found(db, CriterionScore, score_id)
|
|
return [{key: getattr(item, key) for key in ("id", "old_score", "new_score", "old_comment", "new_comment", "reason", "created_at")}
|
|
for item in db.scalars(select(TeacherRevision).where(TeacherRevision.score_id == score_id).order_by(TeacherRevision.id))]
|
|
|
|
|
|
@router.post("/exports/excel")
|
|
def create_excel(data: dict, db: Session = Depends(get_db)):
|
|
task = export_excel(db, int(data["batch_id"]))
|
|
audit(db, "export", "scoring_batch", task.batch_id, {"kind": "excel", "task_id": task.id})
|
|
db.commit()
|
|
return {"id": task.id}
|
|
|
|
|
|
@router.post("/exports/project-pdf")
|
|
def create_pdf(data: dict, db: Session = Depends(get_db)):
|
|
task = export_project_pdf(db, int(data["batch_id"]), int(data["project_id"]))
|
|
audit(db, "export", "project", task.project_id, {"kind": "pdf", "task_id": task.id})
|
|
db.commit()
|
|
return {"id": task.id}
|
|
|
|
|
|
@router.get("/exports")
|
|
def list_exports(db: Session = Depends(get_db)):
|
|
return [{key: getattr(task, key) for key in ("id", "batch_id", "project_id", "kind", "status", "error", "created_at")}
|
|
for task in db.scalars(select(ExportTask).order_by(ExportTask.id.desc()))]
|
|
|
|
|
|
@router.get("/exports/{task_id}")
|
|
def get_export(task_id: int, db: Session = Depends(get_db)):
|
|
task = found(db, ExportTask, task_id)
|
|
return {key: getattr(task, key) for key in ("id", "batch_id", "project_id", "kind", "status", "error", "created_at")}
|
|
|
|
|
|
@router.get("/exports/{task_id}/download")
|
|
def download_export(task_id: int, db: Session = Depends(get_db)):
|
|
task = found(db, ExportTask, task_id)
|
|
root = get_settings().exports_path.resolve()
|
|
path = Path(task.path or "").resolve()
|
|
if task.status != "completed" or not path.is_file() or not path.is_relative_to(root):
|
|
raise HTTPException(404, "导出文件不存在")
|
|
return FileResponse(path, filename=path.name)
|
|
|
|
|
|
@router.get("/assets/{file_id}/{page}")
|
|
def page_asset(file_id: int, page: int, db: Session = Depends(get_db)):
|
|
file = found(db, SubmissionFile, file_id)
|
|
pages = file.parsed.get("pages", []) if file.parsed else []
|
|
item = next((item for item in pages if item["page_number"] == page), None)
|
|
path = Path(item["rendered_image_path"]).resolve() if item and item.get("rendered_image_path") else None
|
|
root = get_settings().processed_path.resolve()
|
|
if not path or not path.is_file() or not path.is_relative_to(root):
|
|
raise HTTPException(404, "页面图像不存在")
|
|
return FileResponse(path, media_type="image/png")
|
|
|
|
|
|
@router.get("/settings/model")
|
|
def get_model_settings(db: Session = Depends(get_db)):
|
|
return {**model_config(db), "api_key_configured": key_configured(db),
|
|
"embedding_model_name": get_settings().embedding_model_name,
|
|
"embedding_model_path": str(get_settings().embedding_model_path),
|
|
"embedding_model_version": get_settings().embedding_model_version}
|
|
|
|
|
|
@router.put("/settings/model")
|
|
def put_model_settings(data: ModelSettingsInput, db: Session = Depends(get_db)):
|
|
result = save_model_config(db, data.model_dump(exclude_none=True))
|
|
audit(db, "edit", "model_settings", None, {"fields": [key for key in data.model_fields_set if key != "api_key"]})
|
|
db.commit()
|
|
return result
|