CategorizedExerciseResultStateProvider::displayQuestionListByAttempt()

Complexity

Conditions	42
Paths	> 20000

Size

Total Lines	265
Code Lines	156

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	0	Features	0

<?php
    private function displayQuestionListByAttempt(
        Exercise $objExercise,
        TrackEExercise $exerciseTracking
    ): array {
        $courseId = api_get_course_int_id();
        $sessionId = api_get_session_id();

        $question_list = explode(',', $exerciseTracking->getDataTracking());
        $question_list = array_map('intval', $question_list);

        if ($objExercise->getResultAccess()) {
            $exercise_stat_info = $objExercise->get_stat_track_exercise_info_by_exe_id(
                $exerciseTracking->getExeId()
            );

            if (false === $objExercise->hasResultsAccess($exercise_stat_info)) {
                throw new Exception(get_lang('YouPassedTheLimitOfXMinutesToSeeTheResults'), $objExercise->getResultsAccess());
            }
        }

        $total_score = $total_weight = 0;

        // Hide results
        $show_results = false;
        $show_only_score = false;

        if (\in_array(
            $objExercise->results_disabled,
            [
                RESULT_DISABLE_SHOW_ONLY_IN_CORRECT_ANSWER,
                RESULT_DISABLE_SHOW_SCORE_AND_EXPECTED_ANSWERS,
                RESULT_DISABLE_SHOW_SCORE_AND_EXPECTED_ANSWERS_AND_RANKING,
            ],
            true
        )) {
            $show_results = true;
        }

        if (\in_array(
            $objExercise->results_disabled,
            [
                RESULT_DISABLE_SHOW_SCORE_ONLY,
                RESULT_DISABLE_SHOW_FINAL_SCORE_ONLY_WITH_CATEGORIES,
                RESULT_DISABLE_RANKING,
            ],
            true
        )) {
            $show_only_score = true;
        }

        // Not display expected answer, but score, and feedback
        if (RESULT_DISABLE_SHOW_SCORE_ONLY === $objExercise->results_disabled
            && EXERCISE_FEEDBACK_TYPE_END === $objExercise->getFeedbackType()
        ) {
            $show_results = true;
            $show_only_score = false;
        }

        $showTotalScoreAndUserChoicesInLastAttempt = true;
        $showTotalScore = true;

        if (\in_array(
            $objExercise->results_disabled,
            [
                RESULT_DISABLE_SHOW_SCORE_ATTEMPT_SHOW_ANSWERS_LAST_ATTEMPT,
                RESULT_DISABLE_SHOW_SCORE_ATTEMPT_SHOW_ANSWERS_LAST_ATTEMPT_NO_FEEDBACK,
                RESULT_DISABLE_DONT_SHOW_SCORE_ONLY_IF_USER_FINISHES_ATTEMPTS_SHOW_ALWAYS_FEEDBACK,
            ],
            true
        )) {
            $show_only_score = true;
            $show_results = true;
            $numberAttempts = 0;

            if ($objExercise->attempts > 0) {
                $attempts = Event::getExerciseResultsByUser(

The method getExerciseResultsByUser() does not exist on Event.

                    api_get_user_id(),
                    $objExercise->id,
                    $courseId,
                    $sessionId,
                    $exerciseTracking->getOrigLpId(),
                    $exerciseTracking->getOrigLpItemId(),
                    'desc'
                );

                if ($attempts) {
                    $numberAttempts = \count($attempts);
                }

                $showTotalScore = false;

                if (RESULT_DISABLE_SHOW_SCORE_ATTEMPT_SHOW_ANSWERS_LAST_ATTEMPT === $objExercise->results_disabled) {
                    $showTotalScore = true;
                }

                $showTotalScoreAndUserChoicesInLastAttempt = false;

                if ($numberAttempts >= $objExercise->attempts) {
                    $showTotalScore = true;
                    $show_only_score = false;
                    $showTotalScoreAndUserChoicesInLastAttempt = true;
                }

                if (RESULT_DISABLE_SHOW_SCORE_ATTEMPT_SHOW_ANSWERS_LAST_ATTEMPT_NO_FEEDBACK === $objExercise->results_disabled) {
                    $showTotalScore = true;
                    $show_only_score = false;
                    $showTotalScoreAndUserChoicesInLastAttempt = false;

                    if ($numberAttempts >= $objExercise->attempts) {
                        $showTotalScoreAndUserChoicesInLastAttempt = true;
                    }

                    // Check if the current attempt is the last.
                    if (!empty($attempts)) {
                        $showTotalScoreAndUserChoicesInLastAttempt = false;
                        $position = 1;

                        foreach ($attempts as $attempt) {
                            if ($exerciseTracking->getExeId() === $attempt['exe_id']) {
                                break;
                            }

                            $position++;
                        }

                        if ($position === $objExercise->attempts) {
                            $showTotalScoreAndUserChoicesInLastAttempt = true;
                        }
                    }
                }
            }

            if (RESULT_DISABLE_DONT_SHOW_SCORE_ONLY_IF_USER_FINISHES_ATTEMPTS_SHOW_ALWAYS_FEEDBACK ===
                $objExercise->results_disabled
            ) {
                $show_only_score = false;
                $showTotalScore = false;
                if ($numberAttempts >= $objExercise->attempts) {
                    $showTotalScore = true;
                }
            }
        }

        $category_list = [
            'none' => [
                'score' => 0,
                'total' => 0,
            ],
        ];
        $exerciseResultCoordinates = [];

        $result = [];
        // Loop over all question to show results for each of them, one by one
        foreach ($question_list as $questionId) {
            // Creates a temporary Question object
            $objQuestionTmp = Question::read($questionId, $objExercise->course);

            // We're inside *one* question. Go through each possible answer for this question
            $result = $objExercise->manage_answer(
                $exerciseTracking->getExeId(),
                $questionId,
                null,
                'exercise_result',
                $exerciseResultCoordinates,
                false,
                true,
                $show_results,
                $objExercise->selectPropagateNeg(),
                [],
                $showTotalScoreAndUserChoicesInLastAttempt
            );

            if (false === $result) {
                continue;
            }

            $total_score += $result['score'];
            $total_weight += $result['weight'];

            $my_total_score = $result['score'];
            $my_total_weight = $result['weight'];
            $scorePassed = ExerciseLib::scorePassed($my_total_score, $my_total_weight);

            // Category report
            $category_was_added_for_this_test = false;
            if (!empty($objQuestionTmp->category)) {
                if (!isset($category_list[$objQuestionTmp->category])) {
                    $category_list[$objQuestionTmp->category] = [
                        'score' => 0,
                        'total' => 0,
                        'total_questions' => 0,
                        'passed' => 0,
                        'wrong' => 0,
                        'no_answer' => 0,
                    ];
                }

                $category_list[$objQuestionTmp->category]['score'] += $my_total_score;
                $category_list[$objQuestionTmp->category]['total'] += $my_total_weight;

                if ($scorePassed) {
                    // Only count passed if score is not empty
                    if (!empty($my_total_score)) {
                        $category_list[$objQuestionTmp->category]['passed']++;
                    }
                } elseif ($result['user_answered']) {
                    $category_list[$objQuestionTmp->category]['wrong']++;
                } else {
                    $category_list[$objQuestionTmp->category]['no_answer']++;
                }

                $category_list[$objQuestionTmp->category]['total_questions']++;
                $category_was_added_for_this_test = true;
            }

            if (!empty($objQuestionTmp->category_list)) {
                foreach ($objQuestionTmp->category_list as $category_id) {
                    $category_list[$category_id]['score'] += $my_total_score;
                    $category_list[$category_id]['total'] += $my_total_weight;
                    $category_was_added_for_this_test = true;
                }
            }

            // No category for this question!
            if (!$category_was_added_for_this_test) {
                $category_list['none']['score'] += $my_total_score;
                $category_list['none']['total'] += $my_total_weight;
            }
        }

        if (($show_results || $show_only_score) && $showTotalScore) {
            if ($result
                && isset($result['answer_type'])
                && MULTIPLE_ANSWER_TRUE_FALSE_DEGREE_CERTAINTY !== $result['answer_type']
            ) {
                $pluginEvaluation = QuestionOptionsEvaluationPlugin::create();
                if ('true' === $pluginEvaluation->get(QuestionOptionsEvaluationPlugin::SETTING_ENABLE)) {
                    $formula = $pluginEvaluation->getFormulaForExercise($objExercise->getId());

                    if (!empty($formula)) {
                        $total_score = $pluginEvaluation->getResultWithFormula(
                            $exerciseTracking->getExeId(),
                            $formula
                        );
                        $total_weight = $pluginEvaluation->getMaxScore();
                    }
                }
            }
        }

        if ($this->isAllowedToSeeResults()) {
            $show_results = true;
        }

        if (!$show_results && !$show_only_score && RESULT_DISABLE_RADAR !== $objExercise->results_disabled) {
            throw new AccessDeniedException();
        }

        // Adding total
        $category_list['total'] = [
            'score' => $total_score,
            'total' => $total_weight,
        ];

        return $category_list;
    }