Proyectos de Subversion Moodle

<?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/>.

/**

 * The default questiontype class.

 *

 * @package    moodlecore

 * @subpackage questiontypes

 * @copyright  1999 onwards Martin Dougiamas {@link http://moodle.com}

 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

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

require_once($CFG->dirroot . '/question/engine/lib.php');

require_once($CFG->libdir . '/questionlib.php');

/**

 * This is the base class for Moodle question types.

 *

 * There are detailed comments on each method, explaining what the method is

 * for, and the circumstances under which you might need to override it.

 *

 * Note: the questiontype API should NOT be considered stable yet. Very few

 * question types have been produced yet, so we do not yet know all the places

 * where the current API is insufficient. I would rather learn from the

 * experiences of the first few question type implementors, and improve the

 * interface to meet their needs, rather the freeze the API prematurely and

 * condem everyone to working round a clunky interface for ever afterwards.

 *

 * @copyright  1999 onwards Martin Dougiamas {@link http://moodle.com}

 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

class question_type {

    protected $fileoptions = array(

        'subdirs' => true,

        'maxfiles' => -1,

        'maxbytes' => 0,

    );

    public function __construct() {

    }

    /**

     * @return string the name of this question type.

     */

    public function name() {

        return substr(get_class($this), 6);

    }

    /**

     * @return string the full frankenstyle name for this plugin.

     */

    public function plugin_name() {

        return get_class($this);

    }

    /**

     * @return string the name of this question type in the user's language.

     * You should not need to override this method, the default behaviour should be fine.

     */

    public function local_name() {

        return get_string('pluginname', $this->plugin_name());

    }

    /**

     * The name this question should appear as in the create new question

     * dropdown. Override this method to return false if you don't want your

     * question type to be createable, for example if it is an abstract base type,

     * otherwise, you should not need to override this method.

     *

     * @return mixed the desired string, or false to hide this question type in the menu.

     */

    public function menu_name() {

        return $this->local_name();

    }

    /**

     * @return bool override this to return false if this is not really a

     *      question type, for example the description question type is not

     *      really a question type.

     */

    public function is_real_question_type() {

        return true;

    }

    /**

     * @return bool true if this question type sometimes requires manual grading.

     */

    public function is_manual_graded() {

        return false;

    }

    /**

     * @param object $question a question of this type.

     * @param string $otherquestionsinuse comma-separate list of other question ids in this attempt.

     * @return bool true if a particular instance of this question requires manual grading.

     */

    public function is_question_manual_graded($question, $otherquestionsinuse) {

        return $this->is_manual_graded();

    }

    /**

     * @return bool true if this question type can be used by the random question type.

     */

    public function is_usable_by_random() {

        return true;

    }

    /**

     * Whether this question type can perform a frequency analysis of student

     * responses.

     *

     * If this method returns true, you must implement the get_possible_responses

     * method, and the question_definition class must implement the

     * classify_response method.

     *

     * @return bool whether this report can analyse all the student responses

     * for things like the quiz statistics report.

     */

    public function can_analyse_responses() {

        // This works in most cases.

        return !$this->is_manual_graded();

    }

    /**

     * @return whether the question_answers.answer field needs to have

     * restore_decode_content_links_worker called on it.

     */

    public function has_html_answers() {

        return false;

    }

    /**

     * If your question type has a table that extends the question table, and

     * you want the base class to automatically save, backup and restore the extra fields,

     * override this method to return an array wherer the first element is the table name,

     * and the subsequent entries are the column names (apart from id and questionid).

     *

     * @return mixed array as above, or null to tell the base class to do nothing.

     */

    public function extra_question_fields() {

        return null;

    }

    /**

     * If you use extra_question_fields, overload this function to return question id field name

     *  in case you table use another name for this column

     */

    public function questionid_column_name() {

        return 'questionid';

    }

    /**

     * If your question type has a table that extends the question_answers table,

     * make this method return an array wherer the first element is the table name,

     * and the subsequent entries are the column names (apart from id and answerid).

     *

     * @return mixed array as above, or null to tell the base class to do nothing.

     */

    public function extra_answer_fields() {

        return null;

    }

    /**

     * If the quetsion type uses files in responses, then this method should

     * return an array of all the response variables that might have corresponding

     * files. For example, the essay qtype returns array('attachments', 'answers').

     *

     * @return array response variable names that may have associated files.

     */

    public function response_file_areas() {

        return array();

    }

    /**

     * Return an instance of the question editing form definition. This looks for a

     * class called edit_{$this->name()}_question_form in the file

     * question/type/{$this->name()}/edit_{$this->name()}_question_form.php

     * and if it exists returns an instance of it.

     *

     * @param string $submiturl passed on to the constructor call.

     * @return object an instance of the form definition, or null if one could not be found.

     */

    public function create_editing_form($submiturl, $question, $category,

            $contexts, $formeditable) {

        global $CFG;

        require_once($CFG->dirroot . '/question/type/edit_question_form.php');

        $definitionfile = $CFG->dirroot . '/question/type/' . $this->name() .

                '/edit_' . $this->name() . '_form.php';

        if (!is_readable($definitionfile) || !is_file($definitionfile)) {

            throw new coding_exception($this->plugin_name() .

                    ' is missing the definition of its editing formin file ' .

                    $definitionfile . '.');

        }

        require_once($definitionfile);

        $classname = $this->plugin_name() . '_edit_form';

        if (!class_exists($classname)) {

            throw new coding_exception($this->plugin_name() .

                    ' does not define the class ' . $this->plugin_name() .

                    '_edit_form.');

        }

        return new $classname($submiturl, $question, $category, $contexts, $formeditable);

    }

    /**

     * @return string the full path of the folder this plugin's files live in.

     */

    public function plugin_dir() {

        global $CFG;

        return $CFG->dirroot . '/question/type/' . $this->name();

    }

    /**

     * @return string the URL of the folder this plugin's files live in.

     */

    public function plugin_baseurl() {

        global $CFG;

        return $CFG->wwwroot . '/question/type/' . $this->name();

    }

    /**

     * Get extra actions for a question of this type to add to the question bank edit menu.

     *

     * This method is called if the {@link edit_menu_column} is being used in the

     * question bank, which it is by default since Moodle 3.8. If applicable for

     * your question type, you can return arn array of {@link action_menu_link}s.

     * These will be added at the end of the Edit menu for this question.

     *

     * The $question object passed in will have a hard-to-predict set of fields,

     * because the fields present depend on which columns are included in the

     * question bank view. However, you can rely on 'id', 'createdby',

     * 'contextid', 'hidden' and 'category' (id) being present, and so you

     * can call question_has_capability_on without causing performance problems.

     *

     * @param stdClass $question the available information about the particular question the action is for.

     * @return action_menu_link[] any actions you want to add to the Edit menu for this question.

     */

    public function get_extra_question_bank_actions(stdClass $question): array {

        return [];

    }

    /**

     * This method should be overriden if you want to include a special heading or some other

     * html on a question editing page besides the question editing form.

     *

     * @param question_edit_form $mform a child of question_edit_form

     * @param object $question

     * @param string $wizardnow is '' for first page.

     */

    public function display_question_editing_page($mform, $question, $wizardnow) {

        global $OUTPUT;

        $heading = $this->get_heading(empty($question->id));

        echo $OUTPUT->heading_with_help($heading, 'pluginname', $this->plugin_name());

        $mform->display();

    }

    /**

     * Method called by display_question_editing_page and by question.php to get

     * heading for breadcrumbs.

     *

     * @return string the heading

     */

    public function get_heading($adding = false) {

        if ($adding) {

            $string = 'pluginnameadding';

        } else {

            $string = 'pluginnameediting';

        }

        return get_string($string, $this->plugin_name());

    }

    /**

     * Set any missing settings for this question to the default values. This is

     * called before displaying the question editing form.

     *

     * @param object $questiondata the question data, loaded from the databsae,

     *      or more likely a newly created question object that is only partially

     *      initialised.

     */

    public function set_default_options($questiondata) {

    }

    /**

     * Return default value for a given form element either from user_preferences table or $default.

     *

     * @param string $name the name of the form element.

     * @param mixed $default default value.

     * @return string|null default value for a given  form element.

     */

    public function get_default_value(string $name, $default): ?string {

        return get_user_preferences($this->plugin_name() . '_' . $name, $default ?? '0');

    }

    /**

     * Save the default value for a given form element in user_preferences table.

     *

     * @param string $name the name of the value to set.

     * @param string $value the setting value.

     */

    public function set_default_value(string $name, string $value): void {

        set_user_preference($this->plugin_name() . '_' . $name, $value);

    }

    /**

     * Save question defaults when creating new questions.

     *

     * @param stdClass $fromform data from the form.

     */

    public function save_defaults_for_new_questions(stdClass $fromform): void {

        // Some question types may not make use of the certain form elements, so

        // we need to do a check on the following generic form elements. For instance,

        // 'defaultmark' is not use in qtype_multianswer and 'penalty' in not used in

        // qtype_essay and qtype_recordrtc.

        if (isset($fromform->defaultmark)) {

            $this->set_default_value('defaultmark', $fromform->defaultmark);

        }

        if (isset($fromform->penalty)) {

            $this->set_default_value('penalty', $fromform->penalty);

        }

    }

    /**

     * Saves (creates or updates) a question.

     *

     * Given some question info and some data about the answers

     * this function parses, organises and saves the question

     * It is used by {@link question.php} when saving new data from

     * a form, and also by {@link import.php} when importing questions

     * This function in turn calls {@link save_question_options}

     * to save question-type specific data.

     *

     * Whether we are saving a new question or updating an existing one can be

     * determined by testing !empty($question->id). If it is not empty, we are updating.

     *

     * The question will be saved in category $form->category.

     *

     * @param object $question the question object which should be updated. For a

     *      new question will be mostly empty.

     * @param object $form the object containing the information to save, as if

     *      from the question editing form.

     * @param object $course not really used any more.

     * @return object On success, return the new question object. On failure,

     *       return an object as follows. If the error object has an errors field,

     *       display that as an error message. Otherwise, the editing form will be

     *       redisplayed with validation errors, from validation_errors field, which

     *       is itself an object, shown next to the form fields. (I don't think this

     *       is accurate any more.)

     */

    public function save_question($question, $form) {

        global $USER, $DB;

        // The actual update/insert done with multiple DB access, so we do it in a transaction.

        $transaction = $DB->start_delegated_transaction ();

        list($form->category) = explode(',', $form->category);

        $context = $this->get_context_by_category_id($form->category);

        $question->category = $form->category;

        // This default implementation is suitable for most

        // question types.

        // First, save the basic question itself.

        $question->name = trim($form->name);

        $question->parent = isset($form->parent) ? $form->parent : 0;

        $question->length = $this->actual_number_of_questions($question);

        $question->penalty = isset($form->penalty) ? $form->penalty : 0;

        // The trim call below has the effect of casting any strange values received,

        // like null or false, to an appropriate string, so we only need to test for

        // missing values. Be careful not to break the value '0' here.

        if (!isset($form->questiontext['text'])) {

            $question->questiontext = '';

        } else {

            $question->questiontext = trim($form->questiontext['text']);

        }

        $question->questiontextformat = !empty($form->questiontext['format']) ?

                $form->questiontext['format'] : 0;

        if (empty($form->generalfeedback['text'])) {

            $question->generalfeedback = '';

        } else {

            $question->generalfeedback = trim($form->generalfeedback['text']);

        }

        $question->generalfeedbackformat = !empty($form->generalfeedback['format']) ?

                $form->generalfeedback['format'] : 0;

        if ($question->name === '') {

            $question->name = shorten_text(strip_tags($form->questiontext['text']), 15);

            if ($question->name === '') {

                $question->name = '-';

            }

        }

        if ($question->penalty > 1 or $question->penalty < 0) {

            $question->errors['penalty'] = get_string('invalidpenalty', 'question');

        }

        if (isset($form->defaultmark)) {

            $question->defaultmark = $form->defaultmark;

        }

        // Only create a new bank entry if the question is not a new version (New question or duplicating a question).

        $questionbankentry = null;

        if (isset($question->id)) {

            $oldparent = $question->id;

            if (!empty($question->id)) {

                // Get the bank entry record where the question is referenced.

                $questionbankentry = get_question_bank_entry($question->id);

            }

        }

        // Get the bank entry old id (this is when there are questions related with a parent, e.g.: qtype_multianswers).

        if (isset($question->oldid)) {

            if (!empty($question->oldid)) {

                $questionbankentry = get_question_bank_entry($question->oldid);

            }

        }

        // Always creates a new question and version record.

        // Set the unique code.

        $question->stamp = make_unique_id_code();

        $question->createdby = $USER->id;

        $question->timecreated = time();

        // Idnumber validation.

        $question->idnumber = null;

        if (isset($form->idnumber)) {

            if ((string) $form->idnumber === '') {

                $question->idnumber = null;

            } else {

                // While this check already exists in the form validation,

                // this is a backstop preventing unnecessary errors.

                // Only set the idnumber if it has changed and will not cause a unique index violation.

                if (strpos($form->category, ',') !== false) {

                    list($category, $categorycontextid) = explode(',', $form->category);

                } else {

                    $category = $form->category;

                }

                $params = ['idnumber' => $form->idnumber, 'categoryid' => $category];

                $andcondition = '';

                if (isset($question->id) && isset($questionbankentry->id)) {

                    $andcondition = 'AND qbe.id != :notid';

                    $params['notid'] = $questionbankentry->id;

                }

                $sql = "SELECT qbe.id

                          FROM {question_bank_entries} qbe

                         WHERE qbe.idnumber = :idnumber

                               AND qbe.questioncategoryid = :categoryid

                           $andcondition";

                if (!$DB->record_exists_sql($sql, $params)) {

                    $question->idnumber = $form->idnumber;

                }

            }

        }

        // Create the question.

        $question->id = $DB->insert_record('question', $question);

        if (!$questionbankentry) {

            // Create a record for question_bank_entries, question_versions and question_references.

            $questionbankentry = new \stdClass();

            $questionbankentry->questioncategoryid = $form->category;

            $questionbankentry->idnumber = $question->idnumber;

            $questionbankentry->ownerid = $question->createdby;

            $questionbankentry->id = $DB->insert_record('question_bank_entries', $questionbankentry);

        } else {

            $questionbankentryold = new \stdClass();

            $questionbankentryold->id = $questionbankentry->id;

            $questionbankentryold->idnumber = $question->idnumber;

            $DB->update_record('question_bank_entries', $questionbankentryold);

        }

        // Create question_versions records.

        $questionversion = new \stdClass();

        $questionversion->questionbankentryid = $questionbankentry->id;

        $questionversion->questionid = $question->id;

        // Get the version and status from the parent question if parent is set.

        if (!$question->parent) {

            // Get the status field. It comes from the form, but for testing we can.

            $status = $form->status ?? $question->status ??

                \core_question\local\bank\question_version_status::QUESTION_STATUS_READY;

            $questionversion->version = get_next_version($questionbankentry->id);

            $questionversion->status = $status;

        } else {

            $parentversion = get_question_version($form->parent);

            $questionversion->version = $parentversion[array_key_first($parentversion)]->version;

            $questionversion->status = $parentversion[array_key_first($parentversion)]->status;

        }

        $questionversion->id = $DB->insert_record('question_versions', $questionversion);

        // Now, whether we are updating a existing question, or creating a new

        // one, we have to do the files processing and update the record.

        // Question already exists, update.

        $question->modifiedby = $USER->id;

        $question->timemodified = time();

        if (!empty($question->questiontext) && !empty($form->questiontext['itemid'])) {

            $question->questiontext = file_save_draft_area_files($form->questiontext['itemid'],

                    $context->id, 'question', 'questiontext', (int)$question->id,

                    $this->fileoptions, $question->questiontext);

        }

        if (!empty($question->generalfeedback) && !empty($form->generalfeedback['itemid'])) {

            $question->generalfeedback = file_save_draft_area_files(

                    $form->generalfeedback['itemid'], $context->id,

                    'question', 'generalfeedback', (int)$question->id,

                    $this->fileoptions, $question->generalfeedback);

        }

        $DB->update_record('question', $question);

        // Now to save all the answers and type-specific options.

        $form->id = $question->id;

        $form->qtype = $question->qtype;

        $form->questiontext = $question->questiontext;

        $form->questiontextformat = $question->questiontextformat;

        // Current context.

        $form->context = $context;

        // Old parent question id is used when there are questions related with a parent, e.g.: qtype_multianswers).

        if (isset($oldparent)) {

            $form->oldparent = $oldparent;

        } else {

            $form->oldparent = $question->parent;

        }

        $result = $this->save_question_options($form);

        if (!empty($result->error)) {

            throw new \moodle_exception($result->error);

        }

        if (!empty($result->notice)) {

            notice($result->notice, "question.php?id={$question->id}");

        }

        if (!empty($result->noticeyesno)) {

            throw new coding_exception(

                    '$result->noticeyesno no longer supported in save_question.');

        }

        // Log the creation of this question.

        $event = \core\event\question_created::create_from_question_instance($question, $context);

        $event->trigger();

        $transaction->allow_commit();

        return $question;

    }

    /**

     * Saves question-type specific options

     *

     * This is called by {@see save_question()} to save the question-type specific data

     *

     * @param object $question This holds the information from the editing form,

     *      it is not a standard question object.

     * @return bool|stdClass $result->error or $result->notice

     */

    public function save_question_options($question) {

        global $DB;

        $extraquestionfields = $this->extra_question_fields();

        if (is_array($extraquestionfields)) {

            $question_extension_table = array_shift($extraquestionfields);

            $function = 'update_record';

            $questionidcolname = $this->questionid_column_name();

            $options = $DB->get_record($question_extension_table,

                    array($questionidcolname => $question->id));

            if (!$options) {

                $function = 'insert_record';

                $options = new stdClass();

                $options->$questionidcolname = $question->id;

            }

            foreach ($extraquestionfields as $field) {

                if (property_exists($question, $field)) {

                    $options->$field = $question->$field;

                }

            }

            $DB->{$function}($question_extension_table, $options);

        }

    }

    /**

     * Save the answers, with any extra data.

     *

     * Questions that use answers will call it from {@link save_question_options()}.

     * @param object $question  This holds the information from the editing form,

     *      it is not a standard question object.

     * @return object $result->error or $result->notice

     */

    public function save_question_answers($question) {

        global $DB;

        $context = $question->context;

        $oldanswers = $DB->get_records('question_answers',

                array('question' => $question->id), 'id ASC');

        // We need separate arrays for answers and extra answer data, so no JOINS there.

        $extraanswerfields = $this->extra_answer_fields();

        $isextraanswerfields = is_array($extraanswerfields);

        $extraanswertable = '';

        $oldanswerextras = array();

        if ($isextraanswerfields) {

            $extraanswertable = array_shift($extraanswerfields);

            if (!empty($oldanswers)) {

                $oldanswerextras = $DB->get_records_sql("SELECT * FROM {{$extraanswertable}} WHERE " .

                    'answerid IN (SELECT id FROM {question_answers} WHERE question = ' . $question->id . ')' );

            }

        }

        // Insert all the new answers.

        foreach ($question->answer as $key => $answerdata) {

            // Check for, and ignore, completely blank answer from the form.

            if ($this->is_answer_empty($question, $key)) {

                continue;

            }

            // Update an existing answer if possible.

            $answer = array_shift($oldanswers);

            if (!$answer) {

                $answer = new stdClass();

                $answer->question = $question->id;

                $answer->answer = '';

                $answer->feedback = '';

                $answer->id = $DB->insert_record('question_answers', $answer);

            }

            $answer = $this->fill_answer_fields($answer, $question, $key, $context);

            $DB->update_record('question_answers', $answer);

            if ($isextraanswerfields) {

                // Check, if this answer contains some extra field data.

                if ($this->is_extra_answer_fields_empty($question, $key)) {

                    continue;

                }

                $answerextra = array_shift($oldanswerextras);

                if (!$answerextra) {

                    $answerextra = new stdClass();

                    $answerextra->answerid = $answer->id;

                    // Avoid looking for correct default for any possible DB field type

                    // by setting real values.

                    $answerextra = $this->fill_extra_answer_fields($answerextra, $question, $key, $context, $extraanswerfields);

                    $answerextra->id = $DB->insert_record($extraanswertable, $answerextra);

                } else {

                    // Update answerid, as record may be reused from another answer.

                    $answerextra->answerid = $answer->id;

                    $answerextra = $this->fill_extra_answer_fields($answerextra, $question, $key, $context, $extraanswerfields);

                    $DB->update_record($extraanswertable, $answerextra);

                }

            }

        }

        if ($isextraanswerfields) {

            // Delete any left over extra answer fields records.

            $oldanswerextraids = array();

            foreach ($oldanswerextras as $oldextra) {

                $oldanswerextraids[] = $oldextra->id;

            }

            $DB->delete_records_list($extraanswertable, 'id', $oldanswerextraids);

        }

        // Delete any left over old answer records.

        $fs = get_file_storage();

        foreach ($oldanswers as $oldanswer) {

            $fs->delete_area_files($context->id, 'question', 'answerfeedback', $oldanswer->id);

            $DB->delete_records('question_answers', array('id' => $oldanswer->id));

        }

    }

    /**

     * Returns true is answer with the $key is empty in the question data and should not be saved in DB.

     *

     * The questions using question_answers table may want to overload this. Default code will work

     * for shortanswer and similar question types.

     * @param object $questiondata This holds the information from the question editing form or import.

     * @param int $key A key of the answer in question.

     * @return bool True if answer shouldn't be saved in DB.

     */

    protected function is_answer_empty($questiondata, $key) {

        return trim($questiondata->answer[$key]) == '' && $questiondata->fraction[$key] == 0 &&

                    html_is_blank($questiondata->feedback[$key]['text']);

    }

    /**

     * Return $answer, filling necessary fields for the question_answers table.

     *

     * The questions using question_answers table may want to overload this. Default code will work

     * for shortanswer and similar question types.

     * @param stdClass $answer Object to save data.

     * @param object $questiondata This holds the information from the question editing form or import.

     * @param int $key A key of the answer in question.

     * @param object $context needed for working with files.

     * @return $answer answer with filled data.

     */

    protected function fill_answer_fields($answer, $questiondata, $key, $context) {

        $answer->answer   = $questiondata->answer[$key];

        $answer->fraction = $questiondata->fraction[$key];

        $answer->feedback = $this->import_or_save_files($questiondata->feedback[$key],

                $context, 'question', 'answerfeedback', $answer->id);

        $answer->feedbackformat = $questiondata->feedback[$key]['format'];

        return $answer;

    }

    /**

     * Returns true if extra answer fields for answer with the $key is empty

     * in the question data and should not be saved in DB.

     *

     * Questions where extra answer fields are optional will want to overload this.

     * @param object $questiondata This holds the information from the question editing form or import.

     * @param int $key A key of the answer in question.

     * @return bool True if extra answer data shouldn't be saved in DB.

     */

    protected function is_extra_answer_fields_empty($questiondata, $key) {

        // No extra answer data in base class.

        return true;

    }

    /**

     * Return $answerextra, filling necessary fields for the extra answer fields table.

     *

     * The questions may want to overload it to save files or do other data processing.

     * @param stdClass $answerextra Object to save data.

     * @param object $questiondata This holds the information from the question editing form or import.

     * @param int $key A key of the answer in question.

     * @param object $context needed for working with files.

     * @param array $extraanswerfields extra answer fields (without table name).

     * @return $answer answerextra with filled data.

     */

    protected function fill_extra_answer_fields($answerextra, $questiondata, $key, $context, $extraanswerfields) {

        foreach ($extraanswerfields as $field) {

            // The $questiondata->$field[$key] won't work in PHP, break it down to two strings of code.

            $fieldarray = $questiondata->$field;

            $answerextra->$field = $fieldarray[$key];

        }

        return $answerextra;

    }

    public function save_hints($formdata, $withparts = false) {

        global $DB;

        $context = $formdata->context;

        $oldhints = $DB->get_records('question_hints',

                array('questionid' => $formdata->id), 'id ASC');

        $numhints = $this->count_hints_on_form($formdata, $withparts);

        for ($i = 0; $i < $numhints; $i += 1) {

            if (html_is_blank($formdata->hint[$i]['text'])) {

                $formdata->hint[$i]['text'] = '';

            }

            if ($withparts) {

                $clearwrong = !empty($formdata->hintclearwrong[$i]);

                $shownumcorrect = !empty($formdata->hintshownumcorrect[$i]);

            }

            if ($this->is_hint_empty_in_form_data($formdata, $i, $withparts)) {

                continue;

            }

            // Update an existing hint if possible.

            $hint = array_shift($oldhints);

            if (!$hint) {

                $hint = new stdClass();

                $hint->questionid = $formdata->id;

                $hint->hint = '';

                $hint->id = $DB->insert_record('question_hints', $hint);

            }

            $hint->hint = $this->import_or_save_files($formdata->hint[$i],

                    $context, 'question', 'hint', $hint->id);

            $hint->hintformat = $formdata->hint[$i]['format'];

            if ($withparts) {

                $hint->clearwrong = $clearwrong;

                $hint->shownumcorrect = $shownumcorrect;

            }

            $hint->options = $this->save_hint_options($formdata, $i, $withparts);

            $DB->update_record('question_hints', $hint);

        }

        // Delete any remaining old hints.

        $fs = get_file_storage();

        foreach ($oldhints as $oldhint) {

            $fs->delete_area_files($context->id, 'question', 'hint', $oldhint->id);

            $DB->delete_records('question_hints', array('id' => $oldhint->id));

        }

    }

    /**

     * Count number of hints on the form.

     * Overload if you use custom hint controls.

     * @param object $formdata the data from the form.

     * @param bool $withparts whether to take into account clearwrong and shownumcorrect options.

     * @return int count of hints on the form.

     */

    protected function count_hints_on_form($formdata, $withparts) {

        if (!empty($formdata->hint)) {

            $numhints = max(array_keys($formdata->hint)) + 1;

        } else {

            $numhints = 0;

        }

        if ($withparts) {

            if (!empty($formdata->hintclearwrong)) {

                $numclears = max(array_keys($formdata->hintclearwrong)) + 1;

            } else {

                $numclears = 0;

            }

            if (!empty($formdata->hintshownumcorrect)) {

                $numshows = max(array_keys($formdata->hintshownumcorrect)) + 1;

            } else {

                $numshows = 0;

            }

            $numhints = max($numhints, $numclears, $numshows);

        }

        return $numhints;

    }

    /**

     * Determine if the hint with specified number is not empty and should be saved.

     * Overload if you use custom hint controls.

     * @param object $formdata the data from the form.

     * @param int $number number of hint under question.

     * @param bool $withparts whether to take into account clearwrong and shownumcorrect options.

     * @return bool is this particular hint data empty.

     */

    protected function is_hint_empty_in_form_data($formdata, $number, $withparts) {

        if ($withparts) {

            return empty($formdata->hint[$number]['text']) && empty($formdata->hintclearwrong[$number]) &&

                    empty($formdata->hintshownumcorrect[$number]);

        } else {

            return  empty($formdata->hint[$number]['text']);

        }

    }

    /**

     * Save additional question type data into the hint optional field.

     * Overload if you use custom hint information.

     * @param object $formdata the data from the form.

     * @param int $number number of hint to get options from.

     * @param bool $withparts whether question have parts.

     * @return string value to save into the options field of question_hints table.

     */

    protected function save_hint_options($formdata, $number, $withparts) {

        return null;    // By default, options field is unused.

    }

    /**

     * Can be used to {@link save_question_options()} to transfer the combined

     * feedback fields from $formdata to $options.

     * @param object $options the $question->options object being built.

     * @param object $formdata the data from the form.

     * @param object $context the context the quetsion is being saved into.

     * @param bool $withparts whether $options->shownumcorrect should be set.

     */

    protected function save_combined_feedback_helper($options, $formdata,

            $context, $withparts = false) {

        $options->correctfeedback = $this->import_or_save_files($formdata->correctfeedback,

                $context, 'question', 'correctfeedback', $formdata->id);

        $options->correctfeedbackformat = $formdata->correctfeedback['format'];

        $options->partiallycorrectfeedback = $this->import_or_save_files(

                $formdata->partiallycorrectfeedback,

                $context, 'question', 'partiallycorrectfeedback', $formdata->id);

        $options->partiallycorrectfeedbackformat = $formdata->partiallycorrectfeedback['format'];

        $options->incorrectfeedback = $this->import_or_save_files($formdata->incorrectfeedback,

                $context, 'question', 'incorrectfeedback', $formdata->id);

        $options->incorrectfeedbackformat = $formdata->incorrectfeedback['format'];

        if ($withparts) {

            $options->shownumcorrect = !empty($formdata->shownumcorrect);

        }

        return $options;

    }

    /**

     * Loads the question type specific options for the question.

     *

     * This function loads any question type specific options for the

     * question from the database into the question object. This information

     * is placed in the $question->options field. A question type is

     * free, however, to decide on a internal structure of the options field.

     * @return bool            Indicates success or failure.

     * @param object $question The question object for the question. This object

     *                         should be updated to include the question type

     *                         specific information (it is passed by reference).

     */

    public function get_question_options($question) {

        global $DB, $OUTPUT;

        if (!isset($question->options)) {

            $question->options = new stdClass();

        }

        $extraquestionfields = $this->extra_question_fields();

        if (is_array($extraquestionfields)) {

            $question_extension_table = array_shift($extraquestionfields);

            $extra_data = $DB->get_record($question_extension_table,

                    array($this->questionid_column_name() => $question->id),

                    implode(', ', $extraquestionfields));

            if ($extra_data) {

                foreach ($extraquestionfields as $field) {

                    $question->options->$field = $extra_data->$field;

                }

            } else {

                echo $OUTPUT->notification('Failed to load question options from the table ' .

                        $question_extension_table . ' for questionid ' . $question->id);

                return false;

            }

        }

        $extraanswerfields = $this->extra_answer_fields();

        if (is_array($extraanswerfields)) {

            $answerextensiontable = array_shift($extraanswerfields);

            // Use LEFT JOIN in case not every answer has extra data.

            $answers = $DB->get_records_sql("

                    SELECT qa.*, qax." . implode(', qax.', $extraanswerfields) . '

                    FROM {question_answers} qa ' . "

                    LEFT JOIN {{$answerextensiontable}} qax ON qa.id = qax.answerid

                    WHERE qa.question = ?

                    ORDER BY qa.id", array($question->id));

            if (!$answers) {

                echo $OUTPUT->notification('Failed to load question answers from the table ' .

                        $answerextensiontable . 'for questionid ' . $question->id);

                return false;

            }

        } else {

            // Don't check for success or failure because some question types do

            // not use the answers table.

            $answers = $DB->get_records('question_answers',

                    array('question' => $question->id), 'id ASC');

        }

        // Store the answers into the question object.

        $question->options->answers = array_map(function($answer) {

            // Some database engines return floats as strings like '1.0000000'. Cast to float for consistency.

            $answer->fraction = (float) $answer->fraction;

            return $answer;

        }, $answers);

        $question->hints = $DB->get_records('question_hints',

                array('questionid' => $question->id), 'id ASC');

        return true;

    }

    /**

     * Create an appropriate question_definition for the question of this type

     * using data loaded from the database.

     * @param object $questiondata the question data loaded from the database.

     * @return question_definition the corresponding question_definition.

     */

    public function make_question($questiondata) {

        $question = $this->make_question_instance($questiondata);

        $this->initialise_question_instance($question, $questiondata);

        return $question;

    }

    /**

     * Create an appropriate question_definition for the question of this type

     * using data loaded from the database.

     * @param object $questiondata the question data loaded from the database.

     * @return question_definition an instance of the appropriate question_definition subclass.

     *      Still needs to be initialised.

     */

    protected function make_question_instance($questiondata) {

        question_bank::load_question_definition_classes($this->name());

        $class = 'qtype_' . $this->name() . '_question';

        return new $class();

    }

    /**

     * Initialise the common question_definition fields.

     * @param question_definition $question the question_definition we are creating.

     * @param object $questiondata the question data loaded from the database.

     */

    protected function initialise_question_instance(question_definition $question, $questiondata) {

        $question->id = $questiondata->id;

        $question->category = $questiondata->category;

        $question->contextid = $questiondata->contextid;

        $question->parent = $questiondata->parent;

        $question->qtype = $this;

        $question->name = $questiondata->name;