ExerciseLib::displayQuestionListByAttempt()

Complexity

Conditions	85
Paths	5

Size

Total Lines	556
Code Lines	361

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	0	Features	0

<?php
    public static function displayQuestionListByAttempt(
        $objExercise,
        $exeId,
        $save_user_result = false,
        $remainingMessage = ''
    ) {
        $origin = api_get_origin();
        $courseId = api_get_course_int_id();
        $courseCode = api_get_course_id();
        $sessionId = api_get_session_id();

        // Getting attempt info
        $exercise_stat_info = $objExercise->get_stat_track_exercise_info_by_exe_id($exeId);

        // Getting question list
        $question_list = [];
        $studentInfo = [];
        if (!empty($exercise_stat_info['data_tracking'])) {
            $studentInfo = api_get_user_info($exercise_stat_info['exe_user_id']);
            $question_list = explode(',', $exercise_stat_info['data_tracking']);
        } else {
            // Try getting the question list only if save result is off
            if ($save_user_result == false) {
                $question_list = $objExercise->get_validated_question_list();
            }
            if (in_array(
                $objExercise->getFeedbackType(),
                [EXERCISE_FEEDBACK_TYPE_DIRECT, EXERCISE_FEEDBACK_TYPE_POPUP]
            )) {
                $question_list = $objExercise->get_validated_question_list();
            }
        }

        if ($objExercise->getResultAccess()) {
            if ($objExercise->hasResultsAccess($exercise_stat_info) === false) {
                echo Display::return_message(
                    sprintf(get_lang('YouPassedTheLimitOfXMinutesToSeeTheResults'), $objExercise->getResultsAccess())
                );

                return false;
            }

            if (!empty($objExercise->getResultAccess())) {
                $url = api_get_path(WEB_CODE_PATH).'exercise/overview.php?'.api_get_cidreq().'&exerciseId='.$objExercise->id;
                echo $objExercise->returnTimeLeftDiv();
                echo $objExercise->showSimpleTimeControl(
                    $objExercise->getResultAccessTimeDiff($exercise_stat_info),
                    $url
                );
            }
        }

        $counter = 1;
        $total_score = $total_weight = 0;
        $exercise_content = null;
        // 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,
            ]
        )) {
            $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,
            ]
        )
        ) {
            $show_only_score = true;
        }

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

        $showTotalScoreAndUserChoicesInLastAttempt = true;
        $showTotalScore = true;
        $showQuestionScore = true;
        $attemptResult = [];

        if (in_array(
            $objExercise->results_disabled,
            [
                RESULT_DISABLE_SHOW_SCORE_ATTEMPT_SHOW_ANSWERS_LAST_ATTEMPT,
                RESULT_DISABLE_DONT_SHOW_SCORE_ONLY_IF_USER_FINISHES_ATTEMPTS_SHOW_ALWAYS_FEEDBACK,
            ])
        ) {
            $show_only_score = true;
            $show_results = true;
            $numberAttempts = 0;
            if ($objExercise->attempts > 0) {
                $attempts = Event::getExerciseResultsByUser(
                    api_get_user_id(),
                    $objExercise->id,
                    $courseId,
                    $sessionId,
                    $exercise_stat_info['orig_lp_id'],
                    $exercise_stat_info['orig_lp_item_id'],
                    'desc'
                );
                if ($attempts) {
                    $numberAttempts = count($attempts);
                }

                if ($save_user_result) {
                    $numberAttempts++;
                }

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

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

        if ('embeddable' !== $origin &&
            !empty($exercise_stat_info['exe_user_id']) &&
            !empty($studentInfo)
        ) {
            // Shows exercise header.
            echo $objExercise->showExerciseResultHeader(
                $studentInfo,
                $exercise_stat_info,
                $save_user_result
            );
        }

        // Display text when test is finished #4074 and for LP #4227
        $endOfMessage = $objExercise->getTextWhenFinished();
        if (!empty($endOfMessage)) {
            echo Display::div(
                $endOfMessage,
                ['id' => 'quiz_end_message']
            );
        }

        $question_list_answers = [];
        $media_list = [];
        $category_list = [];
        $loadChoiceFromSession = false;
        $fromDatabase = true;
        $exerciseResult = null;
        $exerciseResultCoordinates = null;
        $delineationResults = null;

        if (in_array(
            $objExercise->getFeedbackType(),
            [EXERCISE_FEEDBACK_TYPE_DIRECT, EXERCISE_FEEDBACK_TYPE_POPUP]
        )) {
            $loadChoiceFromSession = true;
            $fromDatabase = false;
            $exerciseResult = Session::read('exerciseResult');
            $exerciseResultCoordinates = Session::read('exerciseResultCoordinates');
            $delineationResults = Session::read('hotspot_delineation_result');
            $delineationResults = isset($delineationResults[$objExercise->id]) ? $delineationResults[$objExercise->id] : null;
        }

        $countPendingQuestions = 0;
        $result = [];
        // Loop over all question to show results for each of them, one by one
        if (!empty($question_list)) {
            foreach ($question_list as $questionId) {
                // Creates a temporary Question object
                $objQuestionTmp = Question::read($questionId, $objExercise->course);
                // This variable came from exercise_submit_modal.php
                ob_start();
                $choice = null;
                $delineationChoice = null;
                if ($loadChoiceFromSession) {
                    $choice = isset($exerciseResult[$questionId]) ? $exerciseResult[$questionId] : null;
                    $delineationChoice = isset($delineationResults[$questionId]) ? $delineationResults[$questionId] : null;
                }

                // We're inside *one* question. Go through each possible answer for this question
                $result = $objExercise->manage_answer(
                    $exeId,
                    $questionId,
                    $choice,
                    'exercise_result',
                    $exerciseResultCoordinates,
                    $save_user_result,
                    $fromDatabase,
                    $show_results,
                    $objExercise->selectPropagateNeg(),
                    $delineationChoice,
                    $showTotalScoreAndUserChoicesInLastAttempt
                );

                if (empty($result)) {
                    continue;
                }

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

                $question_list_answers[] = [
                    'question' => $result['open_question'],
                    'answer' => $result['open_answer'],
                    'answer_type' => $result['answer_type'],
                    'generated_oral_file' => $result['generated_oral_file'],
                ];

                $my_total_score = $result['score'];
                $my_total_weight = $result['weight'];

                // Category report
                $category_was_added_for_this_test = false;
                if (isset($objQuestionTmp->category) && !empty($objQuestionTmp->category)) {
                    if (!isset($category_list[$objQuestionTmp->category]['score'])) {
                        $category_list[$objQuestionTmp->category]['score'] = 0;
                    }
                    if (!isset($category_list[$objQuestionTmp->category]['total'])) {
                        $category_list[$objQuestionTmp->category]['total'] = 0;
                    }
                    $category_list[$objQuestionTmp->category]['score'] += $my_total_score;
                    $category_list[$objQuestionTmp->category]['total'] += $my_total_weight;
                    $category_was_added_for_this_test = true;
                }

                if (isset($objQuestionTmp->category_list) && !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 == false) {
                    if (!isset($category_list['none']['score'])) {
                        $category_list['none']['score'] = 0;
                    }
                    if (!isset($category_list['none']['total'])) {
                        $category_list['none']['total'] = 0;
                    }

                    $category_list['none']['score'] += $my_total_score;
                    $category_list['none']['total'] += $my_total_weight;
                }

                if ($objExercise->selectPropagateNeg() == 0 && $my_total_score < 0) {
                    $my_total_score = 0;
                }

                $comnt = null;
                if ($show_results) {
                    $comnt = Event::get_comments($exeId, $questionId);
                    $teacherAudio = self::getOralFeedbackAudio(
                        $exeId,
                        $questionId,
                        api_get_user_id()
                    );

                    if (!empty($comnt) || $teacherAudio) {
                        echo '<b>'.get_lang('Feedback').'</b>';
                    }

                    if (!empty($comnt)) {
                        echo self::getFeedbackText($comnt);
                    }

                    if ($teacherAudio) {
                        echo $teacherAudio;
                    }
                }

                $scorePassed = $my_total_score >= $my_total_weight;
                if (function_exists('bccomp')) {
                    $compareResult = bccomp($my_total_score, $my_total_weight, 3);
                    $scorePassed = $compareResult === 1 || $compareResult === 0;
                }

                $calculatedScore = [
                    'result' => self::show_score(
                        $my_total_score,
                        $my_total_weight,
                        false
                    ),
                    'pass' => $scorePassed,
                    'score' => $my_total_score,
                    'weight' => $my_total_weight,
                    'comments' => $comnt,
                    'user_answered' => $result['user_answered'],
                ];

                $score = [];
                if ($show_results) {
                    $score = $calculatedScore;
                }
                if (in_array($objQuestionTmp->type, [FREE_ANSWER, ORAL_EXPRESSION, ANNOTATION])) {
                    $reviewScore = [
                        'score' => $my_total_score,
                        'comments' => Event::get_comments($exeId, $questionId),
                    ];
                    $check = $objQuestionTmp->isQuestionWaitingReview($reviewScore);
                    if (false === $check) {
                        $countPendingQuestions++;
                    }
                }

                $contents = ob_get_clean();
                $question_content = '';
                if ($show_results) {
                    $question_content = '<div class="question_row_answer">';
                    if (false == $showQuestionScore) {
                        $score = [];
                    }

                    // Shows question title an description
                    $question_content .= $objQuestionTmp->return_header(
                        $objExercise,
                        $counter,
                        $score
                    );
                }
                $counter++;
                $question_content .= $contents;
                if ($show_results) {
                    $question_content .= '</div>';
                }

                $calculatedScore['question_content'] = $question_content;
                $attemptResult[] = $calculatedScore;

                if ($objExercise->showExpectedChoice()) {
                    $exercise_content .= Display::div(
                        Display::panel($question_content),
                        ['class' => 'question-panel']
                    );
                } else {
                    // $show_all_but_expected_answer should not happen at
                    // the same time as $show_results
                    if ($show_results && !$show_only_score) {
                        $exercise_content .= Display::div(
                            Display::panel($question_content),
                            ['class' => 'question-panel']
                        );
                    }
                }
            }
        }

        $totalScoreText = null;
        $certificateBlock = '';
        if (($show_results || $show_only_score) && $showTotalScore) {
            if ($result['answer_type'] == MULTIPLE_ANSWER_TRUE_FALSE_DEGREE_CERTAINTY) {
                echo '<h1 style="text-align : center; margin : 20px 0;">'.get_lang('YourResults').'</h1><br />';
            }
            $totalScoreText .= '<div class="question_row_score">';
            if ($result['answer_type'] == MULTIPLE_ANSWER_TRUE_FALSE_DEGREE_CERTAINTY) {
                $totalScoreText .= self::getQuestionDiagnosisRibbon(
                    $objExercise,
                    $total_score,
                    $total_weight,
                    true
                );
            } else {
                $pluginEvaluation = QuestionOptionsEvaluationPlugin::create();
                if ('true' === $pluginEvaluation->get(QuestionOptionsEvaluationPlugin::SETTING_ENABLE)) {
                    $formula = $pluginEvaluation->getFormulaForExercise($objExercise->selectId());

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

                $totalScoreText .= self::getTotalScoreRibbon(
                    $objExercise,
                    $total_score,
                    $total_weight,
                    true,
                    $countPendingQuestions
                );
            }
            $totalScoreText .= '</div>';

            if (!empty($studentInfo)) {
                $certificateBlock = self::generateAndShowCertificateBlock(
                    $total_score,
                    $total_weight,
                    $objExercise,
                    $studentInfo['id'],
                    $courseCode,
                    $sessionId
                );
            }
        }

        if ($result['answer_type'] == MULTIPLE_ANSWER_TRUE_FALSE_DEGREE_CERTAINTY) {
            $chartMultiAnswer = MultipleAnswerTrueFalseDegreeCertainty::displayStudentsChartResults(
                $exeId,
                $objExercise
            );
            echo $chartMultiAnswer;
        }

        if (!empty($category_list) && ($show_results || $show_only_score)) {
            // Adding total
            $category_list['total'] = [
                'score' => $total_score,
                'total' => $total_weight,
            ];
            echo TestCategory::get_stats_table_by_attempt($objExercise->id, $category_list);
        }

        if ($show_all_but_expected_answer) {
            $exercise_content .= Display::return_message(get_lang('ExerciseWithFeedbackWithoutCorrectionComment'));
        }

        // Remove audio auto play from questions on results page - refs BT#7939
        $exercise_content = preg_replace(
            ['/autoplay[\=\".+\"]+/', '/autostart[\=\".+\"]+/'],
            '',
            $exercise_content
        );

        echo $totalScoreText;
        echo $certificateBlock;

        // Ofaj change BT#11784
        if (api_get_configuration_value('quiz_show_description_on_results_page') &&
            !empty($objExercise->description)
        ) {
            echo Display::div($objExercise->description, ['class' => 'exercise_description']);
        }

        echo $exercise_content;
        if (!$show_only_score) {
            echo $totalScoreText;
        }

        if ($save_user_result) {
            // Tracking of results
            if ($exercise_stat_info) {
                $learnpath_id = $exercise_stat_info['orig_lp_id'];
                $learnpath_item_id = $exercise_stat_info['orig_lp_item_id'];
                $learnpath_item_view_id = $exercise_stat_info['orig_lp_item_view_id'];

                if (api_is_allowed_to_session_edit()) {
                    Event::updateEventExercise(
                        $exercise_stat_info['exe_id'],
                        $objExercise->selectId(),
                        $total_score,
                        $total_weight,
                        $sessionId,
                        $learnpath_id,
                        $learnpath_item_id,
                        $learnpath_item_view_id,
                        $exercise_stat_info['exe_duration'],
                        $question_list
                    );

                    $allowStats = api_get_configuration_value('allow_gradebook_stats');
                    if ($allowStats) {
                        $objExercise->generateStats(
                            $objExercise->selectId(),
                            api_get_course_info(),
                            $sessionId
                        );
                    }
                }
            }

            // Send notification at the end
            if (!api_is_allowed_to_edit(null, true) &&
                !api_is_excluded_user_type()
            ) {
                $objExercise->send_mail_notification_for_exam(
                    'end',
                    $question_list_answers,
                    $origin,
                    $exeId,
                    $total_score,
                    $total_weight
                );
            }
        }

        if (in_array(
            $objExercise->selectResultsDisabled(),
            [RESULT_DISABLE_RANKING, RESULT_DISABLE_SHOW_SCORE_AND_EXPECTED_ANSWERS_AND_RANKING]
        )) {
            echo Display::page_header(get_lang('Ranking'), null, 'h4');
            echo self::displayResultsInRanking(
                $objExercise->iId,
                api_get_user_id(),
                $courseId,
                $sessionId
            );
        }

        if (!empty($remainingMessage)) {
            echo Display::return_message($remainingMessage, 'normal', false);
        }

        $failedAnswersCount = 0;
        $wrongQuestionHtml = '';
        $all = '';
        foreach ($attemptResult as $item) {
            if (false === $item['pass']) {
                $failedAnswersCount++;
                $wrongQuestionHtml .= $item['question_content'].'<br />';
            }
            $all .= $item['question_content'].'<br />';
        }

        $passed = self::isPassPercentageAttemptPassed(
            $objExercise,
            $total_score,
            $total_weight
        );

        return [
            'attempts_result_list' => $attemptResult, // array of results
            'exercise_passed' => $passed, // boolean
            'total_answers_count' => count($attemptResult), // int
            'failed_answers_count' => $failedAnswersCount, // int
            'failed_answers_html' => $wrongQuestionHtml,
            'all_answers_html' => $all,
        ];