Proyectos de Subversion Moodle

<?php

// This file is part of Moodle - http://moodle.org/

//

// Moodle is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// Moodle is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

use mod_quiz\local\reports\report_base;

use mod_quiz\quiz_attempt;

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

require_once($CFG->dirroot . '/mod/quiz/report/grading/gradingsettings_form.php');

/**

 * Quiz report to help teachers manually grade questions that need it.

 *

 * This report basically provides two screens:

 * - List question that might need manual grading (or optionally all questions).

 * - Provide an efficient UI to grade all attempts at a particular question.

 *

 * @copyright 2006 Gustav Delius

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

 */

class quiz_grading_report extends report_base {

    const DEFAULT_PAGE_SIZE = 5;

    const DEFAULT_ORDER = 'random';

    /** @var string Positive integer regular expression. */

    const REGEX_POSITIVE_INT = '/^[1-9]\d*$/';

    /** @var array URL parameters for what is being displayed when grading. */

    protected $viewoptions = [];

    /** @var int the current group, 0 if none, or NO_GROUPS_ALLOWED. */

    protected $currentgroup;

    /** @var array from quiz_report_get_significant_questions. */

    protected $questions;

    /** @var stdClass the course settings. */

    protected $course;

    /** @var stdClass the course_module settings. */

    protected $cm;

    /** @var stdClass the quiz settings. */

    protected $quiz;

    /** @var context the quiz context. */

    protected $context;

    /** @var quiz_grading_renderer Renderer of Quiz Grading. */

    protected $renderer;

    /** @var string fragment of SQL code to restrict to the relevant users. */

    protected $userssql;

    /** @var array extra user fields. */

    protected $extrauserfields = [];

    public function display($quiz, $cm, $course) {

        $this->quiz = $quiz;

        $this->cm = $cm;

        $this->course = $course;

        // Get the URL options.

        $slot = optional_param('slot', null, PARAM_INT);

        $questionid = optional_param('qid', null, PARAM_INT);

        $grade = optional_param('grade', null, PARAM_ALPHA);

        $includeauto = optional_param('includeauto', false, PARAM_BOOL);

        if (!in_array($grade, ['all', 'needsgrading', 'autograded', 'manuallygraded'])) {

            $grade = null;

        }

        $pagesize = optional_param('pagesize',

                get_user_preferences('quiz_grading_pagesize', self::DEFAULT_PAGE_SIZE),

                PARAM_INT);

        $page = optional_param('page', 0, PARAM_INT);

        $order = optional_param('order',

                get_user_preferences('quiz_grading_order', self::DEFAULT_ORDER),

                PARAM_ALPHAEXT);

        // Assemble the options required to reload this page.

        $optparams = ['includeauto', 'page'];

        foreach ($optparams as $param) {

            if ($$param) {

                $this->viewoptions[$param] = $$param;

            }

        }

        if (!data_submitted() && !preg_match(self::REGEX_POSITIVE_INT, $pagesize)) {

            // We only validate if the user accesses the page via a cleaned-up GET URL here.

            throw new moodle_exception('invalidpagesize');

        }

        if ($pagesize != self::DEFAULT_PAGE_SIZE) {

            $this->viewoptions['pagesize'] = $pagesize;

        }

        if ($order != self::DEFAULT_ORDER) {

            $this->viewoptions['order'] = $order;

        }

        // Check permissions.

        $this->context = context_module::instance($this->cm->id);

        require_capability('mod/quiz:grade', $this->context);

        $shownames = has_capability('quiz/grading:viewstudentnames', $this->context);

        // Whether the current user can see custom user fields.

        $showcustomfields = has_capability('quiz/grading:viewidnumber', $this->context);

        $userfieldsapi = \core_user\fields::for_identity($this->context)->with_name();

        $customfields = [];

        foreach ($userfieldsapi->get_required_fields([\core_user\fields::PURPOSE_IDENTITY]) as $field) {

            $customfields[] = $field;

        }

        // Validate order.

        $orderoptions = array_merge(['random', 'date', 'studentfirstname', 'studentlastname'], $customfields);

        if (!in_array($order, $orderoptions)) {

            $order = self::DEFAULT_ORDER;

        } else if (!$shownames && ($order == 'studentfirstname' || $order == 'studentlastname')) {

            $order = self::DEFAULT_ORDER;

        } else if (!$showcustomfields && in_array($order, $customfields)) {

            $order = self::DEFAULT_ORDER;

        }

        if ($order == 'random') {

            $page = 0;

        }

        // Get the list of questions in this quiz.

        $this->questions = quiz_report_get_significant_questions($quiz);

        if ($slot && !array_key_exists($slot, $this->questions)) {

            throw new moodle_exception('unknownquestion', 'quiz_grading');

        }

        // Process any submitted data.

        if ($data = data_submitted() && confirm_sesskey() && $this->validate_submitted_marks()) {

            // Changes done to handle attempts being missed from grading due to redirecting to new page.

            $attemptsgraded = $this->process_submitted_data();

            $nextpagenumber = $page + 1;

            // If attempts need grading and one or more have now been graded, then page number should remain the same.

            if ($grade == 'needsgrading' && $attemptsgraded) {

                $nextpagenumber = $page;

            }

            redirect($this->grade_question_url($slot, $questionid, $grade, $nextpagenumber));

        }

        // Get the group, and the list of significant users.

        $this->currentgroup = $this->get_current_group($cm, $course, $this->context);

        if ($this->currentgroup == self::NO_GROUPS_ALLOWED) {

            $this->userssql = [];

        } else {

            $this->userssql = get_enrolled_sql($this->context,

                    ['mod/quiz:reviewmyattempts', 'mod/quiz:attempt'], $this->currentgroup);

        }

        $hasquestions = quiz_has_questions($this->quiz->id);

        if (!$hasquestions) {

            $this->print_header_and_tabs($cm, $course, $quiz, 'grading');

            echo $this->renderer->render_quiz_no_question_notification($quiz, $cm, $this->context);

            return true;

        }

        if (!$slot) {

            $this->display_index($includeauto);

            return true;

        }

        // Display the grading UI for one question.

        // Make sure there is something to do.

        $counts = null;

        $statecounts = $this->get_question_state_summary([$slot]);

        foreach ($statecounts as $record) {

            if ($record->questionid == $questionid) {

                $counts = $record;

                break;

            }

        }

        // If not, redirect back to the list.

        if (!$counts || $counts->$grade == 0) {

            redirect($this->list_questions_url(), get_string('alldoneredirecting', 'quiz_grading'));

        }

        $this->display_grading_interface($slot, $questionid, $grade,

                $pagesize, $page, $shownames, $showcustomfields, $order, $counts);

        return true;

    }

    /**

     * Get the JOIN conditions needed so we only show attempts by relevant users.

     *

     * @return qubaid_join

     */

    protected function get_qubaids_condition() {

        $where = "quiza.quiz = :mangrquizid AND

                quiza.preview = 0 AND

                quiza.state = :statefinished";

        $params = ['mangrquizid' => $this->cm->instance, 'statefinished' => quiz_attempt::FINISHED];

        $usersjoin = '';

        $currentgroup = groups_get_activity_group($this->cm, true);

        $enrolleduserscount = count_enrolled_users($this->context,

                ['mod/quiz:reviewmyattempts', 'mod/quiz:attempt'], $currentgroup);

        if ($currentgroup) {

            $userssql = get_enrolled_sql($this->context,

                    ['mod/quiz:reviewmyattempts', 'mod/quiz:attempt'], $currentgroup);

            if ($enrolleduserscount < 1) {

                $where .= ' AND quiza.userid = 0';

            } else {

                $usersjoin = "JOIN ({$userssql[0]}) AS enr ON quiza.userid = enr.id";

                $params += $userssql[1];

            }

        }

        return new qubaid_join("{quiz_attempts} quiza $usersjoin ", 'quiza.uniqueid', $where, $params);

    }

    /**

     * Load the quiz_attempts rows corresponding to a list of question_usage ids.

     *

     * @param int[] $qubaids the question_usage ids of the quiz_attempts to load.

     * @return array quiz attempts, with added user name fields.

     */

    protected function load_attempts_by_usage_ids($qubaids) {

        global $DB;

        list($asql, $params) = $DB->get_in_or_equal($qubaids);

        $params[] = quiz_attempt::FINISHED;

        $params[] = $this->quiz->id;

        $fields = 'quiza.*, ';

        $userfieldsapi = \core_user\fields::for_identity($this->context)->with_name();

        $userfieldssql = $userfieldsapi->get_sql('u', false, '', 'userid', false);

        $fields .= $userfieldssql->selects;

        foreach ($userfieldsapi->get_required_fields([\core_user\fields::PURPOSE_IDENTITY]) as $userfield) {

            $this->extrauserfields[] = s($userfield);

        }

        $params = array_merge($userfieldssql->params, $params);

        $attemptsbyid = $DB->get_records_sql("

                SELECT $fields

                FROM {quiz_attempts} quiza

                JOIN {user} u ON u.id = quiza.userid

                {$userfieldssql->joins}

                WHERE quiza.uniqueid $asql AND quiza.state = ? AND quiza.quiz = ?",

                $params);

        $attempts = [];

        foreach ($attemptsbyid as $attempt) {

            $attempts[$attempt->uniqueid] = $attempt;

        }

        return $attempts;

    }

    /**

     * Get the URL of the front page of the report that lists all the questions.

     *

     * @return moodle_url the URL.

     */

    protected function base_url() {

        return new moodle_url('/mod/quiz/report.php',

                ['id' => $this->cm->id, 'mode' => 'grading']);

    }

    /**

     * Get the URL of the front page of the report that lists all the questions.

     *

     * @param bool $includeauto if not given, use the current setting, otherwise,

     *      force a particular value of includeauto in the URL.

     * @return moodle_url the URL.

     */

    protected function list_questions_url($includeauto = null) {

        $url = $this->base_url();

        $url->params($this->viewoptions);

        if (!is_null($includeauto)) {

            $url->param('includeauto', $includeauto);

        }

        return $url;

    }

    /**

     * Get the URL to grade a batch of question attempts.

     *

     * @param int $slot

     * @param int $questionid

     * @param string $grade

     * @param int|bool $page = true, link to current page. false = omit page.

     *      number = link to specific page.

     * @return moodle_url

     */

    protected function grade_question_url($slot, $questionid, $grade, $page = true) {

        $url = $this->base_url();

        $url->params(['slot' => $slot, 'qid' => $questionid, 'grade' => $grade]);

        $url->params($this->viewoptions);

        if (!$page) {

            $url->remove_params('page');

        } else if (is_integer($page)) {

            $url->param('page', $page);

        }

        return $url;

    }

    /**

     * Renders the contents of one cell of the table on the index view.

     *

     * @param stdClass $counts counts of different types of attempt for this slot.

     * @param string $type the type of count to format.

     * @param string $string get_string identifier for the grading link text, if required.

     * @param string $component get_string component identifier for the grading link text, if required.

     * @return string HTML.

     */

    protected function format_count_for_table($counts, $type, $string, $component) {

        $result = $counts->$type;

        if ($counts->$type > 0) {

            $gradeurl = $this->grade_question_url($counts->slot, $counts->questionid, $type);

            $result .= $this->renderer->render_grade_link($counts, $type, $string, $component, $gradeurl);

        }

        return $result;

    }

    /**

     * Display the report front page which summarises the number of attempts to grade.

     *

     * @param bool $includeauto whether to show automatically-graded questions.

     */

    protected function display_index($includeauto) {

        global $PAGE, $OUTPUT;

        $this->print_header_and_tabs($this->cm, $this->course, $this->quiz, 'grading');

        if ($groupmode = groups_get_activity_groupmode($this->cm)) {

            // Groups is being used.

            groups_print_activity_menu($this->cm, $this->list_questions_url());

        }

        // Get the current group for the user looking at the report.

        $currentgroup = $this->get_current_group($this->cm, $this->course, $this->context);

        if ($currentgroup == self::NO_GROUPS_ALLOWED) {

            echo $OUTPUT->notification(get_string('notingroup'));

            return;

        }

        $statecounts = $this->get_question_state_summary(array_keys($this->questions));

        if ($includeauto) {

            $linktext = get_string('hideautomaticallygraded', 'quiz_grading');

        } else {

            $linktext = get_string('alsoshowautomaticallygraded', 'quiz_grading');

        }

        echo $this->renderer->render_display_index_heading($linktext, $this->list_questions_url(!$includeauto));

        $data = [];

        $header = [];

        $header[] = get_string('qno', 'quiz_grading');

        $header[] = get_string('qtypeveryshort', 'question');

        $header[] = get_string('questionname', 'quiz_grading');

        $header[] = get_string('tograde', 'quiz_grading');

        $header[] = get_string('alreadygraded', 'quiz_grading');

        if ($includeauto) {

            $header[] = get_string('automaticallygraded', 'quiz_grading');

        }

        $header[] = get_string('total', 'quiz_grading');

        foreach ($statecounts as $counts) {

            if ($counts->all == 0) {

                continue;

            }

            if (!$includeauto && $counts->needsgrading == 0 && $counts->manuallygraded == 0) {

                continue;

            }

            $row = [];

            $row[] = $this->questions[$counts->slot]->displaynumber;

            $row[] = $PAGE->get_renderer('question', 'bank')->qtype_icon($this->questions[$counts->slot]->qtype);

            $row[] = format_string($counts->name);

            $row[] = $this->format_count_for_table($counts, 'needsgrading', 'gradeverb', 'moodle');

            $row[] = $this->format_count_for_table($counts, 'manuallygraded', 'updategrade', 'quiz_grading');

            if ($includeauto) {

                $row[] = $this->format_count_for_table($counts, 'autograded', 'updategrade', 'quiz_grading');

            }

            $row[] = $this->format_count_for_table($counts, 'all', 'gradeall', 'quiz_grading');

            $data[] = $row;

        }

        echo $this->renderer->render_questions_table($includeauto, $data, $header);

    }

    /**

     * Display the UI for grading attempts at one question.

     *

     * @param int $slot identifies which question to grade.

     * @param int $questionid identifies which question to grade.

     * @param string $grade type of attempts to grade.

     * @param int $pagesize number of questions to show per page.

     * @param int $page current page number.

     * @param bool $shownames whether student names should be shown.

     * @param bool $showcustomfields whether custom field values should be shown.

     * @param string $order preferred order of attempts.

     * @param stdClass $counts object that stores the number of each type of attempt.

     */

    protected function display_grading_interface($slot, $questionid, $grade,

            $pagesize, $page, $shownames, $showcustomfields, $order, $counts) {

        if ($pagesize * $page >= $counts->$grade) {

            $page = 0;

        }

        // Prepare the options form.

        $hidden = [

            'id' => $this->cm->id,

            'mode' => 'grading',

            'slot' => $slot,

            'qid' => $questionid,

            'page' => $page,

        ];

        if (array_key_exists('includeauto', $this->viewoptions)) {

            $hidden['includeauto'] = $this->viewoptions['includeauto'];

        }

        $mform = new quiz_grading_settings_form($hidden, $counts, $shownames, $showcustomfields, $this->context);

        // Tell the form the current settings.

        $settings = new stdClass();

        $settings->grade = $grade;

        $settings->pagesize = $pagesize;

        $settings->order = $order;

        $mform->set_data($settings);

        if ($mform->is_submitted()) {

            if ($mform->is_validated()) {

                // If the form was submitted and validated, save the user preferences, and

                // redirect to a cleaned-up GET URL.

                set_user_preference('quiz_grading_pagesize', $pagesize);

                set_user_preference('quiz_grading_order', $order);

                redirect($this->grade_question_url($slot, $questionid, $grade, $page));

            } else {

                // Set the pagesize back to the previous value, so the report page can continue the render

                // and the form can show the validation.

                $pagesize = get_user_preferences('quiz_grading_pagesize', self::DEFAULT_PAGE_SIZE);

            }

        }

        list($qubaids, $count) = $this->get_usage_ids_where_question_in_state(

                $grade, $slot, $questionid, $order, $page, $pagesize);

        $attempts = $this->load_attempts_by_usage_ids($qubaids);

        // Question info.

        $questioninfo = new stdClass();

        $questioninfo->number = $this->questions[$slot]->number;

        $questioninfo->questionname = format_string($counts->name);

        // Paging info.

        $paginginfo = new stdClass();

        $paginginfo->from = $page * $pagesize + 1;

        $paginginfo->to = min(($page + 1) * $pagesize, $count);

        $paginginfo->of = $count;

        $qubaidlist = implode(',', $qubaids);

        $this->print_header_and_tabs($this->cm, $this->course, $this->quiz, 'grading');

        $gradequestioncontent = '';

        foreach ($qubaids as $qubaid) {

            $attempt = $attempts[$qubaid];

            $quba = question_engine::load_questions_usage_by_activity($qubaid);

            $displayoptions = quiz_get_review_options($this->quiz, $attempt, $this->context);

            $displayoptions->generalfeedback = question_display_options::HIDDEN;

            $displayoptions->history = question_display_options::HIDDEN;

            $displayoptions->manualcomment = question_display_options::EDITABLE;

            $gradequestioncontent .= $this->renderer->render_grade_question(

                    $quba,

                    $slot,

                    $displayoptions,

                    $this->questions[$slot]->number,

                    $this->get_question_heading($attempt, $shownames, $showcustomfields)

            );

        }

        $pagingbar = new stdClass();

        $pagingbar->count = $count;

        $pagingbar->page = $page;

        $pagingbar->pagesize = $pagesize;

        $pagingbar->pagesize = $pagesize;

        $pagingbar->order = $order;

        $pagingbar->pagingurl = $this->grade_question_url($slot, $questionid, $grade, false);

        $hiddeninputs = [

                'qubaids' => $qubaidlist,

                'slots' => $slot,

                'sesskey' => sesskey()

        ];

        echo $this->renderer->render_grading_interface(

                $questioninfo,

                $this->list_questions_url(),

                $mform,

                $paginginfo,

                $pagingbar,

                $this->grade_question_url($slot, $questionid, $grade, $page),

                $hiddeninputs,

                $gradequestioncontent

        );

    }

    /**

     * When saving a grading page, are all the submitted marks valid?

     *

     * @return bool true if all valid, else false.

     */

    protected function validate_submitted_marks() {

        $qubaids = optional_param('qubaids', null, PARAM_SEQUENCE);

        if (!$qubaids) {

            return false;

        }

        $qubaids = clean_param_array(explode(',', $qubaids), PARAM_INT);

        $slots = optional_param('slots', '', PARAM_SEQUENCE);

        if (!$slots) {

            $slots = [];

        } else {

            $slots = explode(',', $slots);

        }

        foreach ($qubaids as $qubaid) {

            foreach ($slots as $slot) {

                if (!question_engine::is_manual_grade_in_range($qubaid, $slot)) {

                    return false;

                }

            }

        }

        return true;

    }

    /**

     * Save all submitted marks to the database.

     *

     * @return bool returns true if some attempts or all are graded. False, if none of the attempts are graded.

     */

    protected function process_submitted_data(): bool {

        global $DB;

        $qubaids = optional_param('qubaids', null, PARAM_SEQUENCE);

        $assumedslotforevents = optional_param('slot', null, PARAM_INT);

        if (!$qubaids) {

            return false;

        }

        $qubaids = clean_param_array(explode(',', $qubaids), PARAM_INT);

        $attempts = $this->load_attempts_by_usage_ids($qubaids);

        $events = [];

        $transaction = $DB->start_delegated_transaction();

        $attemptsgraded = false;

        foreach ($qubaids as $qubaid) {

            $attempt = $attempts[$qubaid];

            $attemptobj = new quiz_attempt($attempt, $this->quiz, $this->cm, $this->course);

            // State of the attempt before grades are changed.

            $attemptoldtstate = $attemptobj->get_question_state($assumedslotforevents);

            $attemptobj->process_submitted_actions(time());

            // Get attempt state after grades are changed.

            $attemptnewtstate = $attemptobj->get_question_state($assumedslotforevents);

            // Check if any attempts are graded.

            if (!$attemptsgraded && $attemptoldtstate->is_graded() != $attemptnewtstate->is_graded()) {

                $attemptsgraded = true;

            }

            // Add the event we will trigger later.

            $params = [

                'objectid' => $attemptobj->get_question_attempt($assumedslotforevents)->get_question_id(),

                'courseid' => $attemptobj->get_courseid(),

                'context' => context_module::instance($attemptobj->get_cmid()),

                'other' => [

                    'quizid' => $attemptobj->get_quizid(),

                    'attemptid' => $attemptobj->get_attemptid(),

                    'slot' => $assumedslotforevents,

                ],

            ];

            $events[] = \mod_quiz\event\question_manually_graded::create($params);

        }

        $transaction->allow_commit();

        // Trigger events for all the questions we manually marked.

        foreach ($events as $event) {

            $event->trigger();

        }

        return $attemptsgraded;

    }

    /**

     * Load information about the number of attempts at various questions in each

     * summarystate.

     *

     * The results are returned as an two dimensional array $qubaid => $slot => $dataobject

     *

     * @param array $slots A list of slots for the questions you want to konw about.

     * @return array The array keys are slot,qestionid. The values are objects with

     * fields $slot, $questionid, $inprogress, $name, $needsgrading, $autograded,

     * $manuallygraded and $all.

     */

    protected function get_question_state_summary($slots) {

        $dm = new question_engine_data_mapper();

        return $dm->load_questions_usages_question_state_summary(

                $this->get_qubaids_condition(), $slots);

    }

    /**

     * Get a list of usage ids where the question with slot $slot, and optionally

     * also with question id $questionid, is in summary state $summarystate. Also

     * return the total count of such states.

     *

     * Only a subset of the ids can be returned by using $orderby, $limitfrom and

     * $limitnum. A special value 'random' can be passed as $orderby, in which case

     * $limitfrom is ignored.

     *

     * @param int $slot The slot for the questions you want to konw about.

     * @param int $questionid (optional) Only return attempts that were of this specific question.

     * @param string $summarystate 'all', 'needsgrading', 'autograded' or 'manuallygraded'.

     * @param string $orderby 'random', 'date', 'student' or 'idnumber'.

     * @param int $page implements paging of the results.

     *      Ignored if $orderby = random or $pagesize is null.

     * @param int $pagesize implements paging of the results. null = all.

     * @return array with two elements, an array of usage ids, and a count of the total number.

     */

    protected function get_usage_ids_where_question_in_state($summarystate, $slot,

            $questionid = null, $orderby = 'random', $page = 0, $pagesize = null) {

        $dm = new question_engine_data_mapper();

        $extraselect = '';

        if ($pagesize && $orderby != 'random') {

            $limitfrom = $page * $pagesize;

        } else {

            $limitfrom = 0;

        }

        $qubaids = $this->get_qubaids_condition();

        $params = [];

        $userfieldsapi = \core_user\fields::for_identity($this->context)->with_name();

        $userfieldssql = $userfieldsapi->get_sql('u', true, '', 'userid', true);

        $params = array_merge($params, $userfieldssql->params);

        $customfields = [];

        foreach ($userfieldsapi->get_required_fields([\core_user\fields::PURPOSE_IDENTITY]) as $field) {

            $customfields[] = $field;

        }

        if ($orderby === 'date') {

            list($statetest, $params) = $dm->in_summary_state_test(

                    'manuallygraded', false, 'mangrstate');

            $extraselect = "(

                    SELECT MAX(sortqas.timecreated)

                    FROM {question_attempt_steps} sortqas

                    WHERE sortqas.questionattemptid = qa.id

                        AND sortqas.state $statetest

                    ) as tcreated";

            $orderby = "tcreated";

        } else if ($orderby === 'studentfirstname' || $orderby === 'studentlastname' || in_array($orderby, $customfields)) {

            $qubaids->from .= " JOIN {user} u ON quiza.userid = u.id {$userfieldssql->joins}";

            // For name sorting, map orderby form value to

            // actual column names; 'idnumber' maps naturally.

            if ($orderby === "studentlastname") {

                $orderby = "u.lastname, u.firstname";

            } else if ($orderby === "studentfirstname") {

                $orderby = "u.firstname, u.lastname";

            } else if (in_array($orderby, $customfields)) { // Sort order by current custom user field.

                $orderby = $userfieldssql->mappings[$orderby];

            }

        }

        return $dm->load_questions_usages_where_question_in_state($qubaids, $summarystate,

                $slot, $questionid, $orderby, $params, $limitfrom, $pagesize, $extraselect);

    }

    /**

     * Initialise some parts of $PAGE and start output.

     *

     * @param stdClass $cm the course_module information.

     * @param stdClass $course the course settings.

     * @param stdClass $quiz the quiz settings.

     * @param string $reportmode the report name.

     */

    public function print_header_and_tabs($cm, $course, $quiz, $reportmode = 'overview') {

        global $PAGE;

        $this->renderer = $PAGE->get_renderer('quiz_grading');

        parent::print_header_and_tabs($cm, $course, $quiz, $reportmode);

    }

    /**

     * Get question heading.

     *

     * @param stdClass $attempt An instance of quiz_attempt.

     * @param bool $shownames True to show the student first/lastnames.

     * @param bool $showcustomfields Whether custom field values should be shown.

     * @return string The string text for the question heading.

     */

    protected function get_question_heading(stdClass $attempt, bool $shownames, bool $showcustomfields): string {

        global $DB;

        $a = new stdClass();

        $a->attempt = $attempt->attempt;

        $a->fullname = fullname($attempt);

        $customfields = [];

        foreach ($this->extrauserfields as $field) {

            if (strval($attempt->{$field}) !== '') {

                $customfields[] = s($attempt->{$field});

            }

        }

        $a->customfields = implode(', ', $customfields);

        if ($shownames && $showcustomfields) {

            return get_string('gradingattemptwithcustomfields', 'quiz_grading', $a);

        } else if ($shownames) {

            return get_string('gradingattempt', 'quiz_grading', $a);

        } else if ($showcustomfields) {

            $a->fullname = $a->customfields;

            return get_string('gradingattempt', 'quiz_grading', $a);

        } else {

            return '';

        }

    }

}