Ir a la última revisión | Autoría | Comparar con el anterior | Ultima modificación | Ver Log |
<?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.idFROM {question_bank_entries} qbeWHERE qbe.idnumber = :idnumberAND 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.answeridWHERE 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;$question->questiontext = $questiondata->questiontext;$question->questiontextformat = $questiondata->questiontextformat;$question->generalfeedback = $questiondata->generalfeedback;$question->generalfeedbackformat = $questiondata->generalfeedbackformat;$question->defaultmark = $questiondata->defaultmark + 0;$question->length = $questiondata->length;$question->penalty = $questiondata->penalty;$question->stamp = $questiondata->stamp;$question->timecreated = $questiondata->timecreated;$question->timemodified = $questiondata->timemodified;$question->createdby = $questiondata->createdby;$question->modifiedby = $questiondata->modifiedby;$this->initialise_core_question_metadata($question, $questiondata);// Fill extra question fields values.$extraquestionfields = $this->extra_question_fields();if (is_array($extraquestionfields)) {// Omit table name.array_shift($extraquestionfields);foreach ($extraquestionfields as $field) {$question->$field = $questiondata->options->$field;}}$this->initialise_question_hints($question, $questiondata);// Add the custom fields.$this->initialise_custom_fields($question, $questiondata);}/*** Initialise the question metadata.** @param question_definition $question the question_definition we are creating.* @param object $questiondata the question data loaded from the database.*/protected function initialise_core_question_metadata(question_definition $question, $questiondata) {$fields =['status','versionid','version','questionbankentryid','idnumber',];foreach ($fields as $field) {if (isset($questiondata->{$field})) {$question->{$field} = $questiondata->{$field};}}}/*** Initialise question_definition::hints field.* @param question_definition $question the question_definition we are creating.* @param object $questiondata the question data loaded from the database.*/protected function initialise_question_hints(question_definition $question, $questiondata) {if (empty($questiondata->hints)) {return;}foreach ($questiondata->hints as $hint) {$question->hints[] = $this->make_hint($hint);}}/*** Create a question_hint, or an appropriate subclass for this question,* from a row loaded from the database.* @param object $hint the DB row from the question hints table.* @return question_hint*/protected function make_hint($hint) {return question_hint::load_from_record($hint);}/*** Initialise question custom fields.* @param question_definition $question the question_definition we are creating.* @param object $questiondata the question data loaded from the database.*/protected function initialise_custom_fields(question_definition $question, $questiondata) {if (!empty($questiondata->customfields)) {$question->customfields = $questiondata->customfields;}}/*** Initialise the combined feedback fields.* @param question_definition $question the question_definition we are creating.* @param object $questiondata the question data loaded from the database.* @param bool $withparts whether to set the shownumcorrect field.*/protected function initialise_combined_feedback(question_definition $question,$questiondata, $withparts = false) {$question->correctfeedback = $questiondata->options->correctfeedback;$question->correctfeedbackformat = $questiondata->options->correctfeedbackformat;$question->partiallycorrectfeedback = $questiondata->options->partiallycorrectfeedback;$question->partiallycorrectfeedbackformat =$questiondata->options->partiallycorrectfeedbackformat;$question->incorrectfeedback = $questiondata->options->incorrectfeedback;$question->incorrectfeedbackformat = $questiondata->options->incorrectfeedbackformat;if ($withparts) {$question->shownumcorrect = $questiondata->options->shownumcorrect;}}/*** Initialise question_definition::answers field.* @param question_definition $question the question_definition we are creating.* @param object $questiondata the question data loaded from the database.* @param bool $forceplaintextanswers most qtypes assume that answers are* FORMAT_PLAIN, and dont use the answerformat DB column (it contains* the default 0 = FORMAT_MOODLE). Therefore, by default this method* ingores answerformat. Pass false here to use answerformat. For example* multichoice does this.*/protected function initialise_question_answers(question_definition $question,$questiondata, $forceplaintextanswers = true) {$question->answers = array();if (empty($questiondata->options->answers)) {return;}foreach ($questiondata->options->answers as $a) {$question->answers[$a->id] = $this->make_answer($a);if (!$forceplaintextanswers) {$question->answers[$a->id]->answerformat = $a->answerformat;}}}/*** Create a question_answer, or an appropriate subclass for this question,* from a row loaded from the database.* @param object $answer the DB row from the question_answers table plus extra answer fields.* @return question_answer*/protected function make_answer($answer) {return new question_answer($answer->id, $answer->answer,$answer->fraction, $answer->feedback, $answer->feedbackformat);}/*** Deletes the question-type specific data when a question is deleted.* @param int $question the question being deleted.* @param int $contextid the context this quesiotn belongs to.*/public function delete_question($questionid, $contextid) {global $DB;$this->delete_files($questionid, $contextid);$extraquestionfields = $this->extra_question_fields();if (is_array($extraquestionfields)) {$question_extension_table = array_shift($extraquestionfields);$DB->delete_records($question_extension_table,array($this->questionid_column_name() => $questionid));}$extraanswerfields = $this->extra_answer_fields();if (is_array($extraanswerfields)) {$answer_extension_table = array_shift($extraanswerfields);$DB->delete_records_select($answer_extension_table,'answerid IN (SELECT qa.id FROM {question_answers} qa WHERE qa.question = ?)',array($questionid));}$DB->delete_records('question_answers', array('question' => $questionid));$DB->delete_records('question_hints', array('questionid' => $questionid));}/*** Returns the number of question numbers which are used by the question** This function returns the number of question numbers to be assigned* to the question. Most question types will have length one; they will be* assigned one number. The 'description' type, however does not use up a* number and so has a length of zero. Other question types may wish to* handle a bundle of questions and hence return a number greater than one.* @return int The number of question numbers which should be* assigned to the question.* @param object $question The question whose length is to be determined.* Question type specific information is included.*/public function actual_number_of_questions($question) {// By default, each question is given one number.return 1;}/*** Calculate the score a monkey would get on a question by clicking randomly.** Some question types have significant non-zero average expected score* of the response is just selected randomly. For example 50% for a* true-false question. It is useful to know what this is. For example* it gets shown in the quiz statistics report.** For almost any open-ended question type (E.g. shortanswer or numerical)* this should be 0.** For selective response question types (e.g. multiple choice), you can probably compute this.** For particularly complicated question types the may be impossible or very* difficult to compute. In this case return null. (Or, if the expected score* is very tiny even though the exact value is unknown, it may appropriate* to return 0.)** @param stdClass $questiondata data defining a question, as returned by* question_bank::load_question_data().* @return number|null either a fraction estimating what the student would* score by guessing, or null, if it is not possible to estimate.*/public function get_random_guess_score($questiondata) {return 0;}/*** Whether or not to break down question stats and response analysis, for a question defined by $questiondata.** @param object $questiondata The full question definition data.* @return bool*/public function break_down_stats_and_response_analysis_by_variant($questiondata) {return true;}/*** This method should return all the possible types of response that are* recognised for this question.** The question is modelled as comprising one or more subparts. For each* subpart, there are one or more classes that that students response* might fall into, each of those classes earning a certain score.** For example, in a shortanswer question, there is only one subpart, the* text entry field. The response the student gave will be classified according* to which of the possible $question->options->answers it matches.** For the matching question type, there will be one subpart for each* question stem, and for each stem, each of the possible choices is a class* of student's response.** A response is an object with two fields, ->responseclass is a string* presentation of that response, and ->fraction, the credit for a response* in that class.** Array keys have no specific meaning, but must be unique, and must be* the same if this function is called repeatedly.** @param object $question the question definition data.* @return array keys are subquestionid, values are arrays of possible* responses to that subquestion.*/public function get_possible_responses($questiondata) {return array();}/*** Utility method used by {@link qtype_renderer::head_code()}. It looks* for any of the files script.js or script.php that exist in the plugin* folder and ensures they get included.*/public function find_standard_scripts() {global $PAGE;$plugindir = $this->plugin_dir();$plugindirrel = 'question/type/' . $this->name();if (file_exists($plugindir . '/script.js')) {$PAGE->requires->js('/' . $plugindirrel . '/script.js');}if (file_exists($plugindir . '/script.php')) {$PAGE->requires->js('/' . $plugindirrel . '/script.php');}}/*** Returns true if the editing wizard is finished, false otherwise.** The default implementation returns true, which is suitable for all question-* types that only use one editing form. This function is used in* question.php to decide whether we can regrade any states of the edited* question and redirect to edit.php.** The dataset dependent question-type, which is extended by the calculated* question-type, overwrites this method because it uses multiple pages (i.e.* a wizard) to set up the question and associated datasets.** @param object $form The data submitted by the previous page.** @return bool Whether the wizard's last page was submitted or not.*/public function finished_edit_wizard($form) {// In the default case there is only one edit page.return true;}// IMPORT/EXPORT FUNCTIONS --------------------------------- ./** Imports question from the Moodle XML format** Imports question using information from extra_question_fields function* If some of you fields contains id's you'll need to reimplement this*/public function import_from_xml($data, $question, qformat_xml $format, $extra=null) {$question_type = $data['@']['type'];if ($question_type != $this->name()) {return false;}$extraquestionfields = $this->extra_question_fields();if (!is_array($extraquestionfields)) {return false;}// Omit table name.array_shift($extraquestionfields);$qo = $format->import_headers($data);$qo->qtype = $question_type;foreach ($extraquestionfields as $field) {$qo->$field = $format->getpath($data, array('#', $field, 0, '#'), '');}// Run through the answers.$answers = $data['#']['answer'];$a_count = 0;$extraanswersfields = $this->extra_answer_fields();if (is_array($extraanswersfields)) {array_shift($extraanswersfields);}foreach ($answers as $answer) {$ans = $format->import_answer($answer);if (!$this->has_html_answers()) {$qo->answer[$a_count] = $ans->answer['text'];} else {$qo->answer[$a_count] = $ans->answer;}$qo->fraction[$a_count] = $ans->fraction;$qo->feedback[$a_count] = $ans->feedback;if (is_array($extraanswersfields)) {foreach ($extraanswersfields as $field) {$qo->{$field}[$a_count] =$format->getpath($answer, array('#', $field, 0, '#'), '');}}++$a_count;}return $qo;}/** Export question to the Moodle XML format** Export question using information from extra_question_fields function* If some of you fields contains id's you'll need to reimplement this*/public function export_to_xml($question, qformat_xml $format, $extra=null) {$extraquestionfields = $this->extra_question_fields();if (!is_array($extraquestionfields)) {return false;}// Omit table name.array_shift($extraquestionfields);$expout='';foreach ($extraquestionfields as $field) {$exportedvalue = $format->xml_escape($question->options->$field);$expout .= " <{$field}>{$exportedvalue}</{$field}>\n";}$extraanswersfields = $this->extra_answer_fields();if (is_array($extraanswersfields)) {array_shift($extraanswersfields);}foreach ($question->options->answers as $answer) {$extra = '';if (is_array($extraanswersfields)) {foreach ($extraanswersfields as $field) {$exportedvalue = $format->xml_escape($answer->$field);$extra .= " <{$field}>{$exportedvalue}</{$field}>\n";}}$expout .= $format->write_answer($answer, $extra);}return $expout;}/*** Abstract function implemented by each question type. It runs all the code* required to set up and save a question of any type for testing purposes.* Alternate DB table prefix may be used to facilitate data deletion.*/public function generate_test($name, $courseid=null) {$form = new stdClass();$form->name = $name;$form->questiontextformat = 1;$form->questiontext = 'test question, generated by script';$form->defaultmark = 1;$form->penalty = 0.3333333;$form->status = \core_question\local\bank\question_version_status::QUESTION_STATUS_READY;$form->generalfeedback = "Well done";$context = context_course::instance($courseid);$newcategory = question_make_default_categories(array($context));$form->category = $newcategory->id . ',1';$question = new stdClass();$question->courseid = $courseid;$question->qtype = $this->name();return array($form, $question);}/*** Get question context by category id* @param int $category* @return object $context*/protected function get_context_by_category_id($category) {global $DB;$contextid = $DB->get_field('question_categories', 'contextid', array('id'=>$category));$context = context::instance_by_id($contextid, IGNORE_MISSING);return $context;}/*** Save the file belonging to one text field.** @param array $field the data from the form (or from import). This will* normally have come from the formslib editor element, so it will be an* array with keys 'text', 'format' and 'itemid'. However, when we are* importing, it will be an array with keys 'text', 'format' and 'files'* @param object $context the context the question is in.* @param string $component indentifies the file area question.* @param string $filearea indentifies the file area questiontext,* generalfeedback, answerfeedback, etc.* @param int $itemid identifies the file area.** @return string the text for this field, after files have been processed.*/protected function import_or_save_files($field, $context, $component, $filearea, $itemid) {if (!empty($field['itemid'])) {// This is the normal case. We are safing the questions editing form.return file_save_draft_area_files($field['itemid'], $context->id, $component,$filearea, $itemid, $this->fileoptions, trim($field['text']));} else if (!empty($field['files'])) {// This is the case when we are doing an import.foreach ($field['files'] as $file) {$this->import_file($context, $component, $filearea, $itemid, $file);}}return trim($field['text']);}/*** Move all the files belonging to this question from one context to another.* @param int $questionid the question being moved.* @param int $oldcontextid the context it is moving from.* @param int $newcontextid the context it is moving to.*/public function move_files($questionid, $oldcontextid, $newcontextid) {$fs = get_file_storage();$fs->move_area_files_to_new_context($oldcontextid,$newcontextid, 'question', 'questiontext', $questionid);$fs->move_area_files_to_new_context($oldcontextid,$newcontextid, 'question', 'generalfeedback', $questionid);}/*** Move all the files belonging to this question's answers when the question* is moved from one context to another.* @param int $questionid the question being moved.* @param int $oldcontextid the context it is moving from.* @param int $newcontextid the context it is moving to.* @param bool $answerstoo whether there is an 'answer' question area,* as well as an 'answerfeedback' one. Default false.*/protected function move_files_in_answers($questionid, $oldcontextid,$newcontextid, $answerstoo = false) {global $DB;$fs = get_file_storage();$answerids = $DB->get_records_menu('question_answers',array('question' => $questionid), 'id', 'id,1');foreach ($answerids as $answerid => $notused) {if ($answerstoo) {$fs->move_area_files_to_new_context($oldcontextid,$newcontextid, 'question', 'answer', $answerid);}$fs->move_area_files_to_new_context($oldcontextid,$newcontextid, 'question', 'answerfeedback', $answerid);}}/*** Move all the files belonging to this question's hints when the question* is moved from one context to another.* @param int $questionid the question being moved.* @param int $oldcontextid the context it is moving from.* @param int $newcontextid the context it is moving to.* @param bool $answerstoo whether there is an 'answer' question area,* as well as an 'answerfeedback' one. Default false.*/protected function move_files_in_hints($questionid, $oldcontextid, $newcontextid) {global $DB;$fs = get_file_storage();$hintids = $DB->get_records_menu('question_hints',array('questionid' => $questionid), 'id', 'id,1');foreach ($hintids as $hintid => $notused) {$fs->move_area_files_to_new_context($oldcontextid,$newcontextid, 'question', 'hint', $hintid);}}/*** Move all the files belonging to this question's answers when the question* is moved from one context to another.* @param int $questionid the question being moved.* @param int $oldcontextid the context it is moving from.* @param int $newcontextid the context it is moving to.* @param bool $answerstoo whether there is an 'answer' question area,* as well as an 'answerfeedback' one. Default false.*/protected function move_files_in_combined_feedback($questionid, $oldcontextid,$newcontextid) {global $DB;$fs = get_file_storage();$fs->move_area_files_to_new_context($oldcontextid,$newcontextid, 'question', 'correctfeedback', $questionid);$fs->move_area_files_to_new_context($oldcontextid,$newcontextid, 'question', 'partiallycorrectfeedback', $questionid);$fs->move_area_files_to_new_context($oldcontextid,$newcontextid, 'question', 'incorrectfeedback', $questionid);}/*** Delete all the files belonging to this question.* @param int $questionid the question being deleted.* @param int $contextid the context the question is in.*/protected function delete_files($questionid, $contextid) {$fs = get_file_storage();$fs->delete_area_files($contextid, 'question', 'questiontext', $questionid);$fs->delete_area_files($contextid, 'question', 'generalfeedback', $questionid);}/*** Delete all the files belonging to this question's answers.* @param int $questionid the question being deleted.* @param int $contextid the context the question is in.* @param bool $answerstoo whether there is an 'answer' question area,* as well as an 'answerfeedback' one. Default false.*/protected function delete_files_in_answers($questionid, $contextid, $answerstoo = false) {global $DB;$fs = get_file_storage();$answerids = $DB->get_records_menu('question_answers',array('question' => $questionid), 'id', 'id,1');foreach ($answerids as $answerid => $notused) {if ($answerstoo) {$fs->delete_area_files($contextid, 'question', 'answer', $answerid);}$fs->delete_area_files($contextid, 'question', 'answerfeedback', $answerid);}}/*** Delete all the files belonging to this question's hints.* @param int $questionid the question being deleted.* @param int $contextid the context the question is in.*/protected function delete_files_in_hints($questionid, $contextid) {global $DB;$fs = get_file_storage();$hintids = $DB->get_records_menu('question_hints',array('questionid' => $questionid), 'id', 'id,1');foreach ($hintids as $hintid => $notused) {$fs->delete_area_files($contextid, 'question', 'hint', $hintid);}}/*** Delete all the files belonging to this question's answers.* @param int $questionid the question being deleted.* @param int $contextid the context the question is in.* @param bool $answerstoo whether there is an 'answer' question area,* as well as an 'answerfeedback' one. Default false.*/protected function delete_files_in_combined_feedback($questionid, $contextid) {global $DB;$fs = get_file_storage();$fs->delete_area_files($contextid,'question', 'correctfeedback', $questionid);$fs->delete_area_files($contextid,'question', 'partiallycorrectfeedback', $questionid);$fs->delete_area_files($contextid,'question', 'incorrectfeedback', $questionid);}public function import_file($context, $component, $filearea, $itemid, $file) {$fs = get_file_storage();$record = new stdClass();if (is_object($context)) {$record->contextid = $context->id;} else {$record->contextid = $context;}$record->component = $component;$record->filearea = $filearea;$record->itemid = $itemid;$record->filename = $file->name;$record->filepath = '/';return $fs->create_file_from_string($record, $this->decode_file($file));}protected function decode_file($file) {switch ($file->encoding) {case 'base64':default:return base64_decode($file->content);}}}/*** This class is used in the return value from* {@link question_type::get_possible_responses()}.** @copyright 2010 The Open University* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later*/class question_possible_response {/*** @var string the classification of this response the student gave to this* part of the question. Must match one of the responseclasses returned by* {@link question_type::get_possible_responses()}.*/public $responseclass;/** @var string the (partial) credit awarded for this responses. */public $fraction;/*** Constructor, just an easy way to set the fields.* @param string $responseclassid see the field descriptions above.* @param string $response see the field descriptions above.* @param number $fraction see the field descriptions above.*/public function __construct($responseclass, $fraction) {$this->responseclass = $responseclass;$this->fraction = $fraction;}public static function no_response() {return new question_possible_response(get_string('noresponse', 'question'), 0);}}