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

/**

 * Definition of the grader report class

 *

 * @package   gradereport_grader

 * @copyright 2007 Nicolas Connault

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

 */

require_once($CFG->dirroot . '/grade/report/lib.php');

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

use core_grades\penalty_manager;

/**

 * Class providing an API for the grader report building and displaying.

 * @uses grade_report

 * @copyright 2007 Nicolas Connault

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

 */

class grade_report_grader extends grade_report {

    /**

     * The final grades.

     * @var array $grades

     */

    public $grades;

    /**

     * Contains all the grades for the course - even the ones not displayed in the grade tree.

     *

     * @var array $allgrades

     */

    private $allgrades;

    /**

     * Contains all grade items expect GRADE_TYPE_NONE.

     *

     * @var array $allgradeitems

     */

    private $allgradeitems;

    /**

     * Array of errors for bulk grades updating.

     * @var array $gradeserror

     */

    public $gradeserror = array();

    // SQL-RELATED

    /**

     * The id of the grade_item by which this report will be sorted.

     * @var int $sortitemid

     */

    public $sortitemid;

    /**

     * Sortorder used in the SQL selections.

     * @var int $sortorder

     */

    public $sortorder;

    /**

     * An SQL fragment affecting the search for users.

     * @var string $userselect

     */

    public $userselect;

    /**

     * The bound params for $userselect

     * @var array $userselectparams

     */

    public $userselectparams = array();

    /**

     * List of collapsed categories from user preference

     * @var array $collapsed

     */

    public $collapsed;

    /**

     * A count of the rows, used for css classes.

     * @var int $rowcount

     */

    public $rowcount = 0;

    /**

     * Capability check caching

     * @var boolean $canviewhidden

     */

    public $canviewhidden;

    /**

     * @var int Maximum number of students that can be shown on one page

     * @deprecated Since Moodle 4.5 MDL-84245. Use grade_report_grader::get_max_students_per_page() instead.

     */

    #[\core\attribute\deprecated('grade_report_grader::get_max_students_per_page()', since: '4.5', mdl: 'MDL-84245')]

    public const MAX_STUDENTS_PER_PAGE = 5000;

    /**

     * @var int The maximum number of grades that can be shown on one page.

     *

     * More than this causes issues for the browser due to the size of the page.

     */

    public const MAX_GRADES_PER_PAGE = 200000;

    /** @var int[] List of available options on the pagination dropdown */

    public const PAGINATION_OPTIONS = [20, 100];

    /**

     * Allow category grade overriding

     * @var bool $overridecat

     */

    protected $overridecat;

    /** @var array of objects, or empty array if no records were found. */

    protected $users = [];

    /**

     * Constructor. Sets local copies of user preferences and initialises grade_tree.

     * @param int $courseid

     * @param object $gpr grade plugin return tracking object

     * @param string $context

     * @param int $page The current page being viewed (when report is paged)

     * @param int $sortitemid The id of the grade_item by which to sort the table

     * @param string $sort Sorting direction

     */

    public function __construct($courseid, $gpr, $context, $page=null, $sortitemid=null, string $sort = '') {

        global $CFG;

        parent::__construct($courseid, $gpr, $context, $page);

        $this->canviewhidden = has_capability('moodle/grade:viewhidden', context_course::instance($this->course->id));

        // load collapsed settings for this report

        $this->collapsed = static::get_collapsed_preferences($this->course->id);

        if (empty($CFG->enableoutcomes)) {

            $nooutcomes = false;

        } else {

            $nooutcomes = get_user_preferences('grade_report_shownooutcomes');

        }

        // if user report preference set or site report setting set use it, otherwise use course or site setting

        $switch = $this->get_pref('aggregationposition');

        if ($switch == '') {

            $switch = grade_get_setting($this->courseid, 'aggregationposition', $CFG->grade_aggregationposition);

        }

        // Grab the grade_tree for this course

        $this->gtree = new grade_tree($this->courseid, true, $switch, $this->collapsed, $nooutcomes);

        $this->sortitemid = $sortitemid;

        // base url for sorting by first/last name

        $this->baseurl = new moodle_url('index.php', array('id' => $this->courseid));

        $studentsperpage = $this->get_students_per_page();

        if (!empty($this->page) && !empty($studentsperpage)) {

            $this->baseurl->params(array('perpage' => $studentsperpage, 'page' => $this->page));

        }

        $this->pbarurl = new moodle_url('/grade/report/grader/index.php', array('id' => $this->courseid));

        $this->setup_groups();

        $this->setup_users();

        $this->setup_sortitemid($sort);

        $this->overridecat = (bool)get_config('moodle', 'grade_overridecat');

    }

    /**

     * Processes the data sent by the form (grades).

     * Caller is responsible for all access control checks

     * @param array $data form submission (with magic quotes)

     * @return array empty array if success, array of warnings if something fails.

     */

    public function process_data($data) {

        global $DB;

        $warnings = array();

        $separategroups = false;

        $mygroups       = array();

        if ($this->groupmode == SEPARATEGROUPS and !has_capability('moodle/site:accessallgroups', $this->context)) {

            $separategroups = true;

            $mygroups = groups_get_user_groups($this->course->id);

            $mygroups = $mygroups[0]; // ignore groupings

            // reorder the groups fro better perf below

            $current = array_search($this->currentgroup, $mygroups);

            if ($current !== false) {

                unset($mygroups[$current]);

                array_unshift($mygroups, $this->currentgroup);

            }

        }

        $viewfullnames = has_capability('moodle/site:viewfullnames', $this->context);

        // always initialize all arrays

        $queue = array();

        $this->load_users();

        $this->load_final_grades();

        // Were any changes made?

        $changedgrades = false;

        $timepageload = clean_param($data->timepageload, PARAM_INT);

        foreach ($data as $varname => $students) {

            $needsupdate = false;

            // Skip, not a grade.

            if (strpos($varname, 'grade') === 0) {

                $datatype = 'grade';

            } else {

                continue;

            }

            foreach ($students as $userid => $items) {

                $userid = clean_param($userid, PARAM_INT);

                foreach ($items as $itemid => $postedvalue) {

                    $itemid = clean_param($itemid, PARAM_INT);

                    // Was change requested?

                    $oldvalue = $this->grades[$userid][$itemid];

                    if ($datatype === 'grade') {

                        // If there was no grade and there still isn't

                        if (is_null($oldvalue->finalgrade) && $postedvalue == -1) {

                            // -1 means no grade

                            continue;

                        }

                        // If the grade item uses a custom scale

                        if (!empty($oldvalue->grade_item->scaleid)) {

                            if ((int)$oldvalue->finalgrade === (int)$postedvalue) {

                                continue;

                            }

                        } else {

                            // The grade item uses a numeric scale

                            // Format the finalgrade from the DB so that it matches the grade from the client

                            if ($postedvalue === format_float($oldvalue->finalgrade, $oldvalue->grade_item->get_decimals())) {

                                continue;

                            }

                        }

                        $changedgrades = true;

                    }

                    if (!$gradeitem = grade_item::fetch(array('id'=>$itemid, 'courseid'=>$this->courseid))) {

                        throw new \moodle_exception('invalidgradeitemid');

                    }

                    // Pre-process grade

                    if ($datatype == 'grade') {

                        if ($gradeitem->gradetype == GRADE_TYPE_SCALE) {

                            if ($postedvalue == -1) { // -1 means no grade

                                $finalgrade = null;

                            } else {

                                $finalgrade = $postedvalue;

                            }

                        } else {

                            $finalgrade = unformat_float($postedvalue);

                        }

                        $errorstr = '';

                        $skip = false;

                        $dategraded = $oldvalue->get_dategraded();

                        if (!empty($dategraded) && $timepageload < $dategraded) {

                            // Warn if the grade was updated while we were editing this form.

                            $errorstr = 'gradewasmodifiedduringediting';

                            $skip = true;

                        } else if (!is_null($finalgrade)) {

                            // Warn if the grade is out of bounds.

                            $bounded = $gradeitem->bounded_grade($finalgrade);

                            if ($bounded > $finalgrade) {

                                $errorstr = 'lessthanmin';

                            } else if ($bounded < $finalgrade) {

                                $errorstr = 'morethanmax';

                            }

                        }

                        if ($errorstr) {

                            $userfieldsapi = \core_user\fields::for_name();

                            $userfields = 'id, ' . $userfieldsapi->get_sql('', false, '', '', false)->selects;

                            $user = $DB->get_record('user', array('id' => $userid), $userfields);

                            $gradestr = new stdClass();

                            $gradestr->username = fullname($user, $viewfullnames);

                            $gradestr->itemname = $gradeitem->get_name();

                            $warnings[] = get_string($errorstr, 'grades', $gradestr);

                            if ($skip) {

                                // Skipping the update of this grade it failed the tests above.

                                continue;

                            }

                        }

                    }

                    // group access control

                    if ($separategroups) {

                        // note: we can not use $this->currentgroup because it would fail badly

                        //       when having two browser windows each with different group

                        $sharinggroup = false;

                        foreach ($mygroups as $groupid) {

                            if (groups_is_member($groupid, $userid)) {

                                $sharinggroup = true;

                                break;

                            }

                        }

                        if (!$sharinggroup) {

                            // either group membership changed or somebody is hacking grades of other group

                            $warnings[] = get_string('errorsavegrade', 'grades');

                            continue;

                        }

                    }

                    $gradeitem->update_final_grade($userid, $finalgrade, 'gradebook', false,

                        FORMAT_MOODLE, null, null, true);

                }

            }

        }

        if ($changedgrades) {

            // If a final grade was overriden reload grades so dependent grades like course total will be correct

            $this->grades = null;

        }

        return $warnings;

    }

    /**

     * Setting the sort order, this depends on last state

     * all this should be in the new table class that we might need to use

     * for displaying grades.

     * @param string $sort sorting direction

     */

    private function setup_sortitemid(string $sort = '') {

        global $SESSION;

        if (!isset($SESSION->gradeuserreport)) {

            $SESSION->gradeuserreport = new stdClass();

        }

        if ($this->sortitemid) {

            if (!isset($SESSION->gradeuserreport->sort)) {

                $this->sortorder = $SESSION->gradeuserreport->sort = 'ASC';

            } else if (!$sort) {

                // this is the first sort, i.e. by last name

                if (!isset($SESSION->gradeuserreport->sortitemid)) {

                    $this->sortorder = $SESSION->gradeuserreport->sort = 'ASC';

                } else if ($SESSION->gradeuserreport->sortitemid == $this->sortitemid) {

                    // same as last sort

                    if ($SESSION->gradeuserreport->sort == 'ASC') {

                        $this->sortorder = $SESSION->gradeuserreport->sort = 'DESC';

                    } else {

                        $this->sortorder = $SESSION->gradeuserreport->sort = 'ASC';

                    }

                } else {

                    $this->sortorder = $SESSION->gradeuserreport->sort = 'ASC';

                }

            }

            $SESSION->gradeuserreport->sortitemid = $this->sortitemid;

        } else {

            // not requesting sort, use last setting (for paging)

            if (isset($SESSION->gradeuserreport->sortitemid)) {

                $this->sortitemid = $SESSION->gradeuserreport->sortitemid;

            } else {

                $this->sortitemid = 'lastname';

            }

            if (isset($SESSION->gradeuserreport->sort)) {

                $this->sortorder = $SESSION->gradeuserreport->sort;

            } else {

                $this->sortorder = 'ASC';

            }

        }

        // If explicit sorting direction exists.

        if ($sort) {

            $this->sortorder = $sort;

            $SESSION->gradeuserreport->sort = $sort;

        }

    }

    /**

     * pulls out the userids of the users to be display, and sorts them

     *

     * @param bool $allusers If we are getting the users within the report, we want them all irrespective of paging.

     */

    public function load_users(bool $allusers = false) {

        global $CFG, $DB;

        if (!empty($this->users)) {

            return;

        }

        $this->setup_users();

        // Limit to users with a gradeable role.

        list($gradebookrolessql, $gradebookrolesparams) = $DB->get_in_or_equal(explode(',', $this->gradebookroles), SQL_PARAMS_NAMED, 'grbr0');

        // Check the status of showing only active enrolments.

        $coursecontext = $this->context->get_course_context(true);

        $defaultgradeshowactiveenrol = !empty($CFG->grade_report_showonlyactiveenrol);

        $showonlyactiveenrol = get_user_preferences('grade_report_showonlyactiveenrol', $defaultgradeshowactiveenrol);

        $showonlyactiveenrol = $showonlyactiveenrol || !has_capability('moodle/course:viewsuspendedusers', $coursecontext);

        // Limit to users with an active enrollment.

        list($enrolledsql, $enrolledparams) = get_enrolled_sql($this->context, '', 0, $showonlyactiveenrol);

        // Fields we need from the user table.

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

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

        // We want to query both the current context and parent contexts.

        list($relatedctxsql, $relatedctxparams) = $DB->get_in_or_equal($this->context->get_parent_context_ids(true), SQL_PARAMS_NAMED, 'relatedctx');

        // If the user has clicked one of the sort asc/desc arrows.

        if (is_numeric($this->sortitemid)) {

            $params = array_merge(array('gitemid' => $this->sortitemid), $gradebookrolesparams, $this->userwheresql_params,

                    $this->groupwheresql_params, $enrolledparams, $relatedctxparams);

            $sortjoin = "LEFT JOIN {grade_grades} g ON g.userid = u.id AND g.itemid = $this->sortitemid";

            if ($this->sortorder == 'ASC') {

                $sort = $DB->sql_order_by_null('g.finalgrade');

            } else {

                $sort = $DB->sql_order_by_null('g.finalgrade', SORT_DESC);

            }

            $sort .= ", u.idnumber, u.lastname, u.firstname, u.email";

        } else {

            $sortjoin = '';

            // The default sort will be that provided by the site for users, unless a valid user field is requested,

            // the value of which takes precedence.

            [$sort] = users_order_by_sql('u', null, $this->context, $userfieldssql->mappings);

            if (array_key_exists($this->sortitemid, $userfieldssql->mappings)) {

                // Ensure user sort field doesn't duplicate one of the default sort fields.

                $usersortfield = $userfieldssql->mappings[$this->sortitemid];

                $defaultsortfields = array_diff(explode(', ', $sort), [$usersortfield]);

                $sort = "{$usersortfield} {$this->sortorder}, " . implode(', ', $defaultsortfields);

            }

            $params = array_merge($gradebookrolesparams, $this->userwheresql_params, $this->groupwheresql_params, $enrolledparams, $relatedctxparams);

        }

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

        $sql = "SELECT {$userfieldssql->selects}

                  FROM {user} u

                        {$userfieldssql->joins}

                  JOIN ($enrolledsql) je ON je.id = u.id

                       $this->groupsql

                       $sortjoin

                  JOIN (

                           SELECT DISTINCT ra.userid

                             FROM {role_assignments} ra

                            WHERE ra.roleid IN ($this->gradebookroles)

                              AND ra.contextid $relatedctxsql

                       ) rainner ON rainner.userid = u.id

                   AND u.deleted = 0

                   $this->userwheresql

                   $this->groupwheresql

              ORDER BY $sort";

        // We never work with unlimited result. Limit the number of records by $this->get_max_students_per_page() if no other limit

        // is specified.

        $studentsperpage = ($this->get_students_per_page() && !$allusers) ?

            $this->get_students_per_page() : $this->get_max_students_per_page();

        $this->users = $DB->get_records_sql($sql, $params, $studentsperpage * $this->page, $studentsperpage);

        if (empty($this->users)) {

            $this->userselect = '';

            $this->users = array();

            $this->userselectparams = array();

        } else {

            list($usql, $uparams) = $DB->get_in_or_equal(array_keys($this->users), SQL_PARAMS_NAMED, 'usid0');

            $this->userselect = "AND g.userid $usql";

            $this->userselectparams = $uparams;

            // First flag everyone as not suspended.

            foreach ($this->users as $user) {

                $this->users[$user->id]->suspendedenrolment = false;

            }

            // If we want to mix both suspended and not suspended users, let's find out who is suspended.

            if (!$showonlyactiveenrol) {

                $sql = "SELECT ue.userid

                          FROM {user_enrolments} ue

                          JOIN {enrol} e ON e.id = ue.enrolid

                         WHERE ue.userid $usql

                               AND ue.status = :uestatus

                               AND e.status = :estatus

                               AND e.courseid = :courseid

                               AND ue.timestart < :now1 AND (ue.timeend = 0 OR ue.timeend > :now2)

                      GROUP BY ue.userid";

                $time = time();

                $params = array_merge($uparams, array('estatus' => ENROL_INSTANCE_ENABLED, 'uestatus' => ENROL_USER_ACTIVE,

                        'courseid' => $coursecontext->instanceid, 'now1' => $time, 'now2' => $time));

                $useractiveenrolments = $DB->get_records_sql($sql, $params);

                foreach ($this->users as $user) {

                    $this->users[$user->id]->suspendedenrolment = !array_key_exists($user->id, $useractiveenrolments);

                }

            }

        }

        return $this->users;

    }

    /**

     * Load all grade items.

     */

    protected function get_allgradeitems() {

        if (!empty($this->allgradeitems)) {

            return $this->allgradeitems;

        }

        $allgradeitems = grade_item::fetch_all(array('courseid' => $this->courseid));

        // But hang on - don't include ones which are set to not show the grade at all.

        $this->allgradeitems = array_filter($allgradeitems, function($item) {

            return $item->gradetype != GRADE_TYPE_NONE;

        });

        return $this->allgradeitems;

    }

    /**

     * Return the maximum number of students we can display per page.

     *

     * This is based on the number of grade items on the course, to limit the overall number of grades displayed on a single page.

     * Trying to display too many grades causes browser issues.

     *

     * @return int

     */

    public function get_max_students_per_page(): int {

        global $CFG;

        $gradeitemcount = count($this->get_allgradeitems());

        if (isset($CFG->maxgradesperpage) && clean_param($CFG->maxgradesperpage, PARAM_INT) > 0) {

            $maxgradesperpage = $CFG->maxgradesperpage;

        } else {

            $maxgradesperpage = self::MAX_GRADES_PER_PAGE;

        }

        if ($gradeitemcount > 0) {

            return round($maxgradesperpage / $gradeitemcount);

        } else {

            return $maxgradesperpage;

        }

    }

    /**

     * we supply the userids in this query, and get all the grades

     * pulls out all the grades, this does not need to worry about paging

     */

    public function load_final_grades() {

        global $CFG, $DB;

        if (!empty($this->grades)) {

            return;

        }

        if (empty($this->users)) {

            return;

        }

        // please note that we must fetch all grade_grades fields if we want to construct grade_grade object from it!

        $params = array_merge(array('courseid'=>$this->courseid), $this->userselectparams);

        $sql = "SELECT g.*

                  FROM {grade_items} gi,

                       {grade_grades} g

                 WHERE g.itemid = gi.id AND gi.courseid = :courseid {$this->userselect}";

        $userids = array_keys($this->users);

        $allgradeitems = $this->get_allgradeitems();

        if ($grades = $DB->get_records_sql($sql, $params)) {

            foreach ($grades as $graderec) {

                $grade = new grade_grade($graderec, false);

                if (!empty($allgradeitems[$graderec->itemid])) {

                    // Note: Filter out grades which have a grade type of GRADE_TYPE_NONE.

                    // Only grades without this type are present in $allgradeitems.

                    $this->allgrades[$graderec->userid][$graderec->itemid] = $grade;

                }

                if (in_array($graderec->userid, $userids) and array_key_exists($graderec->itemid, $this->gtree->get_items())) { // some items may not be present!!

                    $this->grades[$graderec->userid][$graderec->itemid] = $grade;

                    $this->grades[$graderec->userid][$graderec->itemid]->grade_item = $this->gtree->get_item($graderec->itemid); // db caching

                }

            }

        }

        // prefil grades that do not exist yet

        foreach ($userids as $userid) {

            foreach ($this->gtree->get_items() as $itemid => $unused) {

                if (!isset($this->grades[$userid][$itemid])) {

                    $this->grades[$userid][$itemid] = new grade_grade();

                    $this->grades[$userid][$itemid]->itemid = $itemid;

                    $this->grades[$userid][$itemid]->userid = $userid;

                    $this->grades[$userid][$itemid]->grade_item = $this->gtree->get_item($itemid); // db caching

                    $this->allgrades[$userid][$itemid] = $this->grades[$userid][$itemid];

                }

            }

        }

        // Pre fill grades for any remaining items which might be collapsed.

        foreach ($userids as $userid) {

            foreach ($allgradeitems as $itemid => $gradeitem) {

                if (!isset($this->allgrades[$userid][$itemid])) {

                    $this->allgrades[$userid][$itemid] = new grade_grade();

                    $this->allgrades[$userid][$itemid]->itemid = $itemid;

                    $this->allgrades[$userid][$itemid]->userid = $userid;

                    $this->allgrades[$userid][$itemid]->grade_item = $gradeitem;

                }

            }

        }

    }

    /**

     * Builds and returns the rows that will make up the left part of the grader report

     * This consists of student names and icons, links to user reports and id numbers, as well

     * as header cells for these columns. It also includes the fillers required for the

     * categories displayed on the right side of the report.

     * @param boolean $displayaverages whether to display average rows in the table

     * @return array Array of html_table_row objects

     */

    public function get_left_rows($displayaverages) {

        global $CFG, $OUTPUT;

        // Course context to determine how the user details should be displayed.

        $coursecontext = context_course::instance($this->courseid);

        $rows = [];

        $showuserimage = $this->get_pref('showuserimage');

        $viewfullnames = has_capability('moodle/site:viewfullnames', $this->context);

        $extrafields = \core_user\fields::get_identity_fields($this->context);

        $arrows = $this->get_sort_arrows($extrafields);

        $colspan = 1 + count($extrafields);

        $levels = count($this->gtree->levels) - 1;

        $fillercell = new html_table_cell();

        $fillercell->header = true;

        $fillercell->attributes['scope'] = 'col';

        $fillercell->attributes['class'] = 'cell topleft';

        $fillercell->text = html_writer::span(get_string('participants'), 'accesshide');

        $fillercell->colspan = $colspan;

        $fillercell->rowspan = $levels;

        $row = new html_table_row(array($fillercell));

        if ($levels >= 1) { // Do not display the filler cell if there are no levels as there will be nothing else in the row.

            $rows[] = $row;

        }

        for ($i = 1; $i < $levels; $i++) {

            $row = new html_table_row();

            $rows[] = $row;

        }

        $headerrow = new html_table_row();

        $headerrow->attributes['class'] = 'heading';

        $studentheader = new html_table_cell();

        // The browser's scrollbar may partly cover (in certain operative systems) the content in the student header

        // when horizontally scrolling through the table contents (most noticeable when in RTL mode).

        // Therefore, add slight padding on the left or right when using RTL mode.

        $studentheader->attributes['class'] = "header ps-3";

        $studentheader->scope = 'col';

        $studentheader->header = true;

        $studentheader->id = 'studentheader';

        $element = ['type' => 'userfield', 'name' => 'fullname'];

        $studentheader->text = $arrows['studentname'] .

            $this->gtree->get_cell_action_menu($element, 'gradeitem', $this->gpr, $this->baseurl);

        $headerrow->cells[] = $studentheader;

        foreach ($extrafields as $field) {

            $fieldheader = new html_table_cell();

            $fieldheader->attributes['class'] = 'userfield user' . $field;

            $fieldheader->attributes['data-col'] = $field;

            $fieldheader->scope = 'col';

            $fieldheader->header = true;

            $collapsecontext = [

                'field' => $field,

                'name' => \core_user\fields::get_display_name($field),

            ];

            $collapsedicon = $OUTPUT->render_from_template('gradereport_grader/collapse/icon', $collapsecontext);

            // Need to wrap the button into a div with our hooking element for user items, gradeitems already have this.

            $collapsedicon = html_writer::div($collapsedicon, 'd-none', ['data-collapse' => 'expandbutton']);

            $element = ['type' => 'userfield', 'name' => $field];

            $fieldheader->text = $arrows[$field] .

                $this->gtree->get_cell_action_menu($element, 'gradeitem', $this->gpr, $this->baseurl) . $collapsedicon;

            $headerrow->cells[] = $fieldheader;

        }

        $rows[] = $headerrow;

        $suspendedstring = null;

        $usercount = 0;

        foreach ($this->users as $userid => $user) {

            $userrow = new html_table_row();

            $userrow->id = 'fixed_user_'.$userid;

            $userrow->attributes['class'] = ($usercount % 2) ? 'userrow even' : 'userrow odd';

            $usercell = new html_table_cell();

            $usercell->attributes['class'] = ($usercount % 2) ? 'header user even' : 'header user odd';

            $usercount++;

            $usercell->header = true;

            $usercell->scope = 'row';

            if ($showuserimage) {

                $usercell->text = $OUTPUT->render(\core_user::get_profile_picture($user, $coursecontext, [

                    'link' => false, 'visibletoscreenreaders' => false

                ]));

            }

            $fullname = fullname($user, $viewfullnames);

            $usercell->text = html_writer::link(

                \core_user::get_profile_url($user, $coursecontext),

                $usercell->text . $fullname,

                ['class' => 'username']

            );

            if (!empty($user->suspendedenrolment)) {

                $usercell->attributes['class'] .= ' usersuspended';

                //may be lots of suspended users so only get the string once

                if (empty($suspendedstring)) {

                    $suspendedstring = get_string('userenrolmentsuspended', 'grades');

                }

                $icon = $OUTPUT->pix_icon('i/enrolmentsuspended', $suspendedstring);

                $usercell->text .= html_writer::tag('span', $icon, array('class'=>'usersuspendedicon'));

            }

            // The browser's scrollbar may partly cover (in certain operative systems) the content in the user cells

            // when horizontally scrolling through the table contents (most noticeable when in RTL mode).

            // Therefore, add slight padding on the left or right when using RTL mode.

            $usercell->attributes['class'] .= ' ps-3';

            $usercell->text .= $this->gtree->get_cell_action_menu(['userid' => $userid], 'user', $this->gpr);

            $userrow->cells[] = $usercell;

            foreach ($extrafields as $field) {

                $fieldcellcontent = s($user->$field);

                if ($field === 'country') {

                    $countries = get_string_manager()->get_list_of_countries();

                    $fieldcellcontent = $countries[$user->$field] ?? $fieldcellcontent;

                }

                $fieldcell = new html_table_cell();

                $fieldcell->attributes['class'] = 'userfield user' . $field;

                $fieldcell->attributes['data-col'] = $field;

                $fieldcell->header = false;

                $fieldcell->text = html_writer::tag('div', $fieldcellcontent, [

                    'data-collapse' => 'content'

                ]);

                $userrow->cells[] = $fieldcell;

            }

            $userrow->attributes['data-uid'] = $userid;

            $rows[] = $userrow;

        }

        $rows = $this->get_left_range_row($rows, $colspan);

        if ($displayaverages) {

            $rows = $this->get_left_avg_row($rows, $colspan, true);

            $rows = $this->get_left_avg_row($rows, $colspan);

        }

        return $rows;

    }

    /**

     * Builds and returns the rows that will make up the right part of the grader report

     * @param boolean $displayaverages whether to display average rows in the table

     * @return array Array of html_table_row objects

     */

    public function get_right_rows(bool $displayaverages): array {

        global $CFG, $USER, $OUTPUT, $DB, $PAGE;

        $rows = [];

        $this->rowcount = 0;

        $strgrade = get_string('gradenoun');

        $this->get_sort_arrows();

        // Get preferences once.

        $quickgrading = $this->get_pref('quickgrading');

        // Get strings which are re-used inside the loop.

        $strftimedatetimeshort = get_string('strftimedatetimeshort');

        $strerror = get_string('error');

        $stroverridengrade = get_string('overridden', 'grades');

        $strfail = get_string('fail', 'grades');

        $strpass = get_string('pass', 'grades');

        $viewfullnames = has_capability('moodle/site:viewfullnames', $this->context);

        // Preload scale objects for items with a scaleid and initialize tab indices.

        $scaleslist = [];

        foreach ($this->gtree->get_items() as $itemid => $item) {

            if (!empty($item->scaleid)) {

                $scaleslist[] = $item->scaleid;

            }

        }

        $cache = \cache::make_from_params(\cache_store::MODE_REQUEST, 'gradereport_grader', 'scales');

        $scalesarray = $cache->get(get_class($this));

        if (!$scalesarray) {

            $scalesarray = $DB->get_records_list('scale', 'id', $scaleslist);

            // Save to cache.

            $cache->set(get_class($this), $scalesarray);

        }

        foreach ($this->gtree->get_levels() as $row) {

            $headingrow = new html_table_row();

            $headingrow->attributes['class'] = 'heading_name_row';

            foreach ($row as $element) {

                $sortlink = clone($this->baseurl);

                if (isset($element['object']->id)) {

                    $sortlink->param('sortitemid', $element['object']->id);

                }

                $type   = $element['type'];

                if (!empty($element['colspan'])) {

                    $colspan = $element['colspan'];

                } else {

                    $colspan = 1;

                }

                if (!empty($element['depth'])) {

                    $catlevel = 'catlevel'.$element['depth'];

                } else {

                    $catlevel = '';

                }

                // Element is a filler.

                if ($type == 'filler' || $type == 'fillerfirst' || $type == 'fillerlast') {

                    $fillercell = new html_table_cell();

                    $fillercell->attributes['class'] = $type . ' ' . $catlevel;

                    $fillercell->colspan = $colspan;

                    $fillercell->text = ' ';

                    // This is a filler cell; don't use a <th>, it'll confuse screen readers.

                    $fillercell->header = false;

                    $headingrow->cells[] = $fillercell;

                } else if ($type == 'category') {

                    // Make sure the grade category has a grade total or at least has child grade items.

                    if (grade_tree::can_output_item($element)) {

                        // Element is a category.

                        $categorycell = new html_table_cell();

                        $categorycell->attributes['class'] = 'category ' . $catlevel;

                        $categorycell->colspan = $colspan;

                        $categorycell->header = true;

                        $categorycell->scope = 'col';

                        $statusicons = $this->gtree->set_grade_status_icons($element);

                        if ($statusicons) {

                            $categorycell->attributes['class'] .= ' statusicons';

                        }

                        $context = new stdClass();

                        $context->courseheader = $this->get_course_header($element);

                        $context->actionmenu = $this->gtree->get_cell_action_menu($element, 'gradeitem', $this->gpr);

                        $context->statusicons = $statusicons;

                        $categorycell->text = $OUTPUT->render_from_template('gradereport_grader/categorycell', $context);

                        $headingrow->cells[] = $categorycell;

                    }

                } else {

                    // Element is a grade_item.

                    $arrow = '';

                    if ($element['object']->id == $this->sortitemid) {

                        if ($this->sortorder == 'ASC') {

                            $arrow = $this->get_sort_arrow('down', $sortlink);

                        } else {

                            $arrow = $this->get_sort_arrow('up', $sortlink);

                        }

                    }

                    $collapsecontext = [

                        'field' => $element['object']->id,

                        'name' => $element['object']->get_name(),

                    ];

                    $collapsedicon = '';

                    // We do not want grade category total items to be hidden away as it is controlled by something else.

                    if (!$element['object']->is_aggregate_item()) {

                        $collapsedicon = $OUTPUT->render_from_template('gradereport_grader/collapse/icon', $collapsecontext);

                    }

                    $headerlink = grade_helper::get_element_header($element, true,

                        true, false, false, true);

                    $itemcell = new html_table_cell();

                    $itemcell->attributes['class'] = $type . ' ' . $catlevel .

                        ' highlightable'. ' i'. $element['object']->id;

                    $itemcell->attributes['data-itemid'] = $element['object']->id;

                    $singleview = $this->gtree->get_cell_action_menu($element, 'gradeitem', $this->gpr, $this->baseurl);

                    $statusicons = $this->gtree->set_grade_status_icons($element);

                    if ($statusicons) {

                        $itemcell->attributes['class'] .= ' statusicons';

                    }

                    $itemcell->attributes['class'] .= $this->get_cell_display_class($element['object']);

                    $itemcell->colspan = $colspan;

                    $itemcell->header = true;

                    $itemcell->scope = 'col';

                    $context = new stdClass();

                    $context->headerlink = $headerlink;

                    $context->arrow = $arrow;

                    $context->singleview = $singleview;

                    $context->statusicons = $statusicons;

                    $context->collapsedicon = $collapsedicon;

                    $itemcell->text = $OUTPUT->render_from_template('gradereport_grader/headercell', $context);

                    $headingrow->cells[] = $itemcell;

                }

            }

            $rows[] = $headingrow;

        }

        // Get all the grade items if the user can not view hidden grade items.

        // It is possible that the user is simply viewing the 'Course total' by switching to the 'Aggregates only' view

        // and that this user does not have the ability to view hidden items. In this case we still need to pass all the

        // grade items (in case one has been hidden) as the course total shown needs to be adjusted for this particular

        // user.

        if (!$this->canviewhidden) {

            $allgradeitems = $this->get_allgradeitems();

        }

        foreach ($this->users as $userid => $user) {

            if ($this->canviewhidden) {

                $altered = [];

                $unknown = [];

            } else {

                $usergrades = $this->allgrades[$userid];

                $hidingaffected = grade_grade::get_hiding_affected($usergrades, $allgradeitems);

                $altered = $hidingaffected['altered'];

                $unknown = $hidingaffected['unknowngrades'];

                unset($hidingaffected);

            }

            $itemrow = new html_table_row();

            $itemrow->id = 'user_'.$userid;

            $fullname = fullname($user, $viewfullnames);

            foreach ($this->gtree->items as $itemid => $unused) {

                $item =& $this->gtree->items[$itemid];

                $grade = $this->grades[$userid][$item->id];

                $itemcell = new html_table_cell();

                $itemcell->id = 'u' . $userid . 'i' . $itemid;

                $itemcell->attributes['data-itemid'] = $itemid;

                $itemcell->attributes['class'] = 'gradecell';

                // Get the decimal points preference for this item.

                $decimalpoints = $item->get_decimals();

                if (array_key_exists($itemid, $unknown)) {

                    $gradeval = null;

                } else if (array_key_exists($itemid, $altered)) {

                    $gradeval = $altered[$itemid];

                } else {

                    $gradeval = $grade->finalgrade;

                }

                $context = new stdClass();

                // MDL-11274: Hide grades in the grader report if the current grader

                // doesn't have 'moodle/grade:viewhidden'.

                if (!$this->canviewhidden && $grade->is_hidden()) {

                    if (!empty($CFG->grade_hiddenasdate) && $grade->get_datesubmitted()

                            && !$item->is_category_item() && !$item->is_course_item()) {

                        // The problem here is that we do not have the time when grade value was modified,