Merge branch 'MDL-34211' of git://github.com/appalachianstate/moodle into MOODLE_23_S...
[moodle.git] / mod / quiz / report / overview / report.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/>.
17 /**
18  * This file defines the quiz overview report class.
19  *
20  * @package   quiz_overview
21  * @copyright 1999 onwards Martin Dougiamas and others {@link http://moodle.com}
22  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
23  */
26 defined('MOODLE_INTERNAL') || die();
28 require_once($CFG->dirroot . '/mod/quiz/report/attemptsreport.php');
29 require_once($CFG->dirroot . '/mod/quiz/report/overview/overview_options.php');
30 require_once($CFG->dirroot . '/mod/quiz/report/overview/overview_form.php');
31 require_once($CFG->dirroot . '/mod/quiz/report/overview/overview_table.php');
34 /**
35  * Quiz report subclass for the overview (grades) report.
36  *
37  * @copyright 1999 onwards Martin Dougiamas and others {@link http://moodle.com}
38  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
39  */
40 class quiz_overview_report extends quiz_attempts_report {
42     public function display($quiz, $cm, $course) {
43         global $CFG, $DB, $OUTPUT, $PAGE;
45         list($currentgroup, $students, $groupstudents, $allowed) =
46                 $this->init('overview', 'quiz_overview_settings_form', $quiz, $cm, $course);
47         $options = new quiz_overview_options('overview', $quiz, $cm, $course);
49         if ($fromform = $this->form->get_data()) {
50             $options->process_settings_from_form($fromform);
52         } else {
53             $options->process_settings_from_params();
54         }
56         $this->form->set_data($options->get_initial_form_data());
58         if ($options->attempts == self::ALL_WITH) {
59             // This option is only available to users who can access all groups in
60             // groups mode, so setting allowed to empty (which means all quiz attempts
61             // are accessible, is not a security porblem.
62             $allowed = array();
63         }
65         // Load the required questions.
66         $questions = quiz_report_get_significant_questions($quiz);
68         // Prepare for downloading, if applicable.
69         $courseshortname = format_string($course->shortname, true,
70                 array('context' => context_course::instance($course->id)));
71         $table = new quiz_overview_table($quiz, $this->context, $this->qmsubselect,
72                 $options, $groupstudents, $students, $questions, $this->get_base_url());
73         $filename = quiz_report_download_filename(get_string('overviewfilename', 'quiz_overview'),
74                 $courseshortname, $quiz->name);
75         $table->is_downloading($options->download, $filename,
76                 $courseshortname . ' ' . format_string($quiz->name, true));
77         if ($table->is_downloading()) {
78             raise_memory_limit(MEMORY_EXTRA);
79         }
81         $this->process_actions($quiz, $cm, $currentgroup, $groupstudents, $allowed, $options->get_url());
83         // Start output.
84         if (!$table->is_downloading()) {
85             // Only print headers if not asked to download data.
86             $this->print_header_and_tabs($cm, $course, $quiz, $this->mode);
87         }
89         if ($groupmode = groups_get_activity_groupmode($cm)) {
90             // Groups are being used, so output the group selector if we are not downloading.
91             if (!$table->is_downloading()) {
92                 groups_print_activity_menu($cm, $options->get_url());
93             }
94         }
96         // Print information on the number of existing attempts.
97         if (!$table->is_downloading()) {
98             // Do not print notices when downloading.
99             if ($strattemptnum = quiz_num_attempt_summary($quiz, $cm, true, $currentgroup)) {
100                 echo '<div class="quizattemptcounts">' . $strattemptnum . '</div>';
101             }
102         }
104         $hasquestions = quiz_questions_in_quiz($quiz->questions);
105         if (!$table->is_downloading()) {
106             if (!$hasquestions) {
107                 echo quiz_no_questions_message($quiz, $cm, $this->context);
108             } else if (!$students) {
109                 echo $OUTPUT->notification(get_string('nostudentsyet'));
110             } else if ($currentgroup && !$groupstudents) {
111                 echo $OUTPUT->notification(get_string('nostudentsingroup'));
112             }
114             // Print the display options.
115             $this->form->display();
116         }
118         $hasstudents = $students && (!$currentgroup || $groupstudents);
119         if ($hasquestions && ($hasstudents || $options->attempts == self::ALL_WITH)) {
120             // Construct the SQL.
121             $fields = $DB->sql_concat('u.id', "'#'", 'COALESCE(quiza.attempt, 0)') .
122                     ' AS uniqueid, ';
123             if ($this->qmsubselect) {
124                 $fields .=
125                     "(CASE " .
126                     "   WHEN {$this->qmsubselect} THEN 1" .
127                     "   ELSE 0 " .
128                     "END) AS gradedattempt, ";
129             }
131             list($fields, $from, $where, $params) = $table->base_sql($allowed);
133             $table->set_count_sql("SELECT COUNT(1) FROM $from WHERE $where", $params);
135             // Test to see if there are any regraded attempts to be listed.
136             $fields .= ", COALESCE((
137                                 SELECT MAX(qqr.regraded)
138                                   FROM {quiz_overview_regrades} qqr
139                                  WHERE qqr.questionusageid = quiza.uniqueid
140                           ), -1) AS regraded";
141             if ($options->onlyregraded) {
142                 $where .= " AND COALESCE((
143                                     SELECT MAX(qqr.regraded)
144                                       FROM {quiz_overview_regrades} qqr
145                                      WHERE qqr.questionusageid = quiza.uniqueid
146                                 ), -1) <> -1";
147             }
148             $table->set_sql($fields, $from, $where, $params);
150             if (!$table->is_downloading()) {
151                 // Output the regrade buttons.
152                 if (has_capability('mod/quiz:regrade', $this->context)) {
153                     $regradesneeded = $this->count_question_attempts_needing_regrade(
154                             $quiz, $groupstudents);
155                     if ($currentgroup) {
156                         $a= new stdClass();
157                         $a->groupname = groups_get_group_name($currentgroup);
158                         $a->coursestudents = get_string('participants');
159                         $a->countregradeneeded = $regradesneeded;
160                         $regradealldrydolabel =
161                                 get_string('regradealldrydogroup', 'quiz_overview', $a);
162                         $regradealldrylabel =
163                                 get_string('regradealldrygroup', 'quiz_overview', $a);
164                         $regradealllabel =
165                                 get_string('regradeallgroup', 'quiz_overview', $a);
166                     } else {
167                         $regradealldrydolabel =
168                                 get_string('regradealldrydo', 'quiz_overview', $regradesneeded);
169                         $regradealldrylabel =
170                                 get_string('regradealldry', 'quiz_overview');
171                         $regradealllabel =
172                                 get_string('regradeall', 'quiz_overview');
173                     }
174                     $displayurl = new moodle_url($options->get_url(), array('sesskey' => sesskey()));
175                     echo '<div class="mdl-align">';
176                     echo '<form action="'.$displayurl->out_omit_querystring().'">';
177                     echo '<div>';
178                     echo html_writer::input_hidden_params($displayurl);
179                     echo '<input type="submit" name="regradeall" value="'.$regradealllabel.'"/>';
180                     echo '<input type="submit" name="regradealldry" value="' .
181                             $regradealldrylabel . '"/>';
182                     if ($regradesneeded) {
183                         echo '<input type="submit" name="regradealldrydo" value="' .
184                                 $regradealldrydolabel . '"/>';
185                     }
186                     echo '</div>';
187                     echo '</form>';
188                     echo '</div>';
189                 }
190                 // Print information on the grading method.
191                 if ($strattempthighlight = quiz_report_highlighting_grading_method(
192                         $quiz, $this->qmsubselect, $options->onlygraded)) {
193                     echo '<div class="quizattemptcounts">' . $strattempthighlight . '</div>';
194                 }
195             }
197             // Define table columns.
198             $columns = array();
199             $headers = array();
201             if (!$table->is_downloading() && $options->checkboxcolumn) {
202                 $columns[] = 'checkbox';
203                 $headers[] = null;
204             }
206             $this->add_user_columns($table, $columns, $headers);
207             $this->add_state_column($columns, $headers);
208             $this->add_time_columns($columns, $headers);
210             $this->add_grade_columns($quiz, $options->usercanseegrades, $columns, $headers, false);
212             if (!$table->is_downloading() && has_capability('mod/quiz:regrade', $this->context) &&
213                     $this->has_regraded_questions($from, $where, $params)) {
214                 $columns[] = 'regraded';
215                 $headers[] = get_string('regrade', 'quiz_overview');
216             }
218             if ($options->slotmarks) {
219                 foreach ($questions as $slot => $question) {
220                     // Ignore questions of zero length.
221                     $columns[] = 'qsgrade' . $slot;
222                     $header = get_string('qbrief', 'quiz', $question->number);
223                     if (!$table->is_downloading()) {
224                         $header .= '<br />';
225                     } else {
226                         $header .= ' ';
227                     }
228                     $header .= '/' . quiz_rescale_grade($question->maxmark, $quiz, 'question');
229                     $headers[] = $header;
230                 }
231             }
233             $this->set_up_table_columns($table, $columns, $headers, $this->get_base_url(), $options, false);
234             $table->set_attribute('class', 'generaltable generalbox grades');
236             $table->out($options->pagesize, true);
237         }
239         if (!$table->is_downloading() && $options->usercanseegrades) {
240             $output = $PAGE->get_renderer('mod_quiz');
241             if ($currentgroup && $groupstudents) {
242                 list($usql, $params) = $DB->get_in_or_equal($groupstudents);
243                 $params[] = $quiz->id;
244                 if ($DB->record_exists_select('quiz_grades', "userid $usql AND quiz = ?",
245                         $params)) {
246                     $imageurl = new moodle_url('/mod/quiz/report/overview/overviewgraph.php',
247                             array('id' => $quiz->id, 'groupid' => $currentgroup));
248                     $graphname = get_string('overviewreportgraphgroup', 'quiz_overview',
249                             groups_get_group_name($currentgroup));
250                     echo $output->graph($imageurl, $graphname);
251                 }
252             }
254             if ($DB->record_exists('quiz_grades', array('quiz'=> $quiz->id))) {
255                 $imageurl = new moodle_url('/mod/quiz/report/overview/overviewgraph.php',
256                         array('id' => $quiz->id));
257                 $graphname = get_string('overviewreportgraph', 'quiz_overview');
258                 echo $output->graph($imageurl, $graphname);
259             }
260         }
261         return true;
262     }
264     protected function process_actions($quiz, $cm, $currentgroup, $groupstudents, $allowed, $redirecturl) {
265         parent::process_actions($quiz, $cm, $currentgroup, $groupstudents, $allowed, $redirecturl);
267         if (empty($currentgroup) || $groupstudents) {
268             if (optional_param('regrade', 0, PARAM_BOOL) && confirm_sesskey()) {
269                 if ($attemptids = optional_param_array('attemptid', array(), PARAM_INT)) {
270                     require_capability('mod/quiz:regrade', $this->context);
271                     $this->regrade_attempts($quiz, false, $groupstudents, $attemptids);
272                     redirect($redirecturl, '', 5);
273                 }
274             }
275         }
277         if (optional_param('regradeall', 0, PARAM_BOOL) && confirm_sesskey()) {
278             require_capability('mod/quiz:regrade', $this->context);
279             $this->regrade_attempts($quiz, false, $groupstudents);
280             redirect($redirecturl, '', 5);
282         } else if (optional_param('regradealldry', 0, PARAM_BOOL) && confirm_sesskey()) {
283             require_capability('mod/quiz:regrade', $this->context);
284             $this->regrade_attempts($quiz, true, $groupstudents);
285             redirect($redirecturl, '', 5);
287         } else if (optional_param('regradealldrydo', 0, PARAM_BOOL) && confirm_sesskey()) {
288             require_capability('mod/quiz:regrade', $this->context);
289             $this->regrade_attempts_needing_it($quiz, $groupstudents);
290             redirect($redirecturl, '', 5);
291         }
292     }
294     /**
295      * Regrade a particular quiz attempt. Either for real ($dryrun = false), or
296      * as a pretend regrade to see which fractions would change. The outcome is
297      * stored in the quiz_overview_regrades table.
298      *
299      * Note, $attempt is not upgraded in the database. The caller needs to do that.
300      * However, $attempt->sumgrades is updated, if this is not a dry run.
301      *
302      * @param object $attempt the quiz attempt to regrade.
303      * @param bool $dryrun if true, do a pretend regrade, otherwise do it for real.
304      * @param array $slots if null, regrade all questions, otherwise, just regrade
305      *      the quetsions with those slots.
306      */
307     protected function regrade_attempt($attempt, $dryrun = false, $slots = null) {
308         global $DB;
309         set_time_limit(30);
311         $transaction = $DB->start_delegated_transaction();
313         $quba = question_engine::load_questions_usage_by_activity($attempt->uniqueid);
315         if (is_null($slots)) {
316             $slots = $quba->get_slots();
317         }
319         $finished = $attempt->state == quiz_attempt::FINISHED;
320         foreach ($slots as $slot) {
321             $qqr = new stdClass();
322             $qqr->oldfraction = $quba->get_question_fraction($slot);
324             $quba->regrade_question($slot, $finished);
326             $qqr->newfraction = $quba->get_question_fraction($slot);
328             if (abs($qqr->oldfraction - $qqr->newfraction) > 1e-7) {
329                 $qqr->questionusageid = $quba->get_id();
330                 $qqr->slot = $slot;
331                 $qqr->regraded = empty($dryrun);
332                 $qqr->timemodified = time();
333                 $DB->insert_record('quiz_overview_regrades', $qqr, false);
334             }
335         }
337         if (!$dryrun) {
338             question_engine::save_questions_usage_by_activity($quba);
339         }
341         $transaction->allow_commit();
343         // Really, PHP should not need this hint, but without this, we just run out of memory.
344         $quba = null;
345         $transaction = null;
346         gc_collect_cycles();
347     }
349     /**
350      * Regrade attempts for this quiz, exactly which attempts are regraded is
351      * controlled by the parameters.
352      * @param object $quiz the quiz settings.
353      * @param bool $dryrun if true, do a pretend regrade, otherwise do it for real.
354      * @param array $groupstudents blank for all attempts, otherwise regrade attempts
355      * for these users.
356      * @param array $attemptids blank for all attempts, otherwise only regrade
357      * attempts whose id is in this list.
358      */
359     protected function regrade_attempts($quiz, $dryrun = false,
360             $groupstudents = array(), $attemptids = array()) {
361         global $DB;
363         $where = "quiz = ? AND preview = 0";
364         $params = array($quiz->id);
366         if ($groupstudents) {
367             list($usql, $uparams) = $DB->get_in_or_equal($groupstudents);
368             $where .= " AND userid $usql";
369             $params = array_merge($params, $uparams);
370         }
372         if ($attemptids) {
373             list($asql, $aparams) = $DB->get_in_or_equal($attemptids);
374             $where .= " AND id $asql";
375             $params = array_merge($params, $aparams);
376         }
378         $attempts = $DB->get_records_select('quiz_attempts', $where, $params);
379         if (!$attempts) {
380             return;
381         }
383         $this->clear_regrade_table($quiz, $groupstudents);
385         foreach ($attempts as $attempt) {
386             $this->regrade_attempt($attempt, $dryrun);
387         }
389         if (!$dryrun) {
390             $this->update_overall_grades($quiz);
391         }
392     }
394     /**
395      * Regrade those questions in those attempts that are marked as needing regrading
396      * in the quiz_overview_regrades table.
397      * @param object $quiz the quiz settings.
398      * @param array $groupstudents blank for all attempts, otherwise regrade attempts
399      * for these users.
400      */
401     protected function regrade_attempts_needing_it($quiz, $groupstudents) {
402         global $DB;
404         $where = "quiza.quiz = ? AND quiza.preview = 0 AND qqr.regraded = 0";
405         $params = array($quiz->id);
407         // Fetch all attempts that need regrading.
408         if ($groupstudents) {
409             list($usql, $uparams) = $DB->get_in_or_equal($groupstudents);
410             $where .= " AND quiza.userid $usql";
411             $params += $uparams;
412         }
414         $toregrade = $DB->get_records_sql("
415                 SELECT quiza.uniqueid, qqr.slot
416                 FROM {quiz_attempts} quiza
417                 JOIN {quiz_overview_regrades} qqr ON qqr.questionusageid = quiza.uniqueid
418                 WHERE $where", $params);
420         if (!$toregrade) {
421             return;
422         }
424         $attemptquestions = array();
425         foreach ($toregrade as $row) {
426             $attemptquestions[$row->uniqueid][] = $row->slot;
427         }
428         $attempts = $DB->get_records_list('quiz_attempts', 'uniqueid',
429                 array_keys($attemptquestions));
431         $this->clear_regrade_table($quiz, $groupstudents);
433         foreach ($attempts as $attempt) {
434             $this->regrade_attempt($attempt, false, $attemptquestions[$attempt->uniqueid]);
435         }
437         $this->update_overall_grades($quiz);
438     }
440     /**
441      * Count the number of attempts in need of a regrade.
442      * @param object $quiz the quiz settings.
443      * @param array $groupstudents user ids. If this is given, only data relating
444      * to these users is cleared.
445      */
446     protected function count_question_attempts_needing_regrade($quiz, $groupstudents) {
447         global $DB;
449         $usertest = '';
450         $params = array();
451         if ($groupstudents) {
452             list($usql, $params) = $DB->get_in_or_equal($groupstudents);
453             $usertest = "quiza.userid $usql AND ";
454         }
456         $params[] = $quiz->id;
457         $sql = "SELECT COUNT(DISTINCT quiza.id)
458                 FROM {quiz_attempts} quiza
459                 JOIN {quiz_overview_regrades} qqr ON quiza.uniqueid = qqr.questionusageid
460                 WHERE
461                     $usertest
462                     quiza.quiz = ? AND
463                     quiza.preview = 0 AND
464                     qqr.regraded = 0";
465         return $DB->count_records_sql($sql, $params);
466     }
468     /**
469      * Are there any pending regrades in the table we are going to show?
470      * @param string $from tables used by the main query.
471      * @param string $where where clause used by the main query.
472      * @param array $params required by the SQL.
473      * @return bool whether there are pending regrades.
474      */
475     protected function has_regraded_questions($from, $where, $params) {
476         global $DB;
477         $qubaids = new qubaid_join($from, 'uniqueid', $where, $params);
478         return $DB->record_exists_select('quiz_overview_regrades',
479                 'questionusageid ' . $qubaids->usage_id_in(),
480                 $qubaids->usage_id_in_params());
481     }
483     /**
484      * Remove all information about pending/complete regrades from the database.
485      * @param object $quiz the quiz settings.
486      * @param array $groupstudents user ids. If this is given, only data relating
487      * to these users is cleared.
488      */
489     protected function clear_regrade_table($quiz, $groupstudents) {
490         global $DB;
492         // Fetch all attempts that need regrading.
493         $where = '';
494         $params = array();
495         if ($groupstudents) {
496             list($usql, $params) = $DB->get_in_or_equal($groupstudents);
497             $where = "userid $usql AND ";
498         }
500         $params[] = $quiz->id;
501         $DB->delete_records_select('quiz_overview_regrades',
502                 "questionusageid IN (
503                     SELECT uniqueid
504                     FROM {quiz_attempts}
505                     WHERE $where quiz = ?
506                 )", $params);
507     }
509     /**
510      * Update the final grades for all attempts. This method is used following
511      * a regrade.
512      * @param object $quiz the quiz settings.
513      * @param array $userids only update scores for these userids.
514      * @param array $attemptids attemptids only update scores for these attempt ids.
515      */
516     protected function update_overall_grades($quiz) {
517         quiz_update_all_attempt_sumgrades($quiz);
518         quiz_update_all_final_grades($quiz);
519         quiz_update_grades($quiz);
520     }