511 lines
17 KiB
Python
511 lines
17 KiB
Python
"""
|
|
本地出题批卷数据库 - 用于开发测试
|
|
|
|
使用 SQLite 存储：
|
|
1. 题目表（含溯源信息）
|
|
2. 试卷表
|
|
3. 学生答卷表
|
|
4. 批阅报告表
|
|
"""
|
|
|
|
import os
|
|
import sys
|
|
import json
|
|
import uuid
|
|
from datetime import datetime
|
|
from typing import List, Dict, Optional
|
|
import logging
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
from data.db import get_connection, init_databases
|
|
|
|
if sys.platform == 'win32':
|
|
sys.stdout.reconfigure(encoding='utf-8')
|
|
|
|
|
|
class ExamLocalDB:
|
|
"""本地出题批卷数据库"""
|
|
|
|
def __init__(self):
|
|
"""初始化数据库连接（表结构由 data/db.py 统一管理）"""
|
|
init_databases()
|
|
|
|
# ==================== 题目管理 ====================
|
|
|
|
def add_question(self, question: Dict, source_file: str, source_collection: str) -> str:
|
|
"""
|
|
添加题目到数据库
|
|
|
|
Args:
|
|
question: 题目信息
|
|
source_file: 来源文件路径
|
|
source_collection: 来源向量库
|
|
|
|
Returns:
|
|
题目ID
|
|
"""
|
|
question_id = question.get('id') or str(uuid.uuid4())
|
|
|
|
with get_connection("exam") as conn:
|
|
cursor = conn.cursor()
|
|
|
|
cursor.execute('''
|
|
INSERT OR REPLACE INTO questions
|
|
(id, question_type, content, options, correct_answer, analysis,
|
|
knowledge_points, difficulty, score, source_file, source_collection,
|
|
source_snippet, source_hash, status, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
''', (
|
|
question_id,
|
|
self._detect_question_type(question),
|
|
question.get('content', ''),
|
|
json.dumps(question.get('options', []), ensure_ascii=False) if question.get('options') else None,
|
|
self._get_correct_answer(question),
|
|
question.get('analysis', ''),
|
|
json.dumps(question.get('knowledge_points', []), ensure_ascii=False),
|
|
question.get('difficulty', 3),
|
|
self._get_score(question),
|
|
source_file,
|
|
source_collection,
|
|
json.dumps(question.get('sources', []), ensure_ascii=False),
|
|
question.get('source_hash'),
|
|
'approved',
|
|
datetime.now().isoformat()
|
|
))
|
|
|
|
return question_id
|
|
|
|
def add_questions_batch(self, questions: List[Dict], source_file: str, source_collection: str) -> int:
|
|
"""批量添加题目"""
|
|
count = 0
|
|
for q in questions:
|
|
self.add_question(q, source_file, source_collection)
|
|
count += 1
|
|
return count
|
|
|
|
def get_question(self, question_id: str) -> Optional[Dict]:
|
|
"""获取单个题目"""
|
|
with get_connection("exam") as conn:
|
|
cursor = conn.cursor()
|
|
|
|
cursor.execute('SELECT * FROM questions WHERE id = ?', (question_id,))
|
|
row = cursor.fetchone()
|
|
|
|
if row:
|
|
return self._row_to_question(row)
|
|
return None
|
|
|
|
def get_questions_by_file(self, source_file: str) -> List[Dict]:
|
|
"""根据来源文件获取题目"""
|
|
with get_connection("exam") as conn:
|
|
cursor = conn.cursor()
|
|
|
|
cursor.execute('SELECT * FROM questions WHERE source_file = ?', (source_file,))
|
|
rows = cursor.fetchall()
|
|
|
|
return [self._row_to_question(row) for row in rows]
|
|
|
|
def delete_questions_by_file(self, source_file: str) -> int:
|
|
"""删除指定文件的所有题目"""
|
|
with get_connection("exam") as conn:
|
|
cursor = conn.cursor()
|
|
|
|
cursor.execute('DELETE FROM questions WHERE source_file = ?', (source_file,))
|
|
deleted = cursor.rowcount
|
|
|
|
return deleted
|
|
|
|
def list_questions(self, question_type: str = None, limit: int = 100) -> List[Dict]:
|
|
"""列出题目"""
|
|
with get_connection("exam") as conn:
|
|
cursor = conn.cursor()
|
|
|
|
if question_type:
|
|
cursor.execute(
|
|
'SELECT * FROM questions WHERE question_type = ? ORDER BY created_at DESC LIMIT ?',
|
|
(question_type, limit)
|
|
)
|
|
else:
|
|
cursor.execute('SELECT * FROM questions ORDER BY created_at DESC LIMIT ?', (limit,))
|
|
|
|
rows = cursor.fetchall()
|
|
|
|
return [self._row_to_question(row) for row in rows]
|
|
|
|
# ==================== 试卷管理 ====================
|
|
|
|
def create_exam(self, name: str, question_ids: List[str], created_by: str = 'admin',
|
|
description: str = '', duration: int = 60) -> Dict:
|
|
"""
|
|
创建试卷
|
|
|
|
Args:
|
|
name: 试卷名称
|
|
question_ids: 题目ID列表
|
|
created_by: 创建者
|
|
description: 描述
|
|
duration: 考试时长（分钟）
|
|
|
|
Returns:
|
|
试卷信息
|
|
"""
|
|
exam_id = str(uuid.uuid4())
|
|
|
|
# 计算总分和题目数
|
|
questions = []
|
|
total_score = 0
|
|
for qid in question_ids:
|
|
q = self.get_question(qid)
|
|
if q:
|
|
questions.append(q)
|
|
total_score += q['score']
|
|
|
|
with get_connection("exam") as conn:
|
|
cursor = conn.cursor()
|
|
|
|
# 插入试卷
|
|
cursor.execute('''
|
|
INSERT INTO exams (id, name, description, total_score, total_count, duration, status, created_by)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
|
|
''', (exam_id, name, description, total_score, len(questions), duration, 'published', created_by))
|
|
|
|
# 仅关联实际存在的题目，避免无效 ID 触发外键约束。
|
|
valid_question_ids = [q['id'] for q in questions]
|
|
for order, qid in enumerate(valid_question_ids):
|
|
cursor.execute('''
|
|
INSERT INTO exam_questions (exam_id, question_id, question_order)
|
|
VALUES (?, ?, ?)
|
|
''', (exam_id, qid, order))
|
|
|
|
return {
|
|
'id': exam_id,
|
|
'name': name,
|
|
'total_score': total_score,
|
|
'total_count': len(questions),
|
|
'duration': duration,
|
|
'question_ids': valid_question_ids
|
|
}
|
|
|
|
def get_exam(self, exam_id: str) -> Optional[Dict]:
|
|
"""获取试卷详情"""
|
|
with get_connection("exam") as conn:
|
|
cursor = conn.cursor()
|
|
|
|
cursor.execute('SELECT * FROM exams WHERE id = ?', (exam_id,))
|
|
row = cursor.fetchone()
|
|
|
|
if not row:
|
|
return None
|
|
|
|
exam = {
|
|
'id': row['id'],
|
|
'name': row['name'],
|
|
'description': row['description'],
|
|
'total_score': row['total_score'],
|
|
'total_count': row['total_count'],
|
|
'duration': row['duration'],
|
|
'status': row['status'],
|
|
'created_at': row['created_at'],
|
|
'created_by': row['created_by']
|
|
}
|
|
|
|
# 获取关联的题目
|
|
cursor.execute('''
|
|
SELECT question_id FROM exam_questions
|
|
WHERE exam_id = ? ORDER BY question_order
|
|
''', (exam_id,))
|
|
|
|
question_ids = [r['question_id'] for r in cursor.fetchall()]
|
|
exam['question_ids'] = question_ids
|
|
exam['questions'] = [self.get_question(qid) for qid in question_ids]
|
|
|
|
return exam
|
|
|
|
def list_exams(self, limit: int = 20) -> List[Dict]:
|
|
"""列出试卷"""
|
|
with get_connection("exam") as conn:
|
|
cursor = conn.cursor()
|
|
|
|
cursor.execute('''
|
|
SELECT id, name, total_score, total_count, status, created_at
|
|
FROM exams ORDER BY created_at DESC LIMIT ?
|
|
''', (limit,))
|
|
|
|
rows = cursor.fetchall()
|
|
|
|
return [{
|
|
'id': r['id'],
|
|
'name': r['name'],
|
|
'total_score': r['total_score'],
|
|
'total_count': r['total_count'],
|
|
'status': r['status'],
|
|
'created_at': r['created_at']
|
|
} for r in rows]
|
|
|
|
# ==================== 批卷功能 ====================
|
|
|
|
def submit_answer(self, exam_id: str, student_id: str, question_id: str,
|
|
student_answer: str) -> str:
|
|
"""
|
|
提交学生答案
|
|
|
|
Args:
|
|
exam_id: 试卷ID
|
|
student_id: 学生ID
|
|
question_id: 题目ID
|
|
student_answer: 学生答案
|
|
|
|
Returns:
|
|
答案记录ID
|
|
"""
|
|
answer_id = str(uuid.uuid4())
|
|
|
|
# 获取题目信息
|
|
question = self.get_question(question_id)
|
|
if not question:
|
|
raise ValueError(f"题目不存在: {question_id}")
|
|
|
|
with get_connection("exam") as conn:
|
|
cursor = conn.cursor()
|
|
|
|
cursor.execute('''
|
|
INSERT INTO student_answers
|
|
(id, exam_id, student_id, question_id, question_type,
|
|
student_answer, max_score, submitted_at)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?)
|
|
''', (
|
|
answer_id, exam_id, student_id, question_id,
|
|
question['question_type'], student_answer, question['score'],
|
|
datetime.now().isoformat()
|
|
))
|
|
|
|
return answer_id
|
|
|
|
def grade_answer(self, answer_id: str, score: int, feedback: str,
|
|
score_details: Dict = None) -> Dict:
|
|
"""
|
|
批阅单个答案
|
|
|
|
Args:
|
|
answer_id: 答案ID
|
|
score: 得分
|
|
feedback: 反馈
|
|
score_details: 评分详情
|
|
|
|
Returns:
|
|
批阅结果
|
|
"""
|
|
with get_connection("exam") as conn:
|
|
cursor = conn.cursor()
|
|
|
|
cursor.execute('''
|
|
UPDATE student_answers
|
|
SET score = ?, feedback = ?, score_details = ?, graded_at = ?
|
|
WHERE id = ?
|
|
''', (
|
|
score, feedback,
|
|
json.dumps(score_details, ensure_ascii=False) if score_details else None,
|
|
datetime.now().isoformat(), answer_id
|
|
))
|
|
|
|
return {
|
|
'answer_id': answer_id,
|
|
'score': score,
|
|
'feedback': feedback
|
|
}
|
|
|
|
def get_student_answers(self, exam_id: str, student_id: str) -> List[Dict]:
|
|
"""获取学生的答卷"""
|
|
with get_connection("exam") as conn:
|
|
cursor = conn.cursor()
|
|
|
|
cursor.execute('''
|
|
SELECT * FROM student_answers
|
|
WHERE exam_id = ? AND student_id = ?
|
|
''', (exam_id, student_id))
|
|
|
|
rows = cursor.fetchall()
|
|
|
|
return [self._row_to_answer(row) for row in rows]
|
|
|
|
def generate_grade_report(self, exam_id: str, student_id: str) -> Dict:
|
|
"""
|
|
生成批阅报告
|
|
|
|
Args:
|
|
exam_id: 试卷ID
|
|
student_id: 学生ID
|
|
|
|
Returns:
|
|
批阅报告
|
|
"""
|
|
# 获取学生答案
|
|
answers = self.get_student_answers(exam_id, student_id)
|
|
|
|
if not answers:
|
|
return {'error': '没有找到学生答案'}
|
|
|
|
# 计算总分
|
|
total_score = sum(a['score'] for a in answers)
|
|
max_score = sum(a['max_score'] for a in answers)
|
|
score_rate = round(total_score / max_score * 100, 2) if max_score > 0 else 0
|
|
|
|
# 生成报告
|
|
report_id = str(uuid.uuid4())
|
|
|
|
with get_connection("exam") as conn:
|
|
cursor = conn.cursor()
|
|
|
|
cursor.execute('''
|
|
INSERT INTO grade_reports
|
|
(id, exam_id, student_id, total_score, max_score, score_rate)
|
|
VALUES (?, ?, ?, ?, ?, ?)
|
|
''', (report_id, exam_id, student_id, total_score, max_score, score_rate))
|
|
|
|
return {
|
|
'report_id': report_id,
|
|
'exam_id': exam_id,
|
|
'student_id': student_id,
|
|
'total_score': total_score,
|
|
'max_score': max_score,
|
|
'score_rate': score_rate,
|
|
'answers': answers,
|
|
'graded_at': datetime.now().isoformat()
|
|
}
|
|
|
|
# ==================== 工具方法 ====================
|
|
|
|
def _detect_question_type(self, question: Dict) -> str:
|
|
"""检测题型"""
|
|
if 'options' in question and question['options']:
|
|
return 'choice'
|
|
elif 'reference_answer' in question:
|
|
return 'short_answer'
|
|
else:
|
|
return 'blank'
|
|
|
|
def _get_correct_answer(self, question: Dict) -> str:
|
|
"""获取正确答案（统一为字符串）"""
|
|
if 'reference_answer' in question:
|
|
return json.dumps(question['reference_answer'], ensure_ascii=False)
|
|
return question.get('answer', '')
|
|
|
|
def _get_score(self, question: Dict) -> int:
|
|
"""获取分值"""
|
|
if 'score' in question:
|
|
return question['score']
|
|
if 'reference_answer' in question:
|
|
return question['reference_answer'].get('total_score', 10)
|
|
return 2 # 默认选择题2分
|
|
|
|
def _row_to_question(self, row) -> Dict:
|
|
"""数据库行转题目字典"""
|
|
return {
|
|
'id': row['id'],
|
|
'question_type': row['question_type'],
|
|
'content': row['content'],
|
|
'options': json.loads(row['options']) if row['options'] else [],
|
|
'correct_answer': row['correct_answer'],
|
|
'analysis': row['analysis'],
|
|
'knowledge_points': json.loads(row['knowledge_points']) if row['knowledge_points'] else [],
|
|
'difficulty': row['difficulty'],
|
|
'score': row['score'],
|
|
'source_file': row['source_file'],
|
|
'source_collection': row['source_collection'],
|
|
'source_snippet': json.loads(row['source_snippet']) if row['source_snippet'] else [],
|
|
'source_hash': row['source_hash'],
|
|
'status': row['status'],
|
|
'created_at': row['created_at'],
|
|
'created_by': row['created_by']
|
|
}
|
|
|
|
def _row_to_answer(self, row) -> Dict:
|
|
"""数据库行转答案字典"""
|
|
return {
|
|
'id': row['id'],
|
|
'exam_id': row['exam_id'],
|
|
'student_id': row['student_id'],
|
|
'question_id': row['question_id'],
|
|
'question_type': row['question_type'],
|
|
'student_answer': row['student_answer'],
|
|
'score': row['score'],
|
|
'max_score': row['max_score'],
|
|
'feedback': row['feedback'],
|
|
'score_details': json.loads(row['score_details']) if row['score_details'] else {},
|
|
'submitted_at': row['submitted_at'],
|
|
'graded_at': row['graded_at']
|
|
}
|
|
|
|
# ==================== 统计功能 ====================
|
|
|
|
def get_stats(self) -> Dict:
|
|
"""获取数据库统计"""
|
|
with get_connection("exam") as conn:
|
|
cursor = conn.cursor()
|
|
|
|
stats = {}
|
|
|
|
cursor.execute('SELECT COUNT(*) FROM questions')
|
|
stats['total_questions'] = cursor.fetchone()[0]
|
|
|
|
cursor.execute('SELECT COUNT(*) FROM exams')
|
|
stats['total_exams'] = cursor.fetchone()[0]
|
|
|
|
cursor.execute('SELECT COUNT(*) FROM student_answers')
|
|
stats['total_answers'] = cursor.fetchone()[0]
|
|
|
|
cursor.execute('SELECT COUNT(*) FROM grade_reports')
|
|
stats['total_reports'] = cursor.fetchone()[0]
|
|
|
|
# 按题型统计
|
|
cursor.execute('SELECT question_type, COUNT(*) FROM questions GROUP BY question_type')
|
|
stats['by_type'] = dict(cursor.fetchall())
|
|
|
|
# 按来源文件统计
|
|
cursor.execute('SELECT source_file, COUNT(*) FROM questions GROUP BY source_file')
|
|
stats['by_source'] = dict(cursor.fetchall())
|
|
|
|
return stats
|
|
|
|
def clear_all(self):
|
|
"""清空所有数据（慎用）"""
|
|
with get_connection("exam") as conn:
|
|
cursor = conn.cursor()
|
|
|
|
cursor.execute('DELETE FROM grade_reports')
|
|
cursor.execute('DELETE FROM student_answers')
|
|
cursor.execute('DELETE FROM exam_questions')
|
|
cursor.execute('DELETE FROM exams')
|
|
cursor.execute('DELETE FROM questions')
|
|
|
|
logger.info("已清空所有数据")
|
|
|
|
|
|
# ==================== 命令行测试 ====================
|
|
|
|
if __name__ == '__main__':
|
|
db = ExamLocalDB()
|
|
|
|
print("\n" + "=" * 50)
|
|
print("本地出题批卷数据库测试")
|
|
print("=" * 50)
|
|
|
|
# 显示统计
|
|
stats = db.get_stats()
|
|
print(f"\n当前统计:")
|
|
print(f" 题目总数: {stats['total_questions']}")
|
|
print(f" 试卷总数: {stats['total_exams']}")
|
|
print(f" 答卷总数: {stats['total_answers']}")
|
|
print(f" 报告总数: {stats['total_reports']}")
|
|
|
|
if stats['by_type']:
|
|
print(f"\n按题型统计:")
|
|
for t, c in stats['by_type'].items():
|
|
print(f" {t}: {c}")
|
|
|
|
if stats['by_source']:
|
|
print(f"\n按来源文件统计:")
|
|
for f, c in stats['by_source'].items():
|
|
print(f" {f}: {c}")
|