380 lines
12 KiB
Python
380 lines
12 KiB
Python
"""知识图谱：节点 / 关系浏览与管理员维护。"""
|
|
from __future__ import annotations
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException
|
|
from sqlalchemy import func
|
|
from sqlalchemy.orm import Session
|
|
|
|
from database import get_db
|
|
from dependencies import require_learning_user, require_permission
|
|
from models import (
|
|
ChapterKnowledge,
|
|
Course,
|
|
Knowledge,
|
|
KnowledgeRelation,
|
|
KnowledgeResource,
|
|
QuestionKnowledge,
|
|
Textbook,
|
|
User,
|
|
UserKnowledge,
|
|
)
|
|
from schemas import (
|
|
KnowledgeGraphEdge,
|
|
KnowledgeGraphNode,
|
|
KnowledgeGraphOut,
|
|
KnowledgeMapNode,
|
|
KnowledgeMapOut,
|
|
KnowledgeNodeCreate,
|
|
KnowledgeNodeUpdate,
|
|
KnowledgeRelationIn,
|
|
KnowledgeResourceIn,
|
|
KnowledgeResourceOut,
|
|
)
|
|
from services.mastery_engine import status_for
|
|
from services.knowledge_service import knowledge_resources
|
|
|
|
|
|
router = APIRouter(prefix="/knowledge", tags=["knowledge-graph"])
|
|
|
|
RELATION_TYPES = {"包含", "前置", "相关"}
|
|
|
|
|
|
def _node_out(db: Session, node: Knowledge) -> KnowledgeGraphNode:
|
|
chapter_count = (
|
|
db.query(func.count(ChapterKnowledge.id))
|
|
.filter(ChapterKnowledge.knowledge_id == node.id)
|
|
.scalar()
|
|
or 0
|
|
)
|
|
question_count = (
|
|
db.query(func.count(QuestionKnowledge.id))
|
|
.filter(QuestionKnowledge.knowledge_id == node.id)
|
|
.scalar()
|
|
or 0
|
|
)
|
|
return KnowledgeGraphNode(
|
|
id=node.id,
|
|
name=node.name,
|
|
domain=node.domain,
|
|
category=node.category,
|
|
description=node.description,
|
|
chapter_count=chapter_count,
|
|
question_count=question_count,
|
|
resources=[
|
|
KnowledgeResourceOut(
|
|
id=row.id,
|
|
kind=row.kind,
|
|
title=row.title,
|
|
url=row.url,
|
|
source_name=row.title,
|
|
)
|
|
for row in knowledge_resources(db, node.id)
|
|
],
|
|
)
|
|
|
|
|
|
def _unique_name(db: Session, name: str, exclude_id: int | None = None):
|
|
query = db.query(Knowledge).filter(Knowledge.name == name)
|
|
if exclude_id is not None:
|
|
query = query.filter(Knowledge.id != exclude_id)
|
|
if query.first() is not None:
|
|
raise HTTPException(status_code=400, detail="知识点名称已存在")
|
|
|
|
|
|
@router.get("/graph", response_model=KnowledgeGraphOut)
|
|
def get_graph(
|
|
db: Session = Depends(get_db),
|
|
_: User = Depends(require_permission("knowledge:manage")),
|
|
):
|
|
nodes = db.query(Knowledge).order_by(Knowledge.domain, Knowledge.category, Knowledge.id).all()
|
|
edges = db.query(KnowledgeRelation).order_by(KnowledgeRelation.id).all()
|
|
return KnowledgeGraphOut(
|
|
nodes=[_node_out(db, node) for node in nodes],
|
|
edges=[
|
|
KnowledgeGraphEdge(
|
|
source=edge.source_id,
|
|
target=edge.target_id,
|
|
relation_type=edge.relation_type,
|
|
)
|
|
for edge in edges
|
|
],
|
|
)
|
|
|
|
|
|
@router.get("/map", response_model=KnowledgeMapOut)
|
|
def get_knowledge_map(
|
|
db: Session = Depends(get_db),
|
|
user: User = Depends(require_learning_user),
|
|
):
|
|
"""学生视角的完整知识图谱：全量结构 + 本人掌握度。
|
|
|
|
/knowledge 只返回练过的知识点，画不出一张完整的地图；
|
|
这里一次给全量节点（含未练过的）与全部关系，计数用分组查询，避免逐点 N+1。
|
|
"""
|
|
nodes = (
|
|
db.query(Knowledge)
|
|
.order_by(Knowledge.domain, Knowledge.category, Knowledge.id)
|
|
.all()
|
|
)
|
|
edges = db.query(KnowledgeRelation).order_by(KnowledgeRelation.id).all()
|
|
mastery = {
|
|
row.knowledge_id: row.mastery
|
|
for row in db.query(UserKnowledge)
|
|
.filter(UserKnowledge.user_id == user.id)
|
|
.all()
|
|
}
|
|
question_counts = dict(
|
|
db.query(QuestionKnowledge.knowledge_id, func.count(QuestionKnowledge.id))
|
|
.group_by(QuestionKnowledge.knowledge_id)
|
|
.all()
|
|
)
|
|
chapter_counts = dict(
|
|
db.query(ChapterKnowledge.knowledge_id, func.count(ChapterKnowledge.id))
|
|
.group_by(ChapterKnowledge.knowledge_id)
|
|
.all()
|
|
)
|
|
|
|
def count(mapping: dict, node_id: int) -> int:
|
|
return int(mapping.get(node_id, 0) or 0)
|
|
|
|
return KnowledgeMapOut(
|
|
nodes=[
|
|
KnowledgeMapNode(
|
|
id=node.id,
|
|
name=node.name,
|
|
domain=node.domain,
|
|
category=node.category,
|
|
description=node.description,
|
|
mastery=mastery.get(node.id, 0),
|
|
status=status_for(mastery.get(node.id, 0)),
|
|
practiced=node.id in mastery,
|
|
question_count=count(question_counts, node.id),
|
|
chapter_count=count(chapter_counts, node.id),
|
|
)
|
|
for node in nodes
|
|
],
|
|
edges=[
|
|
KnowledgeGraphEdge(
|
|
source=edge.source_id,
|
|
target=edge.target_id,
|
|
relation_type=edge.relation_type,
|
|
)
|
|
for edge in edges
|
|
],
|
|
)
|
|
|
|
|
|
@router.post("/nodes", response_model=KnowledgeGraphNode)
|
|
def create_node(
|
|
payload: KnowledgeNodeCreate,
|
|
db: Session = Depends(get_db),
|
|
_: User = Depends(require_permission("knowledge:manage")),
|
|
):
|
|
name = payload.name.strip()
|
|
_unique_name(db, name)
|
|
node = Knowledge(
|
|
name=name,
|
|
domain=payload.domain.strip() or "初等",
|
|
category=payload.category.strip(),
|
|
description=payload.description.strip(),
|
|
)
|
|
db.add(node)
|
|
db.commit()
|
|
return _node_out(db, node)
|
|
|
|
|
|
@router.put("/nodes/{node_id}", response_model=KnowledgeGraphNode)
|
|
def update_node(
|
|
node_id: int,
|
|
payload: KnowledgeNodeUpdate,
|
|
db: Session = Depends(get_db),
|
|
_: User = Depends(require_permission("knowledge:manage")),
|
|
):
|
|
node = db.get(Knowledge, node_id)
|
|
if node is None:
|
|
raise HTTPException(status_code=404, detail="知识点不存在")
|
|
fields = payload.model_dump(exclude_unset=True)
|
|
if fields.get("name"):
|
|
name = fields["name"].strip()
|
|
_unique_name(db, name, exclude_id=node.id)
|
|
node.name = name
|
|
if fields.get("domain"):
|
|
node.domain = fields["domain"].strip()
|
|
if "category" in fields:
|
|
node.category = (fields["category"] or "").strip()
|
|
if "description" in fields:
|
|
node.description = (fields["description"] or "").strip()
|
|
db.commit()
|
|
return _node_out(db, node)
|
|
|
|
|
|
@router.delete("/nodes/{node_id}")
|
|
def delete_node(
|
|
node_id: int,
|
|
db: Session = Depends(get_db),
|
|
_: User = Depends(require_permission("knowledge:manage")),
|
|
):
|
|
node = db.get(Knowledge, node_id)
|
|
if node is None:
|
|
raise HTTPException(status_code=404, detail="知识点不存在")
|
|
usage = (
|
|
db.query(func.count(ChapterKnowledge.id))
|
|
.filter(ChapterKnowledge.knowledge_id == node.id)
|
|
.scalar()
|
|
or 0
|
|
) + (
|
|
db.query(func.count(QuestionKnowledge.id))
|
|
.filter(QuestionKnowledge.knowledge_id == node.id)
|
|
.scalar()
|
|
or 0
|
|
)
|
|
if usage > 0:
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail=f"该知识点已关联 {usage} 个章节/题目，不能删除；可改名或先解除引用",
|
|
)
|
|
db.query(KnowledgeRelation).filter(
|
|
(KnowledgeRelation.source_id == node.id)
|
|
| (KnowledgeRelation.target_id == node.id)
|
|
).delete(synchronize_session=False)
|
|
db.query(UserKnowledge).filter(UserKnowledge.knowledge_id == node.id).delete(
|
|
synchronize_session=False
|
|
)
|
|
db.delete(node)
|
|
db.commit()
|
|
return {"deleted": node_id}
|
|
|
|
|
|
@router.post("/nodes/{node_id}/resources", response_model=KnowledgeResourceOut)
|
|
def add_resource(
|
|
node_id: int,
|
|
payload: KnowledgeResourceIn,
|
|
db: Session = Depends(get_db),
|
|
_: User = Depends(require_permission("knowledge:manage")),
|
|
):
|
|
node = db.get(Knowledge, node_id)
|
|
if node is None:
|
|
raise HTTPException(status_code=404, detail="知识点不存在")
|
|
kind = payload.kind.strip() or "video"
|
|
title = payload.title.strip()
|
|
url = payload.url.strip()
|
|
if payload.course_id is not None:
|
|
course = db.get(Course, payload.course_id)
|
|
if course is None:
|
|
raise HTTPException(status_code=404, detail="课程不存在")
|
|
title = title or course.name
|
|
url = url or course.url
|
|
elif payload.textbook_id is not None:
|
|
textbook = db.get(Textbook, payload.textbook_id)
|
|
if textbook is None:
|
|
raise HTTPException(status_code=404, detail="教材不存在")
|
|
title = title or textbook.name
|
|
url = url or textbook.link
|
|
if not title or not url:
|
|
raise HTTPException(status_code=400, detail="资源标题与链接不能为空")
|
|
exists = (
|
|
db.query(KnowledgeResource)
|
|
.filter(
|
|
KnowledgeResource.knowledge_id == node.id,
|
|
KnowledgeResource.kind == kind,
|
|
KnowledgeResource.url == url,
|
|
)
|
|
.first()
|
|
)
|
|
if exists is not None:
|
|
raise HTTPException(status_code=400, detail="该资源已关联到本知识点")
|
|
row = KnowledgeResource(
|
|
knowledge_id=node.id,
|
|
kind=kind,
|
|
title=title,
|
|
url=url,
|
|
textbook_id=payload.textbook_id,
|
|
course_id=payload.course_id,
|
|
)
|
|
db.add(row)
|
|
db.commit()
|
|
return KnowledgeResourceOut(
|
|
id=row.id,
|
|
kind=row.kind,
|
|
title=row.title,
|
|
url=row.url,
|
|
source_name=row.title,
|
|
)
|
|
|
|
|
|
@router.delete("/resources/{resource_id}")
|
|
def remove_resource(
|
|
resource_id: int,
|
|
db: Session = Depends(get_db),
|
|
_: User = Depends(require_permission("knowledge:manage")),
|
|
):
|
|
row = db.get(KnowledgeResource, resource_id)
|
|
if row is None:
|
|
raise HTTPException(status_code=404, detail="资源链接不存在")
|
|
db.delete(row)
|
|
db.commit()
|
|
return {"deleted": resource_id}
|
|
|
|
|
|
@router.post("/relations", response_model=KnowledgeGraphEdge)
|
|
def add_relation(
|
|
payload: KnowledgeRelationIn,
|
|
db: Session = Depends(get_db),
|
|
_: User = Depends(require_permission("knowledge:manage")),
|
|
):
|
|
if payload.relation_type not in RELATION_TYPES:
|
|
raise HTTPException(status_code=400, detail="关系类型仅支持 包含/前置/相关")
|
|
if payload.source_id == payload.target_id:
|
|
raise HTTPException(status_code=400, detail="不能连接到自身")
|
|
source = db.get(Knowledge, payload.source_id)
|
|
target = db.get(Knowledge, payload.target_id)
|
|
if source is None or target is None:
|
|
raise HTTPException(status_code=404, detail="知识点不存在")
|
|
exists = (
|
|
db.query(KnowledgeRelation)
|
|
.filter(
|
|
KnowledgeRelation.source_id == source.id,
|
|
KnowledgeRelation.target_id == target.id,
|
|
KnowledgeRelation.relation_type == payload.relation_type,
|
|
)
|
|
.first()
|
|
)
|
|
if exists is not None:
|
|
raise HTTPException(status_code=400, detail="该关系已存在")
|
|
relation = KnowledgeRelation(
|
|
source_id=source.id,
|
|
target_id=target.id,
|
|
relation_type=payload.relation_type,
|
|
)
|
|
db.add(relation)
|
|
db.commit()
|
|
return KnowledgeGraphEdge(
|
|
source=relation.source_id,
|
|
target=relation.target_id,
|
|
relation_type=relation.relation_type,
|
|
)
|
|
|
|
|
|
@router.delete("/relations")
|
|
def remove_relation(
|
|
source_id: int,
|
|
target_id: int,
|
|
relation_type: str = "前置",
|
|
db: Session = Depends(get_db),
|
|
_: User = Depends(require_permission("knowledge:manage")),
|
|
):
|
|
relation = (
|
|
db.query(KnowledgeRelation)
|
|
.filter(
|
|
KnowledgeRelation.source_id == source_id,
|
|
KnowledgeRelation.target_id == target_id,
|
|
KnowledgeRelation.relation_type == relation_type,
|
|
)
|
|
.first()
|
|
)
|
|
if relation is None:
|
|
raise HTTPException(status_code=404, detail="关系不存在")
|
|
db.delete(relation)
|
|
db.commit()
|
|
return {"deleted": relation.id}
|