@hed-hog/lms 0.0.304 → 0.0.306

package/dist/exam/exam-attempt.service.js

@@ -0,0 +1,776 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExamAttemptService = void 0;
+const api_prisma_1 = require("@hed-hog/api-prisma");
+const common_1 = require("@nestjs/common");
+const create_exam_question_dto_1 = require("./dto/create-exam-question.dto");
+let ExamAttemptService = class ExamAttemptService {
+    constructor(prisma) {
+        this.prisma = prisma;
+    }
+    async getAttemptState(examId, userId, explicitStudentId) {
+        const exam = await this.findExamOrThrow(examId);
+        const studentId = await this.resolveStudentId(userId, explicitStudentId);
+        let attempt = await this.findRelevantAttempt(examId, studentId);
+        if (attempt) {
+            attempt = await this.maybeFinalizeExpiredAttempt(exam, attempt);
+        }
+        return this.buildAttemptPayload(exam, studentId, attempt);
+    }
+    async startAttempt(examId, userId, ipAddress, dto) {
+        var _a, _b, _c;
+        const exam = await this.findExamOrThrow(examId);
+        const studentId = await this.resolveStudentId(userId, dto.studentId);
+        let activeAttempt = await this.findActiveAttempt(examId, studentId);
+        if (activeAttempt) {
+            activeAttempt = await this.maybeFinalizeExpiredAttempt(exam, activeAttempt);
+            if (activeAttempt.status === 'in_progress') {
+                return this.buildAttemptPayload(exam, studentId, activeAttempt);
+            }
+        }
+        const usedAttempts = await this.countAttempts(examId, studentId);
+        const attemptsAllowed = Math.max((_a = exam.attempts_allowed) !== null && _a !== void 0 ? _a : 1, 1);
+        if (usedAttempts >= attemptsAllowed) {
+            throw new common_1.BadRequestException('No attempts remaining for this exam');
+        }
+        if (((_b = exam.exam_question) !== null && _b !== void 0 ? _b : []).length === 0) {
+            throw new common_1.BadRequestException('Exam has no questions');
+        }
+        const enrollment = await this.findMatchingEnrollment(exam, studentId);
+        const created = await this.prisma.exam_attempt.create({
+            data: {
+                exam_id: exam.id,
+                student_id: studentId,
+                course_enrollment_id: (_c = enrollment === null || enrollment === void 0 ? void 0 : enrollment.id) !== null && _c !== void 0 ? _c : null,
+                attempt_number: usedAttempts + 1,
+                started_at: new Date(),
+                ip_address: ipAddress || null,
+            },
+            include: {
+                exam_answer: true,
+            },
+        });
+        return this.buildAttemptPayload(exam, studentId, created);
+    }
+    async saveAnswers(examId, attemptId, userId, dto) {
+        const exam = await this.findExamOrThrow(examId);
+        const studentId = await this.resolveStudentId(userId);
+        let attempt = await this.findAttemptOrThrow(examId, attemptId, studentId);
+        attempt = await this.maybeFinalizeExpiredAttempt(exam, attempt);
+        if (attempt.status !== 'in_progress') {
+            return this.buildAttemptPayload(exam, studentId, attempt);
+        }
+        await this.persistAnswers(attempt.id, exam, dto.answers);
+        const updated = await this.findAttemptOrThrow(examId, attemptId, studentId);
+        return this.buildAttemptPayload(exam, studentId, updated);
+    }
+    async submitAttempt(examId, attemptId, userId, dto) {
+        var _a, _b;
+        const exam = await this.findExamOrThrow(examId);
+        const studentId = await this.resolveStudentId(userId);
+        let attempt = await this.findAttemptOrThrow(examId, attemptId, studentId);
+        attempt = await this.maybeFinalizeExpiredAttempt(exam, attempt);
+        if (attempt.status === 'completed') {
+            return this.buildAttemptPayload(exam, studentId, attempt);
+        }
+        await this.persistAnswers(attempt.id, exam, (_a = dto.answers) !== null && _a !== void 0 ? _a : []);
+        const completed = await this.completeAttempt(exam, attempt.id, (_b = dto.force) !== null && _b !== void 0 ? _b : false);
+        return this.buildAttemptPayload(exam, studentId, completed);
+    }
+    async persistAnswers(attemptId, exam, answers) {
+        var _a, _b, _c, _d;
+        const normalizedAnswers = new Map();
+        for (const answer of answers !== null && answers !== void 0 ? answers : []) {
+            normalizedAnswers.set(answer.questionId, {
+                examOptionId: (_a = answer.examOptionId) !== null && _a !== void 0 ? _a : null,
+                answerText: ((_b = answer.answerText) === null || _b === void 0 ? void 0 : _b.trim()) || null,
+                matchingPairs: ((_c = answer.matchingPairs) !== null && _c !== void 0 ? _c : []).map((pair) => {
+                    var _a, _b;
+                    return ({
+                        leftId: String((_a = pair.leftId) !== null && _a !== void 0 ? _a : '').trim(),
+                        rightId: String((_b = pair.rightId) !== null && _b !== void 0 ? _b : '').trim(),
+                    });
+                }),
+            });
+        }
+        const questionsById = new Map(((_d = exam.exam_question) !== null && _d !== void 0 ? _d : []).map((item) => [item.question_id, item]));
+        for (const questionId of normalizedAnswers.keys()) {
+            if (!questionsById.has(questionId)) {
+                throw new common_1.BadRequestException(`Question ${questionId} does not belong to exam`);
+            }
+        }
+        const questionIds = [...normalizedAnswers.keys()];
+        if (questionIds.length === 0) {
+            return;
+        }
+        await this.prisma.$transaction(async (tx) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+            const existingAnswers = await tx.exam_answer.findMany({
+                where: {
+                    exam_attempt_id: attemptId,
+                    question_id: { in: questionIds },
+                },
+                select: {
+                    id: true,
+                    question_id: true,
+                },
+            });
+            const existingByQuestionId = new Map(existingAnswers.map((item) => [item.question_id, item.id]));
+            for (const [questionId, answerValue] of normalizedAnswers.entries()) {
+                const question = questionsById.get(questionId);
+                const existingId = existingByQuestionId.get(questionId);
+                if (!question) {
+                    throw new common_1.BadRequestException(`Question ${questionId} does not belong to exam`);
+                }
+                const questionType = this.resolveQuestionType((_a = question.question) === null || _a === void 0 ? void 0 : _a.question_type);
+                if (questionType === 'essay') {
+                    if (!answerValue.answerText) {
+                        if (existingId) {
+                            await tx.exam_answer.delete({ where: { id: existingId } });
+                        }
+                        continue;
+                    }
+                    const payload = {
+                        exam_option_id: null,
+                        answer_text: answerValue.answerText,
+                        is_correct: null,
+                        points_awarded: 0,
+                    };
+                    if (existingId) {
+                        await tx.exam_answer.update({
+                            where: { id: existingId },
+                            data: payload,
+                        });
+                    }
+                    else {
+                        await tx.exam_answer.create({
+                            data: Object.assign({ exam_attempt_id: attemptId, question_id: questionId }, payload),
+                        });
+                    }
+                    continue;
+                }
+                if (questionType === 'fill_blank') {
+                    if (!answerValue.answerText) {
+                        if (existingId) {
+                            await tx.exam_answer.delete({ where: { id: existingId } });
+                        }
+                        continue;
+                    }
+                    const parsedOptions = this.parseSpecialOptions((_c = (_b = question.question) === null || _b === void 0 ? void 0 : _b.exam_option) !== null && _c !== void 0 ? _c : []);
+                    const expectedAnswers = this.extractFillBlankExpectedAnswers(parsedOptions.fillBlankAnswers);
+                    if (expectedAnswers.length === 0) {
+                        throw new common_1.BadRequestException(`Fill-blank question ${questionId} has no expected answers`);
+                    }
+                    const isCorrect = this.isFillBlankCorrect(answerValue.answerText, expectedAnswers);
+                    const payload = {
+                        exam_option_id: null,
+                        answer_text: answerValue.answerText,
+                        is_correct: isCorrect,
+                        points_awarded: isCorrect ? (_d = question.question.points) !== null && _d !== void 0 ? _d : 0 : 0,
+                    };
+                    if (existingId) {
+                        await tx.exam_answer.update({
+                            where: { id: existingId },
+                            data: payload,
+                        });
+                    }
+                    else {
+                        await tx.exam_answer.create({
+                            data: Object.assign({ exam_attempt_id: attemptId, question_id: questionId }, payload),
+                        });
+                    }
+                    continue;
+                }
+                if (questionType === 'matching') {
+                    const parsedOptions = this.parseSpecialOptions((_f = (_e = question.question) === null || _e === void 0 ? void 0 : _e.exam_option) !== null && _f !== void 0 ? _f : []);
+                    const expectedPairs = this.extractMatchingPairs(parsedOptions.matchingPairs);
+                    if (expectedPairs.length < 2) {
+                        throw new common_1.BadRequestException(`Matching question ${questionId} has no valid pairs`);
+                    }
+                    const sanitizedPairs = answerValue.matchingPairs.filter((pair) => pair.leftId.length > 0 && pair.rightId.length > 0);
+                    if (sanitizedPairs.length === 0) {
+                        if (existingId) {
+                            await tx.exam_answer.delete({ where: { id: existingId } });
+                        }
+                        continue;
+                    }
+                    const isCorrect = this.isMatchingCorrect(sanitizedPairs, expectedPairs);
+                    const payload = {
+                        exam_option_id: null,
+                        answer_text: JSON.stringify({ matchingPairs: sanitizedPairs }),
+                        is_correct: isCorrect,
+                        points_awarded: isCorrect ? (_g = question.question.points) !== null && _g !== void 0 ? _g : 0 : 0,
+                    };
+                    if (existingId) {
+                        await tx.exam_answer.update({
+                            where: { id: existingId },
+                            data: payload,
+                        });
+                    }
+                    else {
+                        await tx.exam_answer.create({
+                            data: Object.assign({ exam_attempt_id: attemptId, question_id: questionId }, payload),
+                        });
+                    }
+                    continue;
+                }
+                if (!answerValue.examOptionId) {
+                    if (existingId) {
+                        await tx.exam_answer.delete({ where: { id: existingId } });
+                    }
+                    continue;
+                }
+                const option = ((_j = (_h = question === null || question === void 0 ? void 0 : question.question) === null || _h === void 0 ? void 0 : _h.exam_option) !== null && _j !== void 0 ? _j : []).find((item) => item.id === answerValue.examOptionId);
+                if (!option) {
+                    throw new common_1.BadRequestException(`Option ${answerValue.examOptionId} does not belong to question ${questionId}`);
+                }
+                const payload = {
+                    exam_option_id: option.id,
+                    answer_text: null,
+                    is_correct: Boolean(option.is_correct),
+                    points_awarded: option.is_correct ? (_k = question.question.points) !== null && _k !== void 0 ? _k : 0 : 0,
+                };
+                if (existingId) {
+                    await tx.exam_answer.update({
+                        where: { id: existingId },
+                        data: payload,
+                    });
+                }
+                else {
+                    await tx.exam_answer.create({
+                        data: Object.assign({ exam_attempt_id: attemptId, question_id: questionId }, payload),
+                    });
+                }
+            }
+        });
+    }
+    async completeAttempt(exam, attemptId, force) {
+        var _a, _b;
+        const currentAttempt = await this.prisma.exam_attempt.findUnique({
+            where: { id: attemptId },
+            include: {
+                exam_answer: true,
+            },
+        });
+        if (!currentAttempt) {
+            throw new common_1.NotFoundException('Attempt not found');
+        }
+        if (currentAttempt.status === 'completed') {
+            return currentAttempt;
+        }
+        const maxPoints = this.getExamMaxPoints(exam);
+        const answeredCount = currentAttempt.exam_answer.length;
+        const questionCount = ((_a = exam.exam_question) !== null && _a !== void 0 ? _a : []).length;
+        if (!force &&
+            exam.require_all_questions_answered_to_finish &&
+            answeredCount < questionCount) {
+            throw new common_1.BadRequestException('All questions must be answered before finishing');
+        }
+        const totalPoints = currentAttempt.exam_answer.reduce((sum, answer) => { var _a; return sum + ((_a = answer.points_awarded) !== null && _a !== void 0 ? _a : 0); }, 0);
+        const maxScore = Math.max((_b = exam.max_score) !== null && _b !== void 0 ? _b : 100, 1);
+        const scaledScore = maxPoints > 0 ? Math.round((totalPoints / maxPoints) * maxScore) : 0;
+        return this.prisma.exam_attempt.update({
+            where: { id: attemptId },
+            data: {
+                status: 'completed',
+                finished_at: new Date(),
+                duration_seconds: Math.max(0, Math.floor((Date.now() - currentAttempt.started_at.getTime()) / 1000)),
+                score: scaledScore,
+            },
+            include: {
+                exam_answer: true,
+            },
+        });
+    }
+    async buildAttemptPayload(exam, studentId, attempt) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const attemptsAllowed = Math.max((_a = exam.attempts_allowed) !== null && _a !== void 0 ? _a : 1, 1);
+        const attemptsUsed = await this.countAttempts(exam.id, studentId);
+        const maxPoints = this.getExamMaxPoints(exam);
+        const questions = this.mapQuestions(exam, (_b = attempt === null || attempt === void 0 ? void 0 : attempt.id) !== null && _b !== void 0 ? _b : exam.id);
+        return {
+            exam: {
+                id: exam.id,
+                title: exam.title,
+                description: exam.description,
+                instructions: exam.instructions,
+                questionCount: questions.length,
+                maxPoints,
+                timeLimitMinutes: exam.time_limit_minutes,
+                passingScore: this.scoreToTen((_c = exam.min_score) !== null && _c !== void 0 ? _c : 0),
+                passingPercent: this.toPercent((_d = exam.min_score) !== null && _d !== void 0 ? _d : 0, (_e = exam.max_score) !== null && _e !== void 0 ? _e : 100),
+                requireAllQuestionsAnsweredToFinish: Boolean(exam.require_all_questions_answered_to_finish),
+                showResult: Boolean((_f = exam.show_result) !== null && _f !== void 0 ? _f : true),
+            },
+            attempts: {
+                allowed: attemptsAllowed,
+                used: attemptsUsed,
+                remaining: Math.max(attemptsAllowed - attemptsUsed, 0),
+                canStart: attemptsUsed < attemptsAllowed,
+            },
+            questions,
+            attempt: attempt
+                ? {
+                    id: attempt.id,
+                    attemptNumber: attempt.attempt_number,
+                    status: attempt.status,
+                    startedAt: attempt.started_at,
+                    finishedAt: attempt.finished_at,
+                    timeRemainingSeconds: this.getRemainingSeconds(exam, attempt),
+                    answeredCount: attempt.exam_answer.length,
+                    answers: ((_g = attempt.exam_answer) !== null && _g !== void 0 ? _g : []).map((answer) => ({
+                        questionId: answer.question_id,
+                        examOptionId: answer.exam_option_id,
+                        answerText: answer.answer_text,
+                        matchingPairs: this.extractMatchingPairsFromAnswerText(answer.answer_text),
+                    })),
+                    result: attempt.status === 'completed'
+                        ? this.mapAttemptResult(exam, attempt)
+                        : null,
+                }
+                : null,
+        };
+    }
+    mapAttemptResult(exam, attempt) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const maxPoints = this.getExamMaxPoints(exam);
+        const maxScore = Math.max((_a = exam.max_score) !== null && _a !== void 0 ? _a : 100, 1);
+        const score = (_b = attempt.score) !== null && _b !== void 0 ? _b : 0;
+        const answersByQuestion = new Map(((_c = attempt.exam_answer) !== null && _c !== void 0 ? _c : []).map((answer) => [answer.question_id, answer]));
+        const hasPendingReview = ((_d = exam.exam_question) !== null && _d !== void 0 ? _d : []).some((item) => {
+            var _a;
+            const answer = answersByQuestion.get(item.question_id);
+            return this.requiresManualReview((_a = item.question) === null || _a === void 0 ? void 0 : _a.question_type) && Boolean(answer);
+        });
+        return {
+            totalPoints: ((_e = attempt.exam_answer) !== null && _e !== void 0 ? _e : []).reduce((sum, answer) => { var _a; return sum + ((_a = answer.points_awarded) !== null && _a !== void 0 ? _a : 0); }, 0),
+            maxPoints,
+            score,
+            scoreDisplay: this.scoreToTen(score),
+            percent: this.toPercent(score, maxScore),
+            passed: hasPendingReview ? null : score >= ((_f = exam.min_score) !== null && _f !== void 0 ? _f : 0),
+            hasPendingReview,
+            pendingReviewCount: ((_g = exam.exam_question) !== null && _g !== void 0 ? _g : []).filter((item) => {
+                var _a;
+                const answer = answersByQuestion.get(item.question_id);
+                return this.requiresManualReview((_a = item.question) === null || _a === void 0 ? void 0 : _a.question_type) && Boolean(answer);
+            }).length,
+            answersSummary: ((_h = exam.exam_question) !== null && _h !== void 0 ? _h : []).map((item) => {
+                var _a, _b;
+                const answer = answersByQuestion.get(item.question_id);
+                return {
+                    questionId: item.question_id,
+                    hasAnswer: Boolean(answer),
+                    isCorrect: typeof (answer === null || answer === void 0 ? void 0 : answer.is_correct) === 'boolean' ? Boolean(answer.is_correct) : null,
+                    pointsAwarded: (_a = answer === null || answer === void 0 ? void 0 : answer.points_awarded) !== null && _a !== void 0 ? _a : 0,
+                    requiresManualReview: this.requiresManualReview((_b = item.question) === null || _b === void 0 ? void 0 : _b.question_type),
+                };
+            }),
+        };
+    }
+    mapQuestions(exam, seedBase) {
+        var _a;
+        const orderedQuestions = this.sortWithSeed(exam.shuffle_questions, ((_a = exam.exam_question) !== null && _a !== void 0 ? _a : []), (item) => item.question_id, `${seedBase}:questions`);
+        return orderedQuestions.map((item, index) => {
+            var _a, _b, _c, _d, _e;
+            const questionType = this.resolveQuestionType((_a = item.question) === null || _a === void 0 ? void 0 : _a.question_type);
+            const parsedOptions = this.parseSpecialOptions((_c = (_b = item.question) === null || _b === void 0 ? void 0 : _b.exam_option) !== null && _c !== void 0 ? _c : []);
+            const objectiveOptions = ((_e = (_d = item.question) === null || _d === void 0 ? void 0 : _d.exam_option) !== null && _e !== void 0 ? _e : []).filter((option) => !this.isJsonString(option.option_text));
+            const orderedOptions = this.sortWithSeed(exam.shuffle_options, objectiveOptions, (option) => option.id, `${seedBase}:question:${item.question_id}:options`);
+            return {
+                id: item.question_id,
+                order: index,
+                questionType,
+                statement: item.question.statement,
+                points: item.question.points,
+                fillBlankAnswers: parsedOptions.fillBlankAnswers,
+                matchingPairs: parsedOptions.matchingPairs,
+                matchingOptions: questionType === 'matching'
+                    ? this.sortWithSeed(true, parsedOptions.matchingPairs.map((pair) => ({
+                        id: pair.id,
+                        text: pair.rightText,
+                    })), (option) => this.hash(option.id), `${seedBase}:question:${item.question_id}:matching-options`)
+                    : [],
+                alternatives: questionType === 'multiple_choice' || questionType === 'true_false'
+                    ? orderedOptions.map((option) => ({
+                        id: option.id,
+                        text: option.option_text,
+                    }))
+                    : [],
+            };
+        });
+    }
+    sortWithSeed(enabled, items, getId, seed) {
+        const list = [...items];
+        if (!enabled) {
+            return list;
+        }
+        return list.sort((left, right) => {
+            const leftHash = this.hash(`${seed}:${getId(left)}`);
+            const rightHash = this.hash(`${seed}:${getId(right)}`);
+            if (leftHash === rightHash) {
+                return getId(left) - getId(right);
+            }
+            return leftHash - rightHash;
+        });
+    }
+    hash(value) {
+        let hash = 0;
+        for (let index = 0; index < value.length; index += 1) {
+            hash = (hash * 31 + value.charCodeAt(index)) >>> 0;
+        }
+        return hash;
+    }
+    async maybeFinalizeExpiredAttempt(exam, attempt) {
+        const remainingSeconds = this.getRemainingSeconds(exam, attempt);
+        if (attempt.status !== 'in_progress' || remainingSeconds === null || remainingSeconds > 0) {
+            return attempt;
+        }
+        return this.completeAttempt(exam, attempt.id, true);
+    }
+    getRemainingSeconds(exam, attempt) {
+        if (!exam.time_limit_minutes) {
+            return null;
+        }
+        const endsAt = attempt.started_at.getTime() + exam.time_limit_minutes * 60 * 1000;
+        return Math.max(0, Math.floor((endsAt - Date.now()) / 1000));
+    }
+    getExamMaxPoints(exam) {
+        var _a;
+        return ((_a = exam.exam_question) !== null && _a !== void 0 ? _a : []).reduce((sum, item) => { var _a, _b; return sum + ((_b = (_a = item.question) === null || _a === void 0 ? void 0 : _a.points) !== null && _b !== void 0 ? _b : 0); }, 0);
+    }
+    isObjectiveQuestion(questionType) {
+        return create_exam_question_dto_1.OBJECTIVE_EXAM_QUESTION_TYPES.includes(this.resolveQuestionType(questionType));
+    }
+    requiresManualReview(questionType) {
+        return this.resolveQuestionType(questionType) === 'essay';
+    }
+    resolveQuestionType(questionType) {
+        var _a;
+        return (_a = questionType) !== null && _a !== void 0 ? _a : 'multiple_choice';
+    }
+    isJsonString(value) {
+        try {
+            const parsed = JSON.parse(value);
+            return typeof parsed === 'object' && parsed !== null;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    parseSpecialOptions(options) {
+        const fillBlankAnswers = [];
+        const matchingPairs = [];
+        for (const option of options) {
+            try {
+                const parsed = JSON.parse(option.option_text);
+                if ((parsed === null || parsed === void 0 ? void 0 : parsed.kind) === 'fill_blank' && typeof parsed.answer === 'string') {
+                    fillBlankAnswers.push({
+                        answer: parsed.answer,
+                        alternatives: Array.isArray(parsed.alternatives)
+                            ? parsed.alternatives
+                            : [],
+                    });
+                    continue;
+                }
+                if ((parsed === null || parsed === void 0 ? void 0 : 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 (_a) {
+                // Ignore objective options
+            }
+        }
+        return {
+            fillBlankAnswers,
+            matchingPairs,
+        };
+    }
+    extractFillBlankExpectedAnswers(rawValue) {
+        if (!Array.isArray(rawValue)) {
+            return [];
+        }
+        return rawValue.flatMap((item) => {
+            const primary = typeof (item === null || item === void 0 ? void 0 : item.answer) === 'string' ? [item.answer] : [];
+            const alternatives = Array.isArray(item === null || item === void 0 ? void 0 : item.alternatives)
+                ? item.alternatives.filter((alternative) => typeof alternative === 'string')
+                : [];
+            return [...primary, ...alternatives]
+                .map((value) => value.trim())
+                .filter((value) => value.length > 0);
+        });
+    }
+    isFillBlankCorrect(answerText, expectedAnswers) {
+        const normalizedAnswer = answerText.trim().toLowerCase();
+        return expectedAnswers.some((expected) => expected.trim().toLowerCase() === normalizedAnswer);
+    }
+    extractMatchingPairs(rawValue) {
+        if (!Array.isArray(rawValue)) {
+            return [];
+        }
+        return rawValue
+            .map((pair) => {
+            var _a, _b, _c;
+            return ({
+                id: String((_a = pair === null || pair === void 0 ? void 0 : pair.id) !== null && _a !== void 0 ? _a : '').trim(),
+                leftText: String((_b = pair === null || pair === void 0 ? void 0 : pair.leftText) !== null && _b !== void 0 ? _b : '').trim(),
+                rightText: String((_c = pair === null || pair === void 0 ? void 0 : pair.rightText) !== null && _c !== void 0 ? _c : '').trim(),
+            });
+        })
+            .filter((pair) => pair.id.length > 0 &&
+            pair.leftText.length > 0 &&
+            pair.rightText.length > 0);
+    }
+    isMatchingCorrect(submittedPairs, expectedPairs) {
+        if (submittedPairs.length !== expectedPairs.length) {
+            return false;
+        }
+        const expectedMap = new Map(expectedPairs.map((pair) => [pair.id, pair.id]));
+        const submittedMap = new Map(submittedPairs.map((pair) => [pair.leftId, pair.rightId]));
+        if (submittedMap.size !== expectedMap.size) {
+            return false;
+        }
+        for (const [leftId, expectedRightId] of expectedMap.entries()) {
+            if (submittedMap.get(leftId) !== expectedRightId) {
+                return false;
+            }
+        }
+        return true;
+    }
+    extractMatchingPairsFromAnswerText(answerText) {
+        if (!answerText) {
+            return [];
+        }
+        try {
+            const parsed = JSON.parse(answerText);
+            if (!Array.isArray(parsed === null || parsed === void 0 ? void 0 : parsed.matchingPairs)) {
+                return [];
+            }
+            return parsed.matchingPairs
+                .map((pair) => {
+                var _a, _b;
+                return ({
+                    leftId: String((_a = pair === null || pair === void 0 ? void 0 : pair.leftId) !== null && _a !== void 0 ? _a : '').trim(),
+                    rightId: String((_b = pair === null || pair === void 0 ? void 0 : pair.rightId) !== null && _b !== void 0 ? _b : '').trim(),
+                });
+            })
+                .filter((pair) => pair.leftId.length > 0 && pair.rightId.length > 0);
+        }
+        catch (_a) {
+            return [];
+        }
+    }
+    async findExamOrThrow(examId) {
+        const exam = await this.prisma.exam.findUnique({
+            where: { id: examId },
+            include: {
+                exam_question: {
+                    orderBy: { order: 'asc' },
+                    include: {
+                        question: {
+                            include: {
+                                exam_option: {
+                                    orderBy: { position: 'asc' },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        if (!exam) {
+            throw new common_1.NotFoundException('Exam not found');
+        }
+        return exam;
+    }
+    async findRelevantAttempt(examId, studentId) {
+        const activeAttempt = await this.findActiveAttempt(examId, studentId);
+        if (activeAttempt) {
+            return activeAttempt;
+        }
+        return this.prisma.exam_attempt.findFirst({
+            where: {
+                exam_id: examId,
+                student_id: studentId,
+            },
+            orderBy: { created_at: 'desc' },
+            include: {
+                exam_answer: true,
+            },
+        });
+    }
+    findActiveAttempt(examId, studentId) {
+        return this.prisma.exam_attempt.findFirst({
+            where: {
+                exam_id: examId,
+                student_id: studentId,
+                status: 'in_progress',
+            },
+            orderBy: { created_at: 'desc' },
+            include: {
+                exam_answer: true,
+            },
+        });
+    }
+    async findAttemptOrThrow(examId, attemptId, studentId) {
+        const attempt = await this.prisma.exam_attempt.findFirst({
+            where: {
+                id: attemptId,
+                exam_id: examId,
+                student_id: studentId,
+            },
+            include: {
+                exam_answer: true,
+            },
+        });
+        if (!attempt) {
+            throw new common_1.NotFoundException('Attempt not found');
+        }
+        return attempt;
+    }
+    countAttempts(examId, studentId) {
+        return this.prisma.exam_attempt.count({
+            where: {
+                exam_id: examId,
+                student_id: studentId,
+                status: {
+                    not: 'voided',
+                },
+            },
+        });
+    }
+    async findMatchingEnrollment(exam, studentId) {
+        if (exam.course_class_group_id) {
+            return this.prisma.course_enrollment.findFirst({
+                where: {
+                    person_id: studentId,
+                    course_class_group_id: exam.course_class_group_id,
+                },
+                orderBy: { updated_at: 'desc' },
+                select: { id: true },
+            });
+        }
+        if (exam.course_id) {
+            return this.prisma.course_enrollment.findFirst({
+                where: {
+                    person_id: studentId,
+                    course_id: exam.course_id,
+                },
+                orderBy: { updated_at: 'desc' },
+                select: { id: true },
+            });
+        }
+        return null;
+    }
+    async resolveStudentId(userId, explicitStudentId) {
+        var _a, _b, _c;
+        if (explicitStudentId) {
+            const person = await this.prisma.person.findUnique({
+                where: { id: explicitStudentId },
+                select: { id: true },
+            });
+            if (!person) {
+                throw new common_1.NotFoundException('Student not found');
+            }
+            return person.id;
+        }
+        const user = await this.prisma.user.findUnique({
+            where: { id: userId },
+            select: {
+                id: true,
+                name: true,
+                user_identifier: {
+                    where: {
+                        type: 'email',
+                        enabled: true,
+                    },
+                    select: {
+                        value: true,
+                    },
+                    take: 1,
+                },
+            },
+        });
+        if (!user) {
+            throw new common_1.NotFoundException('Authenticated user not found');
+        }
+        const userEmail = (_c = (_b = (_a = user.user_identifier) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.value) === null || _c === void 0 ? void 0 : _c.trim().toLowerCase();
+        if (userEmail) {
+            const matchingPersons = await this.prisma.person.findMany({
+                where: {
+                    contact: {
+                        some: {
+                            value: { equals: userEmail, mode: 'insensitive' },
+                            contact_type: {
+                                code: 'email',
+                            },
+                        },
+                    },
+                },
+                select: { id: true },
+                take: 2,
+            });
+            if (matchingPersons.length === 1) {
+                return matchingPersons[0].id;
+            }
+        }
+        const sameIdPerson = await this.prisma.person.findUnique({
+            where: { id: userId },
+            select: { id: true },
+        });
+        if (sameIdPerson) {
+            return sameIdPerson.id;
+        }
+        const emailType = await this.prisma.contact_type.findFirst({
+            where: { code: 'email' },
+            select: { id: true },
+        });
+        const createdPerson = await this.prisma.person.create({
+            data: Object.assign({ name: user.name, type: 'individual', status: 'active' }, (userEmail && emailType
+                ? {
+                    contact: {
+                        create: {
+                            contact_type_id: emailType.id,
+                            value: userEmail,
+                            is_primary: true,
+                        },
+                    },
+                }
+                : {})),
+            select: { id: true },
+        });
+        return createdPerson.id;
+    }
+    toPercent(value, max) {
+        if (!max)
+            return 0;
+        return Math.round((value / max) * 100);
+    }
+    scoreToTen(score) {
+        if (!score)
+            return 0;
+        return score > 10 ? Number((score / 10).toFixed(1)) : Number(score.toFixed(1));
+    }
+};
+exports.ExamAttemptService = ExamAttemptService;
+exports.ExamAttemptService = ExamAttemptService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [api_prisma_1.PrismaService])
+], ExamAttemptService);
+//# sourceMappingURL=exam-attempt.service.js.map