1d0d817ec1bce208e0c2963c43a2b16576c6442d
[moodle.git] / question / type / multianswer / question.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
18 /**
19  * Multianswer question definition class.
20  *
21  * @package    qtype
22  * @subpackage multianswer
23  * @copyright  2010 Pierre Pichet
24  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
25  */
27 require_once($CFG->dirroot . '/question/type/shortanswer/question.php');
28 require_once($CFG->dirroot . '/question/type/numerical/question.php');
29 require_once($CFG->dirroot . '/question/type/multichoice/question.php');
32 /**
33  * Represents a multianswer question.
34  *
35  * A multi-answer question is made of of several subquestions of various types.
36  * You can think of it as an application of the composite pattern to qusetion
37  * types.
38  *
39  * @copyright  2010 Pierre Pichet
40  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
41  */
42 class qtype_multianswer_question extends question_graded_automatically_with_countback {
43     /** @var array of question_graded_automatically. */
44     public $subquestions = array();
46     /**
47      * @var array place number => insex in the $subquestions array. Places are
48      * numbered from 1.
49      */
50     public $places;
52     /**
53      * @var array of strings, one longer than $places, which is achieved by
54      * indexing from 0. The bits of question text that go between the subquestions.
55      */
56     public $textfragments;
58     /**
59      * Get a question_attempt_step_subquestion_adapter
60      * @param question_attempt_step $step the step to adapt.
61      * @param int $i the subquestion index.
62      * @return question_attempt_step_subquestion_adapter.
63      */
64     protected function get_substep($step, $i) {
65         return new question_attempt_step_subquestion_adapter($step, 'sub' . $i . '_');
66     }
68     public function start_attempt(question_attempt_step $step, $variant) {
69         foreach ($this->subquestions as $i => $subq) {
70             $subq->start_attempt($this->get_substep($step, $i), $variant);
71         }
72     }
74     public function apply_attempt_state(question_attempt_step $step) {
75         foreach ($this->subquestions as $i => $subq) {
76             $subq->apply_attempt_state($this->get_substep($step, $i));
77         }
78     }
80     public function get_question_summary() {
81         $summary = $this->html_to_text($this->questiontext, $this->questiontextformat);
82         foreach ($this->subquestions as $i => $subq) {
83             switch ($subq->qtype->name()) {
84                 case 'multichoice':
85                     $choices = array();
86                     $dummyqa = new question_attempt($subq, $this->contextid);
87                     foreach ($subq->get_order($dummyqa) as $ansid) {
88                         $choices[] = $this->html_to_text($subq->answers[$ansid]->answer,
89                                 $subq->answers[$ansid]->answerformat);
90                     }
91                     $answerbit = '{' . implode('; ', $choices) . '}';
92                     break;
93                 case 'numerical':
94                 case 'shortanswer':
95                     $answerbit = '_____';
96                     break;
97                 default:
98                     $answerbit = '{ERR unknown sub-question type}';
99             }
100             $summary = str_replace('{#' . $i . '}', $answerbit, $summary);
101         }
102         return $summary;
103     }
105     public function get_min_fraction() {
106         $fractionsum = 0;
107         $fractionmax = 0;
108         foreach ($this->subquestions as $i => $subq) {
109             $fractionmax += $subq->defaultmark;
110             $fractionsum += $subq->defaultmark * $subq->get_min_fraction();
111         }
112         return $fractionsum / $fractionmax;
113     }
115     public function get_max_fraction() {
116         $fractionsum = 0;
117         $fractionmax = 0;
118         foreach ($this->subquestions as $i => $subq) {
119             $fractionmax += $subq->defaultmark;
120             $fractionsum += $subq->defaultmark * $subq->get_max_fraction();
121         }
122         return $fractionsum / $fractionmax;
123     }
125     public function get_expected_data() {
126         $expected = array();
127         foreach ($this->subquestions as $i => $subq) {
128             $substep = $this->get_substep(null, $i);
129             foreach ($subq->get_expected_data() as $name => $type) {
130                 if ($subq->qtype->name() == 'multichoice' &&
131                         $subq->layout == qtype_multichoice_base::LAYOUT_DROPDOWN) {
132                     // Hack or MC inline does not work.
133                     $expected[$substep->add_prefix($name)] = PARAM_RAW;
134                 } else {
135                     $expected[$substep->add_prefix($name)] = $type;
136                 }
137             }
138         }
139         return $expected;
140     }
142     public function get_correct_response() {
143         $right = array();
144         foreach ($this->subquestions as $i => $subq) {
145             $substep = $this->get_substep(null, $i);
146             foreach ($subq->get_correct_response() as $name => $type) {
147                 $right[$substep->add_prefix($name)] = $type;
148             }
149         }
150         return $right;
151     }
153     public function prepare_simulated_post_data($simulatedresponse) {
154         $postdata = array();
155         foreach ($this->subquestions as $i => $subq) {
156             $substep = $this->get_substep(null, $i);
157             foreach ($subq->prepare_simulated_post_data($simulatedresponse[$i]) as $name => $value) {
158                 $postdata[$substep->add_prefix($name)] = $value;
159             }
160         }
161         return $postdata;
162     }
164     public function get_student_response_values_for_simulation($postdata) {
165         $simulatedresponse = array();
166         foreach ($this->subquestions as $i => $subq) {
167             $substep = $this->get_substep(null, $i);
168             $subqpostdata = $substep->filter_array($postdata);
169             $subqsimulatedresponse = $subq->get_student_response_values_for_simulation($subqpostdata);
170             foreach ($subqsimulatedresponse as $subresponsekey => $responsevalue) {
171                 $simulatedresponse[$i.'.'.$subresponsekey] = $responsevalue;
172             }
173         }
174         ksort($simulatedresponse);
175         return $simulatedresponse;
176     }
178     public function is_complete_response(array $response) {
179         foreach ($this->subquestions as $i => $subq) {
180             $substep = $this->get_substep(null, $i);
181             if (!$subq->is_complete_response($substep->filter_array($response))) {
182                 return false;
183             }
184         }
185         return true;
186     }
188     public function is_gradable_response(array $response) {
189         foreach ($this->subquestions as $i => $subq) {
190             $substep = $this->get_substep(null, $i);
191             if ($subq->is_gradable_response($substep->filter_array($response))) {
192                 return true;
193             }
194         }
195         return false;
196     }
198     public function is_same_response(array $prevresponse, array $newresponse) {
199         foreach ($this->subquestions as $i => $subq) {
200             $substep = $this->get_substep(null, $i);
201             if (!$subq->is_same_response($substep->filter_array($prevresponse),
202                     $substep->filter_array($newresponse))) {
203                 return false;
204             }
205         }
206         return true;
207     }
209     public function get_validation_error(array $response) {
210         $errors = array();
211         foreach ($this->subquestions as $i => $subq) {
212             $substep = $this->get_substep(null, $i);
213             $errors[] = $subq->get_validation_error($substep->filter_array($response));
214         }
215         return implode('<br />', $errors);
216     }
218     /**
219      * Used by grade_response to combine the states of the subquestions.
220      * The combined state is accumulates in $overallstate. That will be right
221      * if all the separate states are right; and wrong if all the separate states
222      * are wrong, otherwise, it will be partially right.
223      * @param question_state $overallstate the result so far.
224      * @param question_state $newstate the new state to add to the combination.
225      * @return question_state the new combined state.
226      */
227     protected function combine_states($overallstate, $newstate) {
228         if (is_null($overallstate)) {
229             return $newstate;
230         } else if ($overallstate == question_state::$gaveup &&
231                 $newstate == question_state::$gaveup) {
232             return question_state::$gaveup;
233         } else if ($overallstate == question_state::$gaveup &&
234                 $newstate == question_state::$gradedwrong) {
235             return question_state::$gradedwrong;
236         } else if ($overallstate == question_state::$gradedwrong &&
237                 $newstate == question_state::$gaveup) {
238             return question_state::$gradedwrong;
239         } else if ($overallstate == question_state::$gradedwrong &&
240                 $newstate == question_state::$gradedwrong) {
241             return question_state::$gradedwrong;
242         } else if ($overallstate == question_state::$gradedright &&
243                 $newstate == question_state::$gradedright) {
244             return question_state::$gradedright;
245         } else {
246             return question_state::$gradedpartial;
247         }
248     }
250     public function grade_response(array $response) {
251         $overallstate = null;
252         $fractionsum = 0;
253         $fractionmax = 0;
254         foreach ($this->subquestions as $i => $subq) {
255             $fractionmax += $subq->defaultmark;
256             $substep = $this->get_substep(null, $i);
257             $subresp = $substep->filter_array($response);
258             if (!$subq->is_gradable_response($subresp)) {
259                 $overallstate = $this->combine_states($overallstate, question_state::$gaveup);
260             } else {
261                 list($subfraction, $newstate) = $subq->grade_response($subresp);
262                 $fractionsum += $subfraction * $subq->defaultmark;
263                 $overallstate = $this->combine_states($overallstate, $newstate);
264             }
265         }
266         return array($fractionsum / $fractionmax, $overallstate);
267     }
269     public function clear_wrong_from_response(array $response) {
270         foreach ($this->subquestions as $i => $subq) {
271             $substep = $this->get_substep(null, $i);
272             $subresp = $substep->filter_array($response);
273             list($subfraction, $newstate) = $subq->grade_response($subresp);
274             if ($newstate != question_state::$gradedright) {
275                 foreach ($subresp as $ind => $resp) {
276                     if ($subq->qtype == 'multichoice' && ($subq->layout == qtype_multichoice_base::LAYOUT_VERTICAL
277                             || $subq->layout == qtype_multichoice_base::LAYOUT_HORIZONTAL)) {
278                         $response[$substep->add_prefix($ind)] = '-1';
279                     } else {
280                         $response[$substep->add_prefix($ind)] = '';
281                     }
282                 }
283             }
284         }
285         return $response;
286     }
288     public function get_num_parts_right(array $response) {
289         $numright = 0;
290         foreach ($this->subquestions as $i => $subq) {
291             $substep = $this->get_substep(null, $i);
292             $subresp = $substep->filter_array($response);
293             list($subfraction, $newstate) = $subq->grade_response($subresp);
294             if ($newstate == question_state::$gradedright) {
295                 $numright += 1;
296             }
297         }
298         return array($numright, count($this->subquestions));
299     }
301     public function compute_final_grade($responses, $totaltries) {
302         $fractionsum = 0;
303         $fractionmax = 0;
304         foreach ($this->subquestions as $i => $subq) {
305             $fractionmax += $subq->defaultmark;
307             $lastresponse = array();
308             $lastchange = 0;
309             $subfraction = 0;
310             foreach ($responses as $responseindex => $response) {
311                 $substep = $this->get_substep(null, $i);
312                 $subresp = $substep->filter_array($response);
313                 if ($subq->is_same_response($lastresponse, $subresp)) {
314                     continue;
315                 }
316                 $lastresponse = $subresp;
317                 $lastchange = $responseindex;
318                 list($subfraction, $newstate) = $subq->grade_response($subresp);
319             }
321             $fractionsum += $subq->defaultmark * max(0, $subfraction - $lastchange * $this->penalty);
322         }
324         return $fractionsum / $fractionmax;
325     }
327     public function summarise_response(array $response) {
328         $summary = array();
329         foreach ($this->subquestions as $i => $subq) {
330             $substep = $this->get_substep(null, $i);
331             $a = new stdClass();
332             $a->i = $i;
333             $a->response = $subq->summarise_response($substep->filter_array($response));
334             $summary[] = get_string('subqresponse', 'qtype_multianswer', $a);
335         }
337         return implode('; ', $summary);
338     }
340     public function check_file_access($qa, $options, $component, $filearea, $args, $forcedownload) {
341         if ($component == 'question' && $filearea == 'answer') {
342             return true;
344         } else if ($component == 'question' && $filearea == 'answerfeedback') {
345             // Full logic to control which feedbacks a student can see is too complex.
346             // Just allow access to all images. There is a theoretical chance the
347             // students could see files they are not meant to see by guessing URLs,
348             // but it is remote.
349             return $options->feedback;
351         } else if ($component == 'question' && $filearea == 'hint') {
352             return $this->check_hint_file_access($qa, $options, $args);
354         } else {
355             return parent::check_file_access($qa, $options, $component, $filearea,
356                     $args, $forcedownload);
357         }
358     }