feat: complete exam lifecycle — AI generation, submission, student session, and results

- Backend: AI generation fallbacks when OpenAI not configured, full exam
  submission saving all params (difficulty, rubric, entity, grading system,
  approval workflow) and creating linked question records per section
- Backend: new exam session controller with get_session, autosave, submit,
  status, and results endpoints; student attempt/answer/score models
- Backend: new controllers for entities, approval workflows, exam schedules
- Frontend: exam session split-layout with passage panel, question types
  (MCQ, T/F/NG, gap-fill, writing, speaking), timer, and review dialog
- Frontend: results page with percentage score, per-answer breakdown table
- Frontend: generation page dynamic dropdowns, full payload submission
- Frontend: updated types for ExamSessionSection, ExamQuestion options

Made-with: Cursor

frontend/src/services/assignments.service.ts

@@ -1,11 +1,26 @@
 import { api } from "@/lib/api-client";
-import type { Assignment, AssignmentState, AssignmentCreateRequest, PaginatedResponse, PaginationParams, ApiSuccessResponse } from "@/types";
+import type {
+  Assignment,
+  AssignmentState,
+  AssignmentCreateRequest,
+  ExamSchedule,
+  ExamScheduleCreateRequest,
+  ScheduleState,
+  StudentExamAssignment,
+  PaginatedResponse,
+  PaginationParams,
+  ApiSuccessResponse,
+} from "@/types";
 
 export interface AssignmentListParams extends PaginationParams {
   state?: AssignmentState;
   entity_id?: number;
 }
 
+export interface ScheduleListParams extends PaginationParams {
+  state?: ScheduleState;
+}
+
 export const assignmentsService = {
   async list(params?: AssignmentListParams): Promise<PaginatedResponse<Assignment>> {
     return api.get<PaginatedResponse<Assignment>>("/assignments", params as Record<string, string | number | boolean | undefined>);
@@ -34,4 +49,28 @@ export const assignmentsService = {
   async start(id: number): Promise<Assignment> {
     return api.post<Assignment>(`/assignments/${id}/start`);
   },
+
+  async listSchedules(params?: ScheduleListParams): Promise<PaginatedResponse<ExamSchedule>> {
+    return api.get<PaginatedResponse<ExamSchedule>>("/exam-schedules", params as Record<string, string | number | boolean | undefined>);
+  },
+
+  async createSchedule(data: ExamScheduleCreateRequest): Promise<ExamSchedule> {
+    return api.post<ExamSchedule>("/exam-schedules", data);
+  },
+
+  async updateSchedule(id: number, data: Partial<ExamScheduleCreateRequest & { state: ScheduleState }>): Promise<ExamSchedule> {
+    return api.put<ExamSchedule>(`/exam-schedules/${id}`, data);
+  },
+
+  async deleteSchedule(id: number): Promise<ApiSuccessResponse> {
+    return api.delete<ApiSuccessResponse>(`/exam-schedules/${id}`);
+  },
+
+  async archiveSchedule(id: number): Promise<ExamSchedule> {
+    return api.post<ExamSchedule>(`/exam-schedules/${id}/archive`);
+  },
+
+  async getStudentExams(): Promise<{ items: StudentExamAssignment[] }> {
+    return api.get<{ items: StudentExamAssignment[] }>("/student/my-exams");
+  },
 };

frontend/src/services/exams.service.ts

@@ -40,10 +40,30 @@ export const examsService = {
     return api.post<Rubric>("/rubrics", data);
   },
 
+  async updateRubric(id: number, data: Partial<Rubric>): Promise<Rubric> {
+    return api.put<Rubric>(`/rubrics/${id}`, data);
+  },
+
+  async deleteRubric(id: number): Promise<ApiSuccessResponse> {
+    return api.delete<ApiSuccessResponse>(`/rubrics/${id}`);
+  },
+
   async listRubricGroups(params?: PaginationParams): Promise<PaginatedResponse<RubricGroup>> {
     return api.get<PaginatedResponse<RubricGroup>>("/rubric-groups", params as Record<string, string | number | boolean | undefined>);
   },
 
+  async createRubricGroup(data: { name: string; rubric_ids: number[] }): Promise<RubricGroup> {
+    return api.post<RubricGroup>("/rubric-groups", data);
+  },
+
+  async updateRubricGroup(id: number, data: { name?: string; rubric_ids?: number[] }): Promise<RubricGroup> {
+    return api.put<RubricGroup>(`/rubric-groups/${id}`, data);
+  },
+
+  async deleteRubricGroup(id: number): Promise<ApiSuccessResponse> {
+    return api.delete<ApiSuccessResponse>(`/rubric-groups/${id}`);
+  },
+
   async listStructures(params?: PaginationParams & { entity_id?: number }): Promise<PaginatedResponse<ExamStructure>> {
     return api.get<PaginatedResponse<ExamStructure>>("/exam-structures", params as Record<string, string | number | boolean | undefined>);
   },
@@ -52,10 +72,23 @@ export const examsService = {
     return api.post<ExamStructure>("/exam-structures", data);
   },
 
+  async updateStructure(id: number, data: Partial<ExamStructure>): Promise<ExamStructure> {
+    return api.put<ExamStructure>(`/exam-structures/${id}`, data);
+  },
+
   async deleteStructure(id: number): Promise<ApiSuccessResponse> {
     return api.delete<ApiSuccessResponse>(`/exam-structures/${id}`);
   },
 
+  async suggestRubricCriteria(data: {
+    name?: string;
+    skill: string;
+    exam_type: string;
+    levels: string[];
+  }): Promise<{ criteria: string[]; suggested_levels?: string[] }> {
+    return api.post("/ai/suggest-rubric-criteria", data);
+  },
+
   async getAvatars(): Promise<{ id: number; name: string; thumbnail: string }[]> {
     return api.get("/exam/avatars");
   },

frontend/src/services/generation.service.ts

@@ -137,9 +137,11 @@ export const generationService = {
   submitExam(data: {
     title: string;
     label: string;
+    exam_mode?: string;
+    structure_id?: number;
     modules: Record<string, unknown>;
     skip_approval?: boolean;
-  }): Promise<{ exam_id: number; status: string; template_id?: number }> {
+  }): Promise<{ exam_id: number; status: string; template_id?: number; total_questions?: number }> {
     return api.post("/exam/generation/submit", data);
   },
 };