naman_panwar_gnpl/pragativeer-v2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix(cbt): comprehensive overhaul of CBT & DPP test pipelines, JSON schemas, active states, and exam pattern filters

Browse Source
This commit is contained in:
ectasy663
2026-09-25 18:12:06 +05:30
parent ed1084bd8d
commit 8a5ea57feb
4 changed files with 222 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files

178
backend/main.py
View File

@@ -443,21 +443,28 @@ def login(payload: LoginPayload, session: Session = Depends(get_session)):
def list_active_tests(exam_pattern: Optional[str] = None, type: Optional[str] = None, session: Session = Depends(get_session), current_user: models.User = Depends(get_current_user)):
query = select(models.Test).where(models.Test.is_active == True)
if exam_pattern:
if exam_pattern == 'JEE_NEET':
pattern_str = str(exam_pattern).strip()
if pattern_str in ['JEE_NEET', 'ALL', 'All']:
pass
elif exam_pattern == 'JEE':
query = query.where(models.Test.exam_pattern.in_([models.ExamEnum.JEE_MAIN, models.ExamEnum.JEE_ADVANCED]))
elif pattern_str in ['JEE', 'JEE_Main', 'JEE_MAIN', 'JEE Main', 'JEE_Advanced', 'JEE_ADVANCED', 'JEE Advanced']:
query = query.where(models.Test.exam_pattern.in_([models.ExamEnum.JEE_MAIN, models.ExamEnum.JEE_ADVANCED, models.ExamEnum.JEE_NEET]))
elif pattern_str in ['NEET']:
query = query.where(models.Test.exam_pattern.in_([models.ExamEnum.NEET, models.ExamEnum.JEE_NEET]))
else:
try:
# Find matching enum by value string (e.g. "JEE_Main")
enum_val = models.ExamEnum(exam_pattern)
query = query.where(models.Test.exam_pattern == enum_val)
enum_val = models.ExamEnum(pattern_str)
query = query.where(models.Test.exam_pattern.in_([enum_val, models.ExamEnum.JEE_NEET]))
except ValueError:
pass
if type:
if type in ["Mock", "CBT"]:
query = query.where(models.Test.type.in_(["Mock", "CBT"]))
elif type in ["DPS", "DPP"]:
query = query.where(models.Test.type.in_(["DPS", "DPP"]))
else:
query = query.where(models.Test.type == type)
else:
query = query.where(models.Test.type != "DPS")
query = query.where(models.Test.type.not_in(["DPS", "DPP"]))
return session.exec(query).all()
@app.get("/api/tests/{test_id}", response_model=models.Test, tags=["CBT Engine"])
@@ -1303,26 +1310,30 @@ def get_admin_tests(session: Session = Depends(get_session), current_user: model
return tests
class ManualQuestionInput(BaseModel):
section: str = "General"
subject: str
topic: str
subtopic: str
difficulty: str
type: str
question_text: str
options: Optional[Dict[str, Any]] = None
correct_answer: Dict[str, Any]
solution_text: str
language: str
section: Optional[str] = "General"
subject: Optional[str] = "General"
topic: Optional[str] = "General"
subtopic: Optional[str] = "General"
difficulty: Optional[str] = "Medium"
type: Optional[str] = "MCQ_Single"
question_text: Optional[str] = None
question: Optional[str] = None
options: Optional[Any] = None
options_hi: Optional[Any] = None
correct_answer: Optional[Any] = None
solution_text: Optional[str] = None
solution: Optional[str] = None
explanation: Optional[str] = None
language: Optional[str] = "English"
class ManualTestCreate(BaseModel):
title: str
type: str = "CBT"
type: str = "Mock"
exam_pattern: str
time_limit: int
scheduled_date: Optional[datetime] = None
end_date: Optional[datetime] = None
admin_id: UUID
admin_id: Optional[UUID] = None
questions_json: List[ManualQuestionInput]
@app.post("/api/admin/tests/upload", tags=["Admin"])
@@ -1332,7 +1343,7 @@ async def upload_admin_test(
exam_pattern: str = Form(...),
time_limit: int = Form(...),
scheduled_date: Optional[datetime] = Form(None),
admin_id: UUID = Form(...),
admin_id: Optional[UUID] = Form(None),
session: Session = Depends(get_session),
current_user: models.User = Depends(get_current_user),
):
@@ -1344,6 +1355,24 @@ async def upload_admin_test(
import storage
import uuid
# Safe pattern normalization
pat_str = str(exam_pattern).strip()
if pat_str in ["JEE", "JEE_MAIN", "JEE Main", "JEE_Main"]:
pat_enum = models.ExamEnum.JEE_MAIN
elif pat_str in ["JEE_ADVANCED", "JEE Advanced", "JEE_Advanced"]:
pat_enum = models.ExamEnum.JEE_ADVANCED
elif pat_str in ["NEET"]:
pat_enum = models.ExamEnum.NEET
elif pat_str in ["JEE_NEET", "JEE & NEET"]:
pat_enum = models.ExamEnum.JEE_NEET
else:
try:
pat_enum = models.ExamEnum(pat_str)
except ValueError:
pat_enum = models.ExamEnum.JEE_MAIN
effective_admin_id = admin_id or uuid.UUID("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
pdf_bytes = await file.read()
current_year = datetime.utcnow().year
object_name = f"tests/{current_year}/{uuid.uuid4()}_{file.filename}"
@@ -1354,28 +1383,19 @@ async def upload_admin_test(
test_obj = models.Test(
title=title,
type="DPS",
exam_pattern=models.ExamEnum(exam_pattern),
exam_pattern=pat_enum,
sections={},
total_time=time_limit,
difficulty="Medium",
scheduled_date=scheduled_date,
is_active=False,
created_by=admin_id,
is_active=True,
created_by=effective_admin_id,
pdf_url=url
)
session.add(test_obj)
session.commit()
session.refresh(test_obj)
# Phase 2: Uncomment below to trigger AI question extraction from PDF
# from worker import process_pdf_test
# process_pdf_test.delay(
# test_id_str=str(test_obj.id),
# object_name=object_name,
# admin_id_str=str(admin_id),
# exam_pattern=exam_pattern
# )
return {
"status": "uploaded",
"test_id": test_obj.id,
@@ -1388,18 +1408,37 @@ def create_manual_test(
session: Session = Depends(get_session), current_user: models.User = Depends(get_current_user)
):
import uuid
# Safe pattern normalization
pat_str = str(data.exam_pattern).strip()
if pat_str in ["JEE", "JEE_MAIN", "JEE Main", "JEE_Main"]:
pat_enum = models.ExamEnum.JEE_MAIN
elif pat_str in ["JEE_ADVANCED", "JEE Advanced", "JEE_Advanced"]:
pat_enum = models.ExamEnum.JEE_ADVANCED
elif pat_str in ["NEET"]:
pat_enum = models.ExamEnum.NEET
elif pat_str in ["JEE_NEET", "JEE & NEET"]:
pat_enum = models.ExamEnum.JEE_NEET
else:
try:
pat_enum = models.ExamEnum(pat_str)
except ValueError:
pat_enum = models.ExamEnum.JEE_MAIN
effective_admin_id = data.admin_id or uuid.UUID("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
# 1. Create the test object
test_obj = models.Test(
title=data.title,
type=data.type,
exam_pattern=models.ExamEnum(data.exam_pattern),
exam_pattern=pat_enum,
sections={},
total_time=data.time_limit,
difficulty="Medium",
scheduled_date=data.scheduled_date,
end_date=data.end_date,
is_active=True,
created_by=data.admin_id
created_by=effective_admin_id
)
session.add(test_obj)
@@ -1407,22 +1446,67 @@ def create_manual_test(
sections_dict = {}
for q_data in data.questions_json:
# Extract text with fallbacks
q_text = q_data.question_text or q_data.question or "Question"
sol_text = q_data.solution_text or q_data.solution or q_data.explanation or "Detailed solution will be available after review."
subj = q_data.subject or "General"
top = q_data.topic or subj
subtop = q_data.subtopic or top
diff = q_data.difficulty or "Medium"
# Normalize question type safely
t_raw = str(q_data.type or "MCQ_Single").strip()
if t_raw in ["Single_Choice", "MCQ", "Single", "MCQ_Single"]:
q_type = models.QuestionTypeEnum.MCQ_SINGLE
elif t_raw in ["Multiple_Choice", "Multiple", "MCQ_Multiple"]:
q_type = models.QuestionTypeEnum.MCQ_MULTIPLE
elif t_raw in ["Numerical", "Subjective", "Integer"]:
q_type = models.QuestionTypeEnum.NUMERICAL
else:
try:
q_type = models.QuestionTypeEnum(t_raw)
except ValueError:
q_type = models.QuestionTypeEnum.MCQ_SINGLE
# Normalize language
l_raw = str(q_data.language or "English").strip().capitalize()
if l_raw not in ["English", "Hindi", "Bilingual"]:
l_raw = "English"
lang_enum = models.MediumEnum(l_raw)
# Normalize options
opts = q_data.options
if isinstance(opts, list):
opts = {chr(65 + i): str(v) for i, v in enumerate(opts)}
opts_hi = q_data.options_hi
if isinstance(opts_hi, list):
opts_hi = {chr(65 + i): str(v) for i, v in enumerate(opts_hi)}
# Normalize correct_answer
ca = q_data.correct_answer
if not isinstance(ca, dict):
ca = {"value": ca if ca is not None else "A"}
elif "value" not in ca:
ca = {"value": ca.get("correct") or ca.get("answer") or "A"}
q_obj = models.Question(
subject=q_data.subject,
topic=q_data.topic,
subtopic=q_data.subtopic,
difficulty=q_data.difficulty,
type=models.QuestionTypeEnum(q_data.type),
question_text=q_data.question_text,
options=q_data.options,
correct_answer=q_data.correct_answer,
solution_text=q_data.solution_text,
language=models.MediumEnum(q_data.language),
created_by=data.admin_id
subject=subj,
topic=top,
subtopic=subtop,
difficulty=diff,
type=q_type,
question_text=q_text,
options=opts,
options_hi=opts_hi,
correct_answer=ca,
solution_text=sol_text,
language=lang_enum,
created_by=effective_admin_id
)
session.add(q_obj)
sec_name = q_data.section
sec_name = q_data.section or subj or "General"
if sec_name not in sections_dict:
sections_dict[sec_name] = {
"name": sec_name,

91
src/app/admin/tests/page.tsx
View File

@@ -14,23 +14,88 @@ import { z } from "zod"
import { useActiveUser } from "@/hooks/useActiveUser"
// Strict Zod schema for client-side validation
const QuestionSchema = z.object({
// Permissive, auto-normalizing Zod schema for client-side question parsing
const QuestionSchema = z.preprocess((val: any) => {
if (typeof val !== "object" || val === null) return val;
const q = { ...val };
// Normalize question text
if (!q.question_text && q.question) {
q.question_text = q.question;
}
// Normalize solution text
if (!q.solution_text && (q.solution || q.explanation)) {
q.solution_text = q.solution || q.explanation;
}
if (!q.solution_text) {
q.solution_text = "Detailed solution will be available after review.";
}
// Normalize topic / subtopic / subject / difficulty
if (!q.subject) q.subject = "General";
if (!q.topic) q.topic = q.subject || "General";
if (!q.subtopic) q.subtopic = q.topic || "General";
if (!q.difficulty) q.difficulty = "Medium";
if (!q.section) q.section = q.subject || "General";
// Normalize question type
const typeStr = String(q.type || "").trim();
if (["Single_Choice", "MCQ", "Single", "MCQ_Single"].includes(typeStr)) {
q.type = "MCQ_Single";
} else if (["Multiple_Choice", "Multiple", "MCQ_Multiple"].includes(typeStr)) {
q.type = "MCQ_Multiple";
} else if (["Numerical", "Subjective", "Integer"].includes(typeStr)) {
q.type = "Numerical";
} else {
q.type = "MCQ_Single";
}
// Normalize language
const langStr = String(q.language || "").trim().toLowerCase();
if (langStr === "hindi") q.language = "Hindi";
else if (langStr === "bilingual") q.language = "Bilingual";
else q.language = "English";
// Normalize options if passed as an array
if (Array.isArray(q.options)) {
const optsObj: Record<string, string> = {};
q.options.forEach((opt: any, idx: number) => {
const letter = String.fromCharCode(65 + idx);
optsObj[letter] = String(opt);
});
q.options = optsObj;
}
// Normalize correct_answer format
if (typeof q.correct_answer === "string" || typeof q.correct_answer === "number") {
q.correct_answer = { value: String(q.correct_answer) };
} else if (Array.isArray(q.correct_answer)) {
q.correct_answer = { value: q.correct_answer.map(String) };
} else if (typeof q.correct_answer === "object" && q.correct_answer !== null) {
const val = q.correct_answer.value ?? q.correct_answer.correct ?? q.correct_answer.answer ?? "A";
q.correct_answer = { value: val };
} else {
q.correct_answer = { value: "A" };
}
return q;
}, z.object({
id: z.string().optional(),
section: z.string().default("General"),
subject: z.string(),
topic: z.string(),
subtopic: z.string(),
difficulty: z.string(),
subject: z.string().default("General"),
topic: z.string().default("General"),
subtopic: z.string().default("General"),
difficulty: z.string().default("Medium"),
type: z.enum(["MCQ_Single", "MCQ_Multiple", "Numerical"]),
question_text: z.string(),
question_text: z.string().min(1, "Question text is required"),
options: z.record(z.string(), z.any()).nullable().optional(),
correct_answer: z.object({
value: z.any()
}),
solution_text: z.string(),
language: z.enum(["English", "Hindi", "Bilingual"])
}).passthrough();
}).passthrough());
const TestSchema = z.array(QuestionSchema);
@@ -173,13 +238,14 @@ export default function AdminTestsPage() {
const handleUpload = async (e: React.FormEvent) => {
e.preventDefault()
const effectiveAdminId = userId && userId !== "admin" ? userId : "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
if (testType === 'DPP_PDF') {
const file = fileInputRef.current?.files?.[0]
if (!file) {
alert("Please select a PDF file to upload to Minio.")
return
}
if (!userId) return
setUploading(true)
try {
const formData = new FormData()
@@ -187,7 +253,7 @@ export default function AdminTestsPage() {
formData.append("title", title)
formData.append("exam_pattern", examPattern)
formData.append("time_limit", timeLimit)
formData.append("admin_id", userId === "admin" ? "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa" : (userId as string))
formData.append("admin_id", effectiveAdminId)
if (scheduledDate) formData.append("scheduled_date", scheduledDate.toISOString())
const res = await fetchWithAuth("/api/admin/tests/upload", {
@@ -215,7 +281,6 @@ export default function AdminTestsPage() {
alert("Please upload a valid JSON file with questions first.")
return
}
if (!userId) return
setUploading(true)
@@ -224,7 +289,7 @@ export default function AdminTestsPage() {
type: testType,
exam_pattern: examPattern,
time_limit: parseInt(timeLimit),
admin_id: userId === "admin" ? "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa" : userId,
admin_id: effectiveAdminId,
questions_json: validQuestions,
scheduled_date: scheduledDate ? scheduledDate.toISOString() : null,
end_date: endDate ? endDate.toISOString() : null,
@@ -449,7 +514,7 @@ export default function AdminTestsPage() {
<div className="space-y-1">
<div className="flex items-center gap-2">
<h3 className="font-semibold">{test.title}</h3>
<Badge variant="outline">{test.exam_pattern.replace("_", " ")}</Badge>
<Badge variant="outline">{test.exam_pattern?.replace("_", " ") || "All"}</Badge>
<Badge variant={test.is_active ? "default" : "secondary"}>
{test.is_active ? "Active" : "Inactive / Processing"}
</Badge>

11
src/app/cbt/[examId]/page.tsx
View File

@@ -119,11 +119,18 @@ export default function CBTExamPage({ params }: { params: Promise<{ examId: stri
setExamType(testData.type);
if (testData.title) setTestName(testData.title);
// Extract all question IDs from sections
// Extract all question IDs from sections safely
const questionIds: string[] = [];
Object.values(testData.sections).forEach((section: any) => {
if (testData.sections) {
const sectionsList = Array.isArray(testData.sections)
? testData.sections
: Object.values(testData.sections);
sectionsList.forEach((section: any) => {
if (section && Array.isArray(section.questions)) {
questionIds.push(...section.questions);
}
});
}
const qRes = await fetchWithAuth(`/api/tests/${examId}/questions`);
if (!qRes.ok) throw new Error("Failed to fetch questions in bulk");

2
src/app/dashboard/cbt/page.tsx
View File

@@ -72,7 +72,7 @@ export default function CBTPage() {
if (selectedPattern === "JEE") {
testsData = testsData.filter((t: any) => t.exam_pattern?.includes("JEE"));
} else if (selectedPattern === "NEET") {
testsData = testsData.filter((t: any) => t.exam_pattern === "NEET");
testsData = testsData.filter((t: any) => t.exam_pattern === "NEET" || t.exam_pattern === "JEE_NEET");
}
setExams(testsData);
}