C:/xampp/htdocs/moodle/question/type/questionbase.php

Go to the documentation of this file.

<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

defined('MOODLE_INTERNAL') || die();


abstract class question_definition {
    public $id;

    public $category;

    public $contextid;

    public $parent = 0;

    public $qtype;

    public $name;

    public $questiontext;

    public $questiontextformat;

    public $generalfeedback;

    public $generalfeedbackformat;

    public $defaultmark = 1;

    public $length = 1;

    public $penalty = 0;

    public $stamp;

    public $version;

    public $hidden = 0;

    public $timecreated;

    public $timemodified;

    public $createdby;

    public $modifiedby;

    public $hints = array();

    public function __construct() {
    }

    public function get_type_name() {
        return $this->qtype->name();
    }

    public function make_behaviour(question_attempt $qa, $preferredbehaviour) {
        return question_engine::make_archetypal_behaviour($preferredbehaviour, $qa);
    }

    public function start_attempt(question_attempt_step $step, $variant) {
    }

    public function apply_attempt_state(question_attempt_step $step) {
    }

    public function get_question_summary() {
        return $this->html_to_text($this->questiontext, $this->questiontextformat);
    }

    public function get_num_variants() {
        return 1;
    }

    public function get_variants_selection_seed() {
        return $this->stamp;
    }

    public function get_min_fraction() {
        return 0;
    }

    public function clear_wrong_from_response(array $response) {
        return array();
    }

    public function get_num_parts_right(array $response) {
        return array(null, null);
    }

    public function get_renderer(moodle_page $page) {
        return $page->get_renderer($this->qtype->plugin_name());
    }

    public abstract function get_expected_data();

    public abstract function get_correct_response();

    public function format_text($text, $format, $qa, $component, $filearea, $itemid,
            $clean = false) {
        $formatoptions = new stdClass();
        $formatoptions->noclean = !$clean;
        $formatoptions->para = false;
        $text = $qa->rewrite_pluginfile_urls($text, $component, $filearea, $itemid);
        return format_text($text, $format, $formatoptions);
    }

    public function html_to_text($text, $format) {
        return html_to_text(format_text($text, $format, array('noclean' => true)), 0, false);
    }

    public function format_questiontext($qa) {
        return $this->format_text($this->questiontext, $this->questiontextformat,
                $qa, 'question', 'questiontext', $this->id);
    }

    public function format_generalfeedback($qa) {
        return $this->format_text($this->generalfeedback, $this->generalfeedbackformat,
                $qa, 'question', 'generalfeedback', $this->id);
    }

    public function check_file_access($qa, $options, $component, $filearea, $args, $forcedownload) {
        if ($component == 'question' && $filearea == 'questiontext') {
            // Question text always visible.
            return true;

        } else if ($component == 'question' && $filearea == 'generalfeedback') {
            return $options->generalfeedback;

        } else {
            // Unrecognised component or filearea.
            return false;
        }
    }
}


class question_information_item extends question_definition {
    public function __construct() {
        parent::__construct();
        $this->defaultmark = 0;
        $this->penalty = 0;
        $this->length = 0;
    }

    public function make_behaviour(question_attempt $qa, $preferredbehaviour) {
        question_engine::load_behaviour_class('informationitem');
        return new qbehaviour_informationitem($qa, $preferredbehaviour);
    }

    public function get_expected_data() {
        return array();
    }

    public function get_correct_response() {
        return array();
    }

    public function get_question_summary() {
        return null;
    }
}


interface question_manually_gradable {
    public function is_complete_response(array $response);

    public function is_same_response(array $prevresponse, array $newresponse);

    public function summarise_response(array $response);

    public function classify_response(array $response);
}


class question_classified_response {
    public $responseclassid;
    public $response;
    public $fraction;
    public function __construct($responseclassid, $response, $fraction) {
        $this->responseclassid = $responseclassid;
        $this->response = $response;
        $this->fraction = $fraction;
    }

    public static function no_response() {
        return new question_classified_response(null, get_string('noresponse', 'question'), null);
    }
}


interface question_automatically_gradable extends question_manually_gradable {
    public function is_gradable_response(array $response);

    public function get_validation_error(array $response);

    public function grade_response(array $response);

    public function get_hint($hintnumber, question_attempt $qa);

    public function get_right_answer_summary();
}


interface question_automatically_gradable_with_countback extends question_automatically_gradable {
    public function compute_final_grade($responses, $totaltries);
}


abstract class question_with_responses extends question_definition
        implements question_manually_gradable {
    public function classify_response(array $response) {
        return array();
    }
}


abstract class question_graded_automatically extends question_with_responses
        implements question_automatically_gradable {
    public $shownumcorrect = false;

    public function is_gradable_response(array $response) {
        return $this->is_complete_response($response);
    }

    public function get_right_answer_summary() {
        $correctresponse = $this->get_correct_response();
        if (empty($correctresponse)) {
            return null;
        }
        return $this->summarise_response($correctresponse);
    }

    protected function check_combined_feedback_file_access($qa, $options, $filearea) {
        $state = $qa->get_state();

        if (!$state->is_finished()) {
            $response = $qa->get_last_qt_data();
            if (!$this->is_gradable_response($response)) {
                return false;
            }
            list($notused, $state) = $this->grade_response($response);
        }

        return $options->feedback && $state->get_feedback_class() . 'feedback' == $filearea;
    }

    protected function check_hint_file_access($qa, $options, $args) {
        if (!$options->feedback) {
            return false;
        }
        $hint = $qa->get_applicable_hint();
        $hintid = reset($args); // itemid is hint id.
        return $hintid == $hint->id;
    }

    public function get_hint($hintnumber, question_attempt $qa) {
        if (!isset($this->hints[$hintnumber])) {
            return null;
        }
        return $this->hints[$hintnumber];
    }

    public function format_hint(question_hint $hint, question_attempt $qa) {
        return $this->format_text($hint->hint, $hint->hintformat, $qa,
                'question', 'hint', $hint->id);
    }
}


abstract class question_graded_automatically_with_countback
        extends question_graded_automatically
        implements question_automatically_gradable_with_countback {

    public function make_behaviour(question_attempt $qa, $preferredbehaviour) {
        if ($preferredbehaviour == 'interactive') {
            return question_engine::make_behaviour('interactivecountback',
                    $qa, $preferredbehaviour);
        }
        return question_engine::make_archetypal_behaviour($preferredbehaviour, $qa);
    }
}


abstract class question_graded_by_strategy extends question_graded_automatically {
    protected $gradingstrategy;

    public function __construct(question_grading_strategy $strategy) {
        parent::__construct();
        $this->gradingstrategy = $strategy;
    }

    public function get_correct_response() {
        $answer = $this->get_correct_answer();
        if (!$answer) {
            return array();
        }

        return array('answer' => $answer->answer);
    }

    public function get_matching_answer(array $response) {
        return $this->gradingstrategy->grade($response);
    }

    public function get_correct_answer() {
        return $this->gradingstrategy->get_correct_answer();
    }

    public function grade_response(array $response) {
        $answer = $this->get_matching_answer($response);
        if ($answer) {
            return array($answer->fraction,
                    question_state::graded_state_for_fraction($answer->fraction));
        } else {
            return array(0, question_state::$gradedwrong);
        }
    }

    public function classify_response(array $response) {
        if (empty($response['answer'])) {
            return array($this->id => question_classified_response::no_response());
        }

        $ans = $this->get_matching_answer($response);
        if (!$ans) {
            return array($this->id => new question_classified_response(
                    0, $response['answer'], 0));
        }

        return array($this->id => new question_classified_response(
                $ans->id, $response['answer'], $ans->fraction));
    }
}


class question_answer {
    public $id;

    public $answer;

    public $answerformat = FORMAT_PLAIN;

    public $fraction;

    public $feedback;

    public $feedbackformat;

    public function __construct($id, $answer, $fraction, $feedback, $feedbackformat) {
        $this->id = $id;
        $this->answer = $answer;
        $this->fraction = $fraction;
        $this->feedback = $feedback;
        $this->feedbackformat = $feedbackformat;
    }
}


class question_hint {
    public $id;
    public $hint;
    public $hintformat;

    public function __construct($id, $hint, $hintformat) {
        $this->id = $id;
        $this->hint = $hint;
        $this->hintformat = $hintformat;
    }

    public static function load_from_record($row) {
        return new question_hint($row->id, $row->hint, $row->hintformat);
    }

    public function adjust_display_options(question_display_options $options) {
        // Do nothing.
    }
}


class question_hint_with_parts extends question_hint {
    public $shownumcorrect;

    public $clearwrong;

    public function __construct($id, $hint, $hintformat, $shownumcorrect, $clearwrong) {
        parent::__construct($id, $hint, $hintformat);
        $this->shownumcorrect = $shownumcorrect;
        $this->clearwrong = $clearwrong;
    }

    public static function load_from_record($row) {
        return new question_hint_with_parts($row->id, $row->hint, $row->hintformat,
                $row->shownumcorrect, $row->clearwrong);
    }

    public function adjust_display_options(question_display_options $options) {
        parent::adjust_display_options($options);
        if ($this->clearwrong) {
            $options->clearwrong = true;
        }
        $options->numpartscorrect = $this->shownumcorrect;
    }
}


interface question_grading_strategy {
    public function grade(array $response);

    public function get_correct_answer();
}


interface question_response_answer_comparer {
    public function get_answers();

    public function compare_response_with_answer(array $response, question_answer $answer);
}


class question_first_matching_answer_grading_strategy implements question_grading_strategy {
    protected $question;

    public function __construct(question_response_answer_comparer $question) {
        $this->question = $question;
    }

    public function grade(array $response) {
        foreach ($this->question->get_answers() as $aid => $answer) {
            if ($this->question->compare_response_with_answer($response, $answer)) {
                $answer->id = $aid;
                return $answer;
            }
        }
        return null;
    }

    public function get_correct_answer() {
        foreach ($this->question->get_answers() as $answer) {
            $state = question_state::graded_state_for_fraction($answer->fraction);
            if ($state == question_state::$gradedright) {
                return $answer;
            }
        }
        return null;
    }
}