@hed-hog/lms 0.0.304 → 0.0.306

package/src/exam/exam.service.ts

@@ -0,0 +1,784 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+    BadRequestException,
+    Injectable,
+    NotFoundException,
+} from '@nestjs/common';
+import {
+    CreateExamQuestionDto,
+    OBJECTIVE_EXAM_QUESTION_TYPES,
+    type ExamQuestionType,
+} from './dto/create-exam-question.dto';
+import { CreateExamDto } from './dto/create-exam.dto';
+import { UpdateExamQuestionDto } from './dto/update-exam-question.dto';
+import { UpdateExamDto } from './dto/update-exam.dto';
+
+@Injectable()
+export class ExamService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async list(params: {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+    status?: string;
+  }) {
+    const page = Math.max(Number(params.page) || 1, 1);
+    const pageSize = Math.max(Number(params.pageSize) || 12, 1);
+    const skip = (page - 1) * pageSize;
+
+    const where: any = {};
+
+    if (params.status) {
+      where.status = params.status;
+    }
+
+    if (params.search) {
+      const normalized = params.search.trim();
+      const parsedId = this.parseCodeToId(normalized);
+
+      where.OR = [
+        { title: { contains: normalized, mode: 'insensitive' } },
+        { description: { contains: normalized, mode: 'insensitive' } },
+        { instructions: { contains: normalized, mode: 'insensitive' } },
+      ];
+
+      if (parsedId !== null) {
+        where.OR.push({ id: parsedId });
+      }
+    }
+
+    const [exams, total] = await Promise.all([
+      this.prisma.exam.findMany({
+        skip,
+        take: pageSize,
+        where,
+        orderBy: { created_at: 'desc' },
+        include: {
+          _count: {
+            select: {
+              exam_question: true,
+              exam_attempt: true,
+            },
+          },
+        },
+      }),
+      this.prisma.exam.count({ where }),
+    ]);
+
+    const avgScores = await this.findAverageScoresByExam(
+      exams.map((exam) => exam.id),
+    );
+
+    return {
+      total,
+      page,
+      pageSize,
+      lastPage: Math.max(1, Math.ceil(total / pageSize)),
+      data: exams.map((exam) => this.mapExam(exam, avgScores[exam.id] ?? 0)),
+    };
+  }
+
+  async stats() {
+    const [totalExams, publishedExams, totalQuestions, avgScore] =
+      await Promise.all([
+        this.prisma.exam.count(),
+        this.prisma.exam.count({ where: { status: 'published' } }),
+        this.prisma.exam_question.count(),
+        this.prisma.exam_attempt.aggregate({
+          _avg: { score: true },
+          where: { score: { not: null } },
+        }),
+      ]);
+
+    return {
+      totalExams,
+      publishedExams,
+      totalQuestions,
+      overallAverage: this.scoreToTen(avgScore._avg.score ?? 0),
+    };
+  }
+
+  async getById(id: number) {
+    const exam = await this.prisma.exam.findUnique({
+      where: { id },
+      include: {
+        _count: {
+          select: {
+            exam_question: true,
+            exam_attempt: true,
+          },
+        },
+      },
+    });
+
+    if (!exam) return null;
+
+    const avgScores = await this.findAverageScoresByExam([id]);
+    return this.mapExam(exam, avgScores[id] ?? 0);
+  }
+
+  async listQuestions(examId: number) {
+    const exam = await this.prisma.exam.findUnique({
+      where: { id: examId },
+      include: {
+        _count: {
+          select: {
+            exam_question: true,
+          },
+        },
+        exam_question: {
+          orderBy: { order: 'asc' },
+          include: {
+            question: {
+              include: {
+                exam_option: {
+                  orderBy: { position: 'asc' },
+                },
+              },
+            },
+          },
+        },
+      },
+    });
+
+    if (!exam) {
+      throw new NotFoundException('Exam not found');
+    }
+
+    return {
+      exam: {
+        id: exam.id,
+        code: this.idToCode(exam.id),
+        title: exam.title,
+      },
+      questionCount: exam._count.exam_question,
+      data: exam.exam_question.map((item) => this.mapExamQuestion(item)),
+    };
+  }
+
+  async createQuestion(examId: number, dto: CreateExamQuestionDto) {
+    const exam = await this.prisma.exam.findUnique({ where: { id: examId } });
+    if (!exam) {
+      throw new NotFoundException('Exam not found');
+    }
+
+    const last = await this.prisma.exam_question.findFirst({
+      where: { exam_id: examId },
+      orderBy: { order: 'desc' },
+      select: { order: true },
+    });
+    const questionType = this.resolveQuestionType(dto.questionType);
+    const alternatives = this.normalizeAlternatives(
+      questionType,
+      dto.alternatives,
+      true,
+    );
+    const fillBlankAnswers = this.normalizeFillBlankAnswers(
+      questionType,
+      dto.fillBlankAnswers,
+      true,
+    );
+    const matchingPairs = this.normalizeMatchingPairs(
+      questionType,
+      dto.matchingPairs,
+      true,
+    );
+    const specialOptions = this.buildSpecialOptions(
+      questionType,
+      fillBlankAnswers,
+      matchingPairs,
+    );
+
+    const created = await this.prisma.$transaction(async (tx) => {
+      const question = await tx.question.create({
+        data: {
+          question_type: questionType,
+          statement: dto.statement,
+          points: dto.points,
+        },
+      });
+
+      const optionsToPersist =
+        alternatives.length > 0
+          ? alternatives.map((alternative, index) => ({
+              question_id: question.id,
+              option_text: alternative.text,
+              is_correct: alternative.isCorrect,
+              position: index,
+            }))
+          : specialOptions.map((option, index) => ({
+              question_id: question.id,
+              option_text: option.optionText,
+              is_correct: true,
+              position: index,
+            }));
+
+      if (optionsToPersist.length > 0) {
+        await tx.exam_option.createMany({
+          data: optionsToPersist,
+        });
+      }
+
+      const relation = await tx.exam_question.create({
+        data: {
+          exam_id: examId,
+          question_id: question.id,
+          order: (last?.order ?? -1) + 1,
+        },
+      });
+
+      return tx.exam_question.findUnique({
+        where: { id: relation.id },
+        include: {
+          question: {
+            include: {
+              exam_option: {
+                orderBy: { position: 'asc' },
+              },
+            },
+          },
+        },
+      });
+    });
+
+    return this.mapExamQuestion(created);
+  }
+
+  async updateQuestion(
+    examId: number,
+    questionId: number,
+    dto: UpdateExamQuestionDto,
+  ) {
+    const relation = await this.prisma.exam_question.findFirst({
+      where: {
+        exam_id: examId,
+        question_id: questionId,
+      },
+      select: {
+        id: true,
+        question_id: true,
+        question: {
+          select: {
+            question_type: true,
+          },
+        },
+      },
+    });
+
+    if (!relation) {
+      throw new NotFoundException('Question not found in exam');
+    }
+
+    const nextQuestionType = this.resolveQuestionType(
+      dto.questionType ?? relation.question.question_type,
+    );
+    const shouldReplaceAlternatives =
+      dto.alternatives !== undefined ||
+      nextQuestionType !== relation.question.question_type;
+    const alternatives = shouldReplaceAlternatives
+      ? this.normalizeAlternatives(
+          nextQuestionType,
+          dto.alternatives,
+          nextQuestionType !== relation.question.question_type,
+        )
+      : null;
+    const shouldReplaceFillBlankAnswers =
+      dto.fillBlankAnswers !== undefined ||
+      nextQuestionType !== relation.question.question_type;
+    const fillBlankAnswers = shouldReplaceFillBlankAnswers
+      ? this.normalizeFillBlankAnswers(
+          nextQuestionType,
+          dto.fillBlankAnswers,
+          nextQuestionType !== relation.question.question_type,
+        )
+      : null;
+    const shouldReplaceMatchingPairs =
+      dto.matchingPairs !== undefined ||
+      nextQuestionType !== relation.question.question_type;
+    const matchingPairs = shouldReplaceMatchingPairs
+      ? this.normalizeMatchingPairs(
+          nextQuestionType,
+          dto.matchingPairs,
+          nextQuestionType !== relation.question.question_type,
+        )
+      : null;
+    const shouldReplaceSpecialOptions =
+      shouldReplaceFillBlankAnswers || shouldReplaceMatchingPairs;
+    const specialOptions = shouldReplaceSpecialOptions
+      ? this.buildSpecialOptions(
+          nextQuestionType,
+          fillBlankAnswers,
+          matchingPairs,
+        )
+      : [];
+
+    const updated = await this.prisma.$transaction(async (tx) => {
+      await tx.question.update({
+        where: { id: relation.question_id },
+        data: {
+          ...(dto.questionType !== undefined && {
+            question_type: nextQuestionType,
+          }),
+          ...(dto.statement !== undefined && { statement: dto.statement }),
+          ...(dto.points !== undefined && { points: dto.points }),
+        },
+      });
+
+      if (shouldReplaceAlternatives || shouldReplaceSpecialOptions) {
+        await tx.exam_option.deleteMany({
+          where: { question_id: relation.question_id },
+        });
+
+        const optionsToPersist = (alternatives?.length ?? 0)
+          ? alternatives!.map((alternative, index) => ({
+              question_id: relation.question_id,
+              option_text: alternative.text,
+              is_correct: alternative.isCorrect,
+              position: index,
+            }))
+          : specialOptions.map((option, index) => ({
+              question_id: relation.question_id,
+              option_text: option.optionText,
+              is_correct: true,
+              position: index,
+            }));
+
+        if (optionsToPersist.length > 0) {
+          await tx.exam_option.createMany({
+            data: optionsToPersist,
+          });
+        }
+      }
+
+      return tx.exam_question.findUnique({
+        where: { id: relation.id },
+        include: {
+          question: {
+            include: {
+              exam_option: {
+                orderBy: { position: 'asc' },
+              },
+            },
+          },
+        },
+      });
+    });
+
+    return this.mapExamQuestion(updated);
+  }
+
+  async removeQuestion(examId: number, questionId: number) {
+    await this.prisma.exam_question.deleteMany({
+      where: {
+        exam_id: examId,
+        question_id: questionId,
+      },
+    });
+
+    const remaining = await this.prisma.exam_question.findMany({
+      where: { exam_id: examId },
+      orderBy: { order: 'asc' },
+      select: { id: true },
+    });
+
+    await Promise.all(
+      remaining.map((item, index) =>
+        this.prisma.exam_question.update({
+          where: { id: item.id },
+          data: { order: index },
+        }),
+      ),
+    );
+
+    return { success: true };
+  }
+
+  async reorderQuestions(examId: number, questionIds: number[]) {
+    const relations = await this.prisma.exam_question.findMany({
+      where: { exam_id: examId },
+      select: { question_id: true, id: true },
+    });
+
+    const existingQuestionIds = new Set(relations.map((item) => item.question_id));
+    const receivedQuestionIds = new Set(questionIds);
+
+    if (
+      existingQuestionIds.size !== receivedQuestionIds.size ||
+      !questionIds.every((id) => existingQuestionIds.has(id))
+    ) {
+      return { success: false };
+    }
+
+    const byQuestionId = new Map(relations.map((item) => [item.question_id, item.id]));
+
+    await this.prisma.$transaction(
+      questionIds.map((questionId, index) =>
+        this.prisma.exam_question.update({
+          where: { id: byQuestionId.get(questionId)! },
+          data: { order: index },
+        }),
+      ),
+    );
+
+    return { success: true };
+  }
+
+  async create(dto: CreateExamDto) {
+    const exam = await this.prisma.exam.create({
+      data: {
+        title: dto.title,
+        exam_type: 'test',
+        status: dto.status ?? 'draft',
+        min_score: this.scoreFromTen(dto.minScore ?? 7),
+        time_limit_minutes: dto.timeLimit ?? 60,
+        shuffle_questions: dto.shuffle ?? false,
+        ...(dto.primaryColor !== undefined && {
+          primary_color: dto.primaryColor,
+        }),
+        ...(dto.secondaryColor !== undefined && {
+          secondary_color: dto.secondaryColor,
+        }),
+      },
+      include: {
+        _count: {
+          select: {
+            exam_question: true,
+            exam_attempt: true,
+          },
+        },
+      },
+    });
+
+    return this.mapExam(exam, 0);
+  }
+
+  async update(id: number, dto: UpdateExamDto) {
+    const exam = await this.prisma.exam.update({
+      where: { id },
+      data: {
+        ...(dto.title !== undefined && { title: dto.title }),
+        ...(dto.status !== undefined && { status: dto.status }),
+        ...(dto.minScore !== undefined && {
+          min_score: this.scoreFromTen(dto.minScore),
+        }),
+        ...(dto.timeLimit !== undefined && {
+          time_limit_minutes: dto.timeLimit,
+        }),
+        ...(dto.shuffle !== undefined && {
+          shuffle_questions: dto.shuffle,
+        }),
+        ...(dto.primaryColor !== undefined && {
+          primary_color: dto.primaryColor,
+        }),
+        ...(dto.secondaryColor !== undefined && {
+          secondary_color: dto.secondaryColor,
+        }),
+      },
+      include: {
+        _count: {
+          select: {
+            exam_question: true,
+            exam_attempt: true,
+          },
+        },
+      },
+    });
+
+    const avgScores = await this.findAverageScoresByExam([id]);
+    return this.mapExam(exam, avgScores[id] ?? 0);
+  }
+
+  async remove(id: number) {
+    await this.prisma.exam.delete({ where: { id } });
+    return { success: true };
+  }
+
+  private async findAverageScoresByExam(examIds: number[]) {
+    if (examIds.length === 0) return {} as Record<number, number>;
+
+    const grouped = await this.prisma.exam_attempt.groupBy({
+      by: ['exam_id'],
+      where: {
+        exam_id: { in: examIds },
+        score: { not: null },
+      },
+      _avg: { score: true },
+    });
+
+    return grouped.reduce(
+      (acc, item) => {
+        acc[item.exam_id] = this.scoreToTen(item._avg.score ?? 0);
+        return acc;
+      },
+      {} as Record<number, number>,
+    );
+  }
+
+  private mapExam(exam: any, averageScore: number) {
+    return {
+      id: exam.id,
+      code: this.idToCode(exam.id),
+      title: exam.title,
+      minScore: this.scoreToTen(exam.min_score ?? 0),
+      timeLimit: exam.time_limit_minutes ?? 0,
+      shuffle: Boolean(exam.shuffle_questions),
+      status: exam.status,
+      questions: exam._count?.exam_question ?? 0,
+      attempts: exam._count?.exam_attempt ?? 0,
+      averageScore,
+      primaryColor: exam.primary_color ?? null,
+      primaryContrastColor: exam.primary_contrast_color ?? null,
+      secondaryColor: exam.secondary_color ?? null,
+      secondaryContrastColor: exam.secondary_contrast_color ?? null,
+      createdAt: exam.created_at,
+    };
+  }
+
+  private mapExamQuestion(item: any) {
+    const questionType = this.resolveQuestionType(item.question.question_type);
+    const parsedOptions = this.parseSpecialOptions(item.question.exam_option ?? []);
+
+    return {
+      id: item.question.id,
+      examQuestionId: item.id,
+      order: item.order,
+      questionType,
+      statement: item.question.statement,
+      points: item.question.points,
+      fillBlankAnswers: parsedOptions.fillBlankAnswers,
+      matchingPairs: parsedOptions.matchingPairs,
+      alternatives: OBJECTIVE_EXAM_QUESTION_TYPES.includes(questionType)
+        ? (item.question.exam_option ?? []).map((option: any) => ({
+            id: option.id,
+            text: option.option_text,
+            isCorrect: Boolean(option.is_correct),
+          }))
+        : [],
+    };
+  }
+
+  private parseCodeToId(value: string) {
+    const normalized = value.trim();
+
+    if (/^\d+$/.test(normalized)) {
+      return Number(normalized);
+    }
+
+    const codeMatch = normalized.match(/^ex[-_\s]?0*(\d+)$/i);
+    if (!codeMatch) return null;
+
+    return Number(codeMatch[1]);
+  }
+
+  private idToCode(id: number) {
+    return `EX-${String(id).padStart(3, '0')}`;
+  }
+
+  private scoreToTen(score: number) {
+    if (!score) return 0;
+    return score > 10 ? Number((score / 10).toFixed(1)) : Number(score.toFixed(1));
+  }
+
+  private scoreFromTen(score: number) {
+    if (score > 10) return Math.round(score);
+    return Math.round(score * 10);
+  }
+
+  private resolveQuestionType(questionType?: string): ExamQuestionType {
+    return (questionType as ExamQuestionType | undefined) ?? 'multiple_choice';
+  }
+
+  private normalizeAlternatives(
+    questionType: ExamQuestionType,
+    alternatives: CreateExamQuestionDto['alternatives'],
+    requireOnObjective: boolean,
+  ) {
+    if (!OBJECTIVE_EXAM_QUESTION_TYPES.includes(questionType)) {
+      return [];
+    }
+
+    if (!alternatives || alternatives.length < 2) {
+      if (requireOnObjective) {
+        throw new BadRequestException(
+          'Objective questions require at least 2 alternatives',
+        );
+      }
+
+      return [];
+    }
+
+    const normalized = alternatives.map((alternative) => ({
+      text: alternative.text.trim(),
+      isCorrect: Boolean(alternative.isCorrect),
+    }));
+
+    if (normalized.some((alternative) => alternative.text.length === 0)) {
+      throw new BadRequestException('All alternatives must have text');
+    }
+
+    const correctCount = normalized.filter(
+      (alternative) => alternative.isCorrect,
+    ).length;
+
+    if (correctCount === 0) {
+      throw new BadRequestException(
+        'Objective questions require at least 1 correct alternative',
+      );
+    }
+
+    if (questionType === 'true_false' && normalized.length !== 2) {
+      throw new BadRequestException(
+        'True/false questions require exactly 2 alternatives',
+      );
+    }
+
+    return normalized;
+  }
+
+  private normalizeFillBlankAnswers(
+    questionType: ExamQuestionType,
+    fillBlankAnswers: CreateExamQuestionDto['fillBlankAnswers'],
+    requireOnFillBlank: boolean,
+  ) {
+    if (questionType !== 'fill_blank') {
+      return null;
+    }
+
+    if (!fillBlankAnswers || fillBlankAnswers.length === 0) {
+      if (requireOnFillBlank) {
+        throw new BadRequestException(
+          'Fill-blank questions require at least 1 expected answer',
+        );
+      }
+
+      return [];
+    }
+
+    const normalized = fillBlankAnswers.map((item) => ({
+      answer: item.answer.trim(),
+      alternatives: (item.alternatives ?? [])
+        .map((alternative) => alternative.trim())
+        .filter((alternative) => alternative.length > 0),
+    }));
+
+    if (normalized.some((item) => item.answer.length === 0)) {
+      throw new BadRequestException(
+        'Fill-blank expected answers cannot be empty',
+      );
+    }
+
+    return normalized;
+  }
+
+  private normalizeMatchingPairs(
+    questionType: ExamQuestionType,
+    matchingPairs: CreateExamQuestionDto['matchingPairs'],
+    requireOnMatching: boolean,
+  ) {
+    if (questionType !== 'matching') {
+      return null;
+    }
+
+    if (!matchingPairs || matchingPairs.length < 2) {
+      if (requireOnMatching) {
+        throw new BadRequestException(
+          'Matching questions require at least 2 pairs',
+        );
+      }
+
+      return [];
+    }
+
+    const normalized = matchingPairs.map((pair, index) => ({
+      id: pair.id.trim() || `pair-${index + 1}`,
+      leftText: pair.leftText.trim(),
+      rightText: pair.rightText.trim(),
+    }));
+
+    if (
+      normalized.some(
+        (pair) => pair.leftText.length === 0 || pair.rightText.length === 0,
+      )
+    ) {
+      throw new BadRequestException('Matching pair texts cannot be empty');
+    }
+
+    const uniqueIds = new Set(normalized.map((pair) => pair.id));
+    if (uniqueIds.size !== normalized.length) {
+      throw new BadRequestException('Matching pair ids must be unique');
+    }
+
+    return normalized;
+  }
+
+  private buildSpecialOptions(
+    questionType: ExamQuestionType,
+    fillBlankAnswers: Array<{ answer: string; alternatives: string[] }> | null,
+    matchingPairs: Array<{ id: string; leftText: string; rightText: string }> | null,
+  ) {
+    if (questionType === 'fill_blank') {
+      return (fillBlankAnswers ?? []).map((item) => ({
+        optionText: JSON.stringify({
+          kind: 'fill_blank',
+          answer: item.answer,
+          alternatives: item.alternatives,
+        }),
+      }));
+    }
+
+    if (questionType === 'matching') {
+      return (matchingPairs ?? []).map((pair) => ({
+        optionText: JSON.stringify({
+          kind: 'matching',
+          id: pair.id,
+          leftText: pair.leftText,
+          rightText: pair.rightText,
+        }),
+      }));
+    }
+
+    return [] as Array<{ optionText: string }>;
+  }
+
+  private parseSpecialOptions(options: any[]) {
+    const fillBlankAnswers: Array<{ answer: string; alternatives?: string[] }> = [];
+    const matchingPairs: Array<{ id: string; leftText: string; rightText: string }> = [];
+
+    for (const option of options) {
+      try {
+        const parsed = JSON.parse(option.option_text);
+
+        if (parsed?.kind === 'fill_blank' && typeof parsed.answer === 'string') {
+          fillBlankAnswers.push({
+            answer: parsed.answer,
+            alternatives: Array.isArray(parsed.alternatives)
+              ? parsed.alternatives
+              : [],
+          });
+          continue;
+        }
+
+        if (
+          parsed?.kind === 'matching' &&
+          typeof parsed.id === 'string' &&
+          typeof parsed.leftText === 'string' &&
+          typeof parsed.rightText === 'string'
+        ) {
+          matchingPairs.push({
+            id: parsed.id,
+            leftText: parsed.leftText,
+            rightText: parsed.rightText,
+          });
+        }
+      } catch {
+        // ignore non-JSON options used by objective questions
+      }
+    }
+
+    return {
+      fillBlankAnswers,
+      matchingPairs,
+    };
+  }
+}