mirror of
https://github.com/moodle/moodle.git
synced 2025-02-12 19:41:59 +01:00
edffadfd1c
This was breaking the contribution column, which needs to know the weights of all the categories up the tree, whether they are visible or not.
1149 lines
50 KiB
PHP
1149 lines
50 KiB
PHP
<?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 grade_user_report class is defined
|
|
*
|
|
* @package gradereport_user
|
|
* @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');
|
|
|
|
//showhiddenitems values
|
|
define("GRADE_REPORT_USER_HIDE_HIDDEN", 0);
|
|
define("GRADE_REPORT_USER_HIDE_UNTIL", 1);
|
|
define("GRADE_REPORT_USER_SHOW_HIDDEN", 2);
|
|
|
|
/**
|
|
* Class providing an API for the user report building and displaying.
|
|
* @uses grade_report
|
|
* @package gradereport_user
|
|
*/
|
|
class grade_report_user extends grade_report {
|
|
|
|
/**
|
|
* The user.
|
|
* @var object $user
|
|
*/
|
|
public $user;
|
|
|
|
/**
|
|
* A flexitable to hold the data.
|
|
* @var object $table
|
|
*/
|
|
public $table;
|
|
|
|
/**
|
|
* An array of table headers
|
|
* @var array
|
|
*/
|
|
public $tableheaders = array();
|
|
|
|
/**
|
|
* An array of table columns
|
|
* @var array
|
|
*/
|
|
public $tablecolumns = array();
|
|
|
|
/**
|
|
* An array containing rows of data for the table.
|
|
* @var type
|
|
*/
|
|
public $tabledata = array();
|
|
|
|
/**
|
|
* The grade tree structure
|
|
* @var grade_tree
|
|
*/
|
|
public $gtree;
|
|
|
|
/**
|
|
* Flat structure similar to grade tree
|
|
*/
|
|
public $gseq;
|
|
|
|
/**
|
|
* show student ranks
|
|
*/
|
|
public $showrank;
|
|
|
|
/**
|
|
* show grade percentages
|
|
*/
|
|
public $showpercentage;
|
|
|
|
/**
|
|
* Show range
|
|
*/
|
|
public $showrange = true;
|
|
|
|
/**
|
|
* Show grades in the report, default true
|
|
* @var bool
|
|
*/
|
|
public $showgrade = true;
|
|
|
|
/**
|
|
* Decimal points to use for values in the report, default 2
|
|
* @var int
|
|
*/
|
|
public $decimals = 2;
|
|
|
|
/**
|
|
* The number of decimal places to round range to, default 0
|
|
* @var int
|
|
*/
|
|
public $rangedecimals = 0;
|
|
|
|
/**
|
|
* Show grade feedback in the report, default true
|
|
* @var bool
|
|
*/
|
|
public $showfeedback = true;
|
|
|
|
/**
|
|
* Show grade weighting in the report, default true.
|
|
* @var bool
|
|
*/
|
|
public $showweight = true;
|
|
|
|
/**
|
|
* Show letter grades in the report, default false
|
|
* @var bool
|
|
*/
|
|
public $showlettergrade = false;
|
|
|
|
/**
|
|
* Show the calculated contribution to the course total column.
|
|
* @var bool
|
|
*/
|
|
public $showcontributiontocoursetotal = true;
|
|
|
|
/**
|
|
* Show average grades in the report, default false.
|
|
* @var false
|
|
*/
|
|
public $showaverage = false;
|
|
|
|
public $maxdepth;
|
|
public $evenodd;
|
|
|
|
public $canviewhidden;
|
|
|
|
public $switch;
|
|
|
|
/**
|
|
* Show hidden items even when user does not have required cap
|
|
*/
|
|
public $showhiddenitems;
|
|
public $showtotalsifcontainhidden;
|
|
|
|
public $baseurl;
|
|
public $pbarurl;
|
|
|
|
/**
|
|
* The modinfo object to be used.
|
|
*
|
|
* @var course_modinfo
|
|
*/
|
|
protected $modinfo = null;
|
|
|
|
/**
|
|
* View as user.
|
|
*
|
|
* When this is set to true, the visibility checks, and capability checks will be
|
|
* applied to the user whose grades are being displayed. This is very useful when
|
|
* a mentor/parent is viewing the report of their mentee because they need to have
|
|
* access to the same information, but not more, not less.
|
|
*
|
|
* @var boolean
|
|
*/
|
|
protected $viewasuser = false;
|
|
|
|
/**
|
|
* An array that collects the aggregationhints for every
|
|
* grade_item. The hints contain grade, grademin, grademax
|
|
* status, weight and parent.
|
|
*
|
|
* @var array
|
|
*/
|
|
protected $aggregationhints = array();
|
|
|
|
/**
|
|
* 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 $userid The id of the user
|
|
* @param bool $viewasuser Set this to true when the current user is a mentor/parent of the targetted user.
|
|
*/
|
|
public function __construct($courseid, $gpr, $context, $userid, $viewasuser = null) {
|
|
global $DB, $CFG;
|
|
parent::__construct($courseid, $gpr, $context);
|
|
|
|
$this->showrank = grade_get_setting($this->courseid, 'report_user_showrank', $CFG->grade_report_user_showrank);
|
|
$this->showpercentage = grade_get_setting($this->courseid, 'report_user_showpercentage', $CFG->grade_report_user_showpercentage);
|
|
$this->showhiddenitems = grade_get_setting($this->courseid, 'report_user_showhiddenitems', $CFG->grade_report_user_showhiddenitems);
|
|
$this->showtotalsifcontainhidden = array($this->courseid => grade_get_setting($this->courseid, 'report_user_showtotalsifcontainhidden', $CFG->grade_report_user_showtotalsifcontainhidden));
|
|
|
|
$this->showgrade = grade_get_setting($this->courseid, 'report_user_showgrade', !empty($CFG->grade_report_user_showgrade));
|
|
$this->showrange = grade_get_setting($this->courseid, 'report_user_showrange', !empty($CFG->grade_report_user_showrange));
|
|
$this->showfeedback = grade_get_setting($this->courseid, 'report_user_showfeedback', !empty($CFG->grade_report_user_showfeedback));
|
|
|
|
$this->showweight = grade_get_setting($this->courseid, 'report_user_showweight',
|
|
!empty($CFG->grade_report_user_showweight));
|
|
|
|
$this->showcontributiontocoursetotal = grade_get_setting($this->courseid, 'report_user_showcontributiontocoursetotal',
|
|
!empty($CFG->grade_report_user_showcontributiontocoursetotal));
|
|
|
|
$this->showlettergrade = grade_get_setting($this->courseid, 'report_user_showlettergrade', !empty($CFG->grade_report_user_showlettergrade));
|
|
$this->showaverage = grade_get_setting($this->courseid, 'report_user_showaverage', !empty($CFG->grade_report_user_showaverage));
|
|
|
|
$this->viewasuser = $viewasuser;
|
|
|
|
// The default grade decimals is 2
|
|
$defaultdecimals = 2;
|
|
if (property_exists($CFG, 'grade_decimalpoints')) {
|
|
$defaultdecimals = $CFG->grade_decimalpoints;
|
|
}
|
|
$this->decimals = grade_get_setting($this->courseid, 'decimalpoints', $defaultdecimals);
|
|
|
|
// The default range decimals is 0
|
|
$defaultrangedecimals = 0;
|
|
if (property_exists($CFG, 'grade_report_user_rangedecimals')) {
|
|
$defaultrangedecimals = $CFG->grade_report_user_rangedecimals;
|
|
}
|
|
$this->rangedecimals = grade_get_setting($this->courseid, 'report_user_rangedecimals', $defaultrangedecimals);
|
|
|
|
$this->switch = grade_get_setting($this->courseid, 'aggregationposition', $CFG->grade_aggregationposition);
|
|
|
|
// Grab the grade_tree for this course
|
|
$this->gtree = new grade_tree($this->courseid, false, $this->switch, null, !$CFG->enableoutcomes);
|
|
|
|
// Get the user (for full name).
|
|
$this->user = $DB->get_record('user', array('id' => $userid));
|
|
|
|
// What user are we viewing this as?
|
|
$coursecontext = context_course::instance($this->courseid);
|
|
if ($viewasuser) {
|
|
$this->modinfo = new course_modinfo($this->course, $this->user->id);
|
|
$this->canviewhidden = has_capability('moodle/grade:viewhidden', $coursecontext, $this->user->id);
|
|
} else {
|
|
$this->modinfo = $this->gtree->modinfo;
|
|
$this->canviewhidden = has_capability('moodle/grade:viewhidden', $coursecontext);
|
|
}
|
|
|
|
// Determine the number of rows and indentation.
|
|
$this->maxdepth = 1;
|
|
$this->inject_rowspans($this->gtree->top_element);
|
|
$this->maxdepth++; // Need to account for the lead column that spans all children.
|
|
for ($i = 1; $i <= $this->maxdepth; $i++) {
|
|
$this->evenodd[$i] = 0;
|
|
}
|
|
|
|
$this->tabledata = array();
|
|
|
|
// base url for sorting by first/last name
|
|
$this->baseurl = $CFG->wwwroot.'/grade/report?id='.$courseid.'&userid='.$userid;
|
|
$this->pbarurl = $this->baseurl;
|
|
|
|
// no groups on this report - rank is from all course users
|
|
$this->setup_table();
|
|
|
|
//optionally calculate grade item averages
|
|
$this->calculate_averages();
|
|
}
|
|
|
|
/**
|
|
* Recurses through a tree of elements setting the rowspan property on each element
|
|
*
|
|
* @param array $element Either the top element or, during recursion, the current element
|
|
* @return int The number of elements processed
|
|
*/
|
|
function inject_rowspans(&$element) {
|
|
|
|
if ($element['depth'] > $this->maxdepth) {
|
|
$this->maxdepth = $element['depth'];
|
|
}
|
|
if (empty($element['children'])) {
|
|
return 1;
|
|
}
|
|
$count = 1;
|
|
|
|
foreach ($element['children'] as $key=>$child) {
|
|
// If category is hidden then do not include it in the rowspan.
|
|
if ($child['type'] == 'category' && $child['object']->is_hidden() && !$this->canviewhidden
|
|
&& ($this->showhiddenitems == GRADE_REPORT_USER_HIDE_HIDDEN
|
|
|| ($this->showhiddenitems == GRADE_REPORT_USER_HIDE_UNTIL && !$child['object']->is_hiddenuntil()))) {
|
|
// Just calculate the rowspans for children of this category, don't add them to the count.
|
|
$this->inject_rowspans($element['children'][$key]);
|
|
} else {
|
|
$count += $this->inject_rowspans($element['children'][$key]);
|
|
}
|
|
}
|
|
|
|
$element['rowspan'] = $count;
|
|
return $count;
|
|
}
|
|
|
|
|
|
/**
|
|
* Prepares the headers and attributes of the flexitable.
|
|
*/
|
|
public function setup_table() {
|
|
/*
|
|
* Table has 1-8 columns
|
|
*| All columns except for itemname/description are optional
|
|
*/
|
|
|
|
// setting up table headers
|
|
|
|
$this->tablecolumns = array('itemname');
|
|
$this->tableheaders = array($this->get_lang_string('gradeitem', 'grades'));
|
|
|
|
if ($this->showweight) {
|
|
$this->tablecolumns[] = 'weight';
|
|
$this->tableheaders[] = $this->get_lang_string('weightuc', 'grades');
|
|
}
|
|
|
|
if ($this->showgrade) {
|
|
$this->tablecolumns[] = 'grade';
|
|
$this->tableheaders[] = $this->get_lang_string('grade', 'grades');
|
|
}
|
|
|
|
if ($this->showrange) {
|
|
$this->tablecolumns[] = 'range';
|
|
$this->tableheaders[] = $this->get_lang_string('range', 'grades');
|
|
}
|
|
|
|
if ($this->showpercentage) {
|
|
$this->tablecolumns[] = 'percentage';
|
|
$this->tableheaders[] = $this->get_lang_string('percentage', 'grades');
|
|
}
|
|
|
|
if ($this->showlettergrade) {
|
|
$this->tablecolumns[] = 'lettergrade';
|
|
$this->tableheaders[] = $this->get_lang_string('lettergrade', 'grades');
|
|
}
|
|
|
|
if ($this->showrank) {
|
|
$this->tablecolumns[] = 'rank';
|
|
$this->tableheaders[] = $this->get_lang_string('rank', 'grades');
|
|
}
|
|
|
|
if ($this->showaverage) {
|
|
$this->tablecolumns[] = 'average';
|
|
$this->tableheaders[] = $this->get_lang_string('average', 'grades');
|
|
}
|
|
|
|
if ($this->showfeedback) {
|
|
$this->tablecolumns[] = 'feedback';
|
|
$this->tableheaders[] = $this->get_lang_string('feedback', 'grades');
|
|
}
|
|
|
|
if ($this->showcontributiontocoursetotal) {
|
|
$this->tablecolumns[] = 'contributiontocoursetotal';
|
|
$this->tableheaders[] = $this->get_lang_string('contributiontocoursetotal', 'grades');
|
|
}
|
|
}
|
|
|
|
function fill_table() {
|
|
//print "<pre>";
|
|
//print_r($this->gtree->top_element);
|
|
$this->fill_table_recursive($this->gtree->top_element);
|
|
//print_r($this->tabledata);
|
|
//print "</pre>";
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Fill the table with data.
|
|
*
|
|
* @param $element - An array containing the table data for the current row.
|
|
*/
|
|
private function fill_table_recursive(&$element) {
|
|
global $DB, $CFG;
|
|
|
|
$type = $element['type'];
|
|
$depth = $element['depth'];
|
|
$grade_object = $element['object'];
|
|
$eid = $grade_object->id;
|
|
$element['userid'] = $this->user->id;
|
|
$fullname = $this->gtree->get_element_header($element, true, true, true, true);
|
|
$data = array();
|
|
$hidden = '';
|
|
$excluded = '';
|
|
$itemlevel = ($type == 'categoryitem' || $type == 'category' || $type == 'courseitem') ? $depth : ($depth + 1);
|
|
$class = 'level' . $itemlevel . ' level' . ($itemlevel % 2 ? 'odd' : 'even');
|
|
$classfeedback = '';
|
|
|
|
// If this is a hidden grade category, hide it completely from the user
|
|
if ($type == 'category' && $grade_object->is_hidden() && !$this->canviewhidden && (
|
|
$this->showhiddenitems == GRADE_REPORT_USER_HIDE_HIDDEN ||
|
|
($this->showhiddenitems == GRADE_REPORT_USER_HIDE_UNTIL && !$grade_object->is_hiddenuntil()))) {
|
|
return false;
|
|
}
|
|
|
|
if ($type == 'category') {
|
|
$this->evenodd[$depth] = (($this->evenodd[$depth] + 1) % 2);
|
|
}
|
|
$alter = ($this->evenodd[$depth] == 0) ? 'even' : 'odd';
|
|
|
|
/// Process those items that have scores associated
|
|
if ($type == 'item' or $type == 'categoryitem' or $type == 'courseitem') {
|
|
$header_row = "row_{$eid}_{$this->user->id}";
|
|
$header_cat = "cat_{$grade_object->categoryid}_{$this->user->id}";
|
|
|
|
if (! $grade_grade = grade_grade::fetch(array('itemid'=>$grade_object->id,'userid'=>$this->user->id))) {
|
|
$grade_grade = new grade_grade();
|
|
$grade_grade->userid = $this->user->id;
|
|
$grade_grade->itemid = $grade_object->id;
|
|
}
|
|
|
|
$grade_grade->load_grade_item();
|
|
|
|
/// Hidden Items
|
|
if ($grade_grade->grade_item->is_hidden()) {
|
|
$hidden = ' dimmed_text';
|
|
}
|
|
|
|
$hide = false;
|
|
// If this is a hidden grade item, hide it completely from the user.
|
|
if ($grade_grade->is_hidden() && !$this->canviewhidden && (
|
|
$this->showhiddenitems == GRADE_REPORT_USER_HIDE_HIDDEN ||
|
|
($this->showhiddenitems == GRADE_REPORT_USER_HIDE_UNTIL && !$grade_grade->is_hiddenuntil()))) {
|
|
$hide = true;
|
|
} else if (!empty($grade_object->itemmodule) && !empty($grade_object->iteminstance)) {
|
|
// The grade object can be marked visible but still be hidden if
|
|
// the student cannot see the activity due to conditional access
|
|
// and it's set to be hidden entirely.
|
|
$instances = $this->modinfo->get_instances_of($grade_object->itemmodule);
|
|
if (!empty($instances[$grade_object->iteminstance])) {
|
|
$cm = $instances[$grade_object->iteminstance];
|
|
if (!$cm->uservisible) {
|
|
// If there is 'availableinfo' text then it is only greyed
|
|
// out and not entirely hidden.
|
|
if (!$cm->availableinfo) {
|
|
$hide = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Actual Grade - We need to calculate this whether the row is hidden or not.
|
|
$gradeval = $grade_grade->finalgrade;
|
|
$hint = $grade_grade->get_aggregation_hint();
|
|
if (!$this->canviewhidden) {
|
|
/// Virtual Grade (may be calculated excluding hidden items etc).
|
|
$adjustedgrade = $this->blank_hidden_total_and_adjust_bounds($this->courseid,
|
|
$grade_grade->grade_item,
|
|
$gradeval);
|
|
|
|
$gradeval = $adjustedgrade['grade'];
|
|
|
|
// We temporarily adjust the view of this grade item - because the min and
|
|
// max are affected by the hidden values in the aggregation.
|
|
$grade_grade->grade_item->grademax = $adjustedgrade['grademax'];
|
|
$grade_grade->grade_item->grademin = $adjustedgrade['grademin'];
|
|
$hint['status'] = $adjustedgrade['aggregationstatus'];
|
|
$hint['weight'] = $adjustedgrade['aggregationweight'];
|
|
} else {
|
|
// The max and min for an aggregation may be different to the grade_item.
|
|
if (!is_null($gradeval)) {
|
|
$grade_grade->grade_item->grademax = $grade_grade->rawgrademax;
|
|
$grade_grade->grade_item->grademin = $grade_grade->rawgrademin;
|
|
}
|
|
}
|
|
|
|
|
|
if (!$hide) {
|
|
/// Excluded Item
|
|
/**
|
|
if ($grade_grade->is_excluded()) {
|
|
$fullname .= ' ['.get_string('excluded', 'grades').']';
|
|
$excluded = ' excluded';
|
|
}
|
|
**/
|
|
|
|
/// Other class information
|
|
$class .= $hidden . $excluded;
|
|
if ($this->switch) { // alter style based on whether aggregation is first or last
|
|
$class .= ($type == 'categoryitem' or $type == 'courseitem') ? " ".$alter."d$depth baggt b2b" : " item b1b";
|
|
} else {
|
|
$class .= ($type == 'categoryitem' or $type == 'courseitem') ? " ".$alter."d$depth baggb" : " item b1b";
|
|
}
|
|
if ($type == 'categoryitem' or $type == 'courseitem') {
|
|
$header_cat = "cat_{$grade_object->iteminstance}_{$this->user->id}";
|
|
}
|
|
|
|
/// Name
|
|
$data['itemname']['content'] = $fullname;
|
|
$data['itemname']['class'] = $class;
|
|
$data['itemname']['colspan'] = ($this->maxdepth - $depth);
|
|
$data['itemname']['celltype'] = 'th';
|
|
$data['itemname']['id'] = $header_row;
|
|
|
|
if ($this->showfeedback) {
|
|
// Copy $class before appending itemcenter as feedback should not be centered
|
|
$classfeedback = $class;
|
|
}
|
|
$class .= " itemcenter ";
|
|
if ($this->showweight) {
|
|
$data['weight']['class'] = $class;
|
|
$data['weight']['content'] = '-';
|
|
$data['weight']['headers'] = "$header_cat $header_row weight";
|
|
// has a weight assigned, might be extra credit
|
|
|
|
// This obliterates the weight because it provides a more informative description.
|
|
if (is_numeric($hint['weight'])) {
|
|
$data['weight']['content'] = format_float($hint['weight'] * 100.0, 2) . ' %';
|
|
}
|
|
if ($hint['status'] != 'used' && $hint['status'] != 'unknown') {
|
|
$data['weight']['content'] .= '<br>' . get_string('aggregationhint' . $hint['status'], 'grades');
|
|
}
|
|
}
|
|
|
|
if ($this->showgrade) {
|
|
if ($grade_grade->grade_item->needsupdate) {
|
|
$data['grade']['class'] = $class.' gradingerror';
|
|
$data['grade']['content'] = get_string('error');
|
|
} else if (!empty($CFG->grade_hiddenasdate) and $grade_grade->get_datesubmitted() and !$this->canviewhidden and $grade_grade->is_hidden()
|
|
and !$grade_grade->grade_item->is_category_item() and !$grade_grade->grade_item->is_course_item()) {
|
|
// the problem here is that we do not have the time when grade value was modified, 'timemodified' is general modification date for grade_grades records
|
|
$class .= ' datesubmitted';
|
|
$data['grade']['class'] = $class;
|
|
$data['grade']['content'] = get_string('submittedon', 'grades', userdate($grade_grade->get_datesubmitted(), get_string('strftimedatetimeshort')));
|
|
|
|
} else if ($grade_grade->is_hidden()) {
|
|
$data['grade']['class'] = $class.' dimmed_text';
|
|
$data['grade']['content'] = '-';
|
|
if ($this->canviewhidden) {
|
|
$data['grade']['content'] = grade_format_gradevalue($gradeval,
|
|
$grade_grade->grade_item,
|
|
true);
|
|
}
|
|
} else {
|
|
$data['grade']['class'] = $class;
|
|
$data['grade']['content'] = grade_format_gradevalue($gradeval,
|
|
$grade_grade->grade_item,
|
|
true);
|
|
}
|
|
$data['grade']['headers'] = "$header_cat $header_row grade";
|
|
}
|
|
|
|
// Range
|
|
if ($this->showrange) {
|
|
$data['range']['class'] = $class;
|
|
$data['range']['content'] = $grade_grade->grade_item->get_formatted_range(GRADE_DISPLAY_TYPE_REAL, $this->rangedecimals);
|
|
$data['range']['headers'] = "$header_cat $header_row range";
|
|
}
|
|
|
|
// Percentage
|
|
if ($this->showpercentage) {
|
|
if ($grade_grade->grade_item->needsupdate) {
|
|
$data['percentage']['class'] = $class.' gradingerror';
|
|
$data['percentage']['content'] = get_string('error');
|
|
} else if ($grade_grade->is_hidden()) {
|
|
$data['percentage']['class'] = $class.' dimmed_text';
|
|
$data['percentage']['content'] = '-';
|
|
if ($this->canviewhidden) {
|
|
$data['percentage']['content'] = grade_format_gradevalue($gradeval, $grade_grade->grade_item, true, GRADE_DISPLAY_TYPE_PERCENTAGE);
|
|
}
|
|
} else {
|
|
$data['percentage']['class'] = $class;
|
|
$data['percentage']['content'] = grade_format_gradevalue($gradeval, $grade_grade->grade_item, true, GRADE_DISPLAY_TYPE_PERCENTAGE);
|
|
}
|
|
$data['percentage']['headers'] = "$header_cat $header_row percentage";
|
|
}
|
|
|
|
// Lettergrade
|
|
if ($this->showlettergrade) {
|
|
if ($grade_grade->grade_item->needsupdate) {
|
|
$data['lettergrade']['class'] = $class.' gradingerror';
|
|
$data['lettergrade']['content'] = get_string('error');
|
|
} else if ($grade_grade->is_hidden()) {
|
|
$data['lettergrade']['class'] = $class.' dimmed_text';
|
|
if (!$this->canviewhidden) {
|
|
$data['lettergrade']['content'] = '-';
|
|
} else {
|
|
$data['lettergrade']['content'] = grade_format_gradevalue($gradeval, $grade_grade->grade_item, true, GRADE_DISPLAY_TYPE_LETTER);
|
|
}
|
|
} else {
|
|
$data['lettergrade']['class'] = $class;
|
|
$data['lettergrade']['content'] = grade_format_gradevalue($gradeval, $grade_grade->grade_item, true, GRADE_DISPLAY_TYPE_LETTER);
|
|
}
|
|
$data['lettergrade']['headers'] = "$header_cat $header_row lettergrade";
|
|
}
|
|
|
|
// Rank
|
|
if ($this->showrank) {
|
|
if ($grade_grade->grade_item->needsupdate) {
|
|
$data['rank']['class'] = $class.' gradingerror';
|
|
$data['rank']['content'] = get_string('error');
|
|
} elseif ($grade_grade->is_hidden()) {
|
|
$data['rank']['class'] = $class.' dimmed_text';
|
|
$data['rank']['content'] = '-';
|
|
} else if (is_null($gradeval)) {
|
|
// no grade, no rank
|
|
$data['rank']['class'] = $class;
|
|
$data['rank']['content'] = '-';
|
|
|
|
} else {
|
|
/// find the number of users with a higher grade
|
|
$sql = "SELECT COUNT(DISTINCT(userid))
|
|
FROM {grade_grades}
|
|
WHERE finalgrade > ?
|
|
AND itemid = ?
|
|
AND hidden = 0";
|
|
$rank = $DB->count_records_sql($sql, array($grade_grade->finalgrade, $grade_grade->grade_item->id)) + 1;
|
|
|
|
$data['rank']['class'] = $class;
|
|
$data['rank']['content'] = "$rank/".$this->get_numusers(false); // total course users
|
|
}
|
|
$data['rank']['headers'] = "$header_cat $header_row rank";
|
|
}
|
|
|
|
// Average
|
|
if ($this->showaverage) {
|
|
$data['average']['class'] = $class;
|
|
if (!empty($this->gtree->items[$eid]->avg)) {
|
|
$data['average']['content'] = $this->gtree->items[$eid]->avg;
|
|
} else {
|
|
$data['average']['content'] = '-';
|
|
}
|
|
$data['average']['headers'] = "$header_cat $header_row average";
|
|
}
|
|
|
|
// Feedback
|
|
if ($this->showfeedback) {
|
|
if ($grade_grade->overridden > 0 AND ($type == 'categoryitem' OR $type == 'courseitem')) {
|
|
$data['feedback']['class'] = $classfeedback.' feedbacktext';
|
|
$data['feedback']['content'] = get_string('overridden', 'grades').': ' . format_text($grade_grade->feedback, $grade_grade->feedbackformat);
|
|
} else if (empty($grade_grade->feedback) or (!$this->canviewhidden and $grade_grade->is_hidden())) {
|
|
$data['feedback']['class'] = $classfeedback.' feedbacktext';
|
|
$data['feedback']['content'] = ' ';
|
|
} else {
|
|
$data['feedback']['class'] = $classfeedback.' feedbacktext';
|
|
$data['feedback']['content'] = format_text($grade_grade->feedback, $grade_grade->feedbackformat);
|
|
}
|
|
$data['feedback']['headers'] = "$header_cat $header_row feedback";
|
|
}
|
|
// Contribution to the course total column.
|
|
if ($this->showcontributiontocoursetotal) {
|
|
$data['contributiontocoursetotal']['class'] = $class;
|
|
$data['contributiontocoursetotal']['content'] = '-';
|
|
$data['contributiontocoursetotal']['headers'] = "$header_cat $header_row contributiontocoursetotal";
|
|
|
|
}
|
|
}
|
|
// We collect the aggregation hints whether they are hidden or not.
|
|
if ($this->showcontributiontocoursetotal) {
|
|
$hint['grademax'] = $grade_grade->grade_item->grademax;
|
|
$hint['grademin'] = $grade_grade->grade_item->grademin;
|
|
$hint['grade'] = $gradeval;
|
|
$parent = $grade_object->load_parent_category();
|
|
if ($grade_object->is_category_item()) {
|
|
$parent = $parent->load_parent_category();
|
|
}
|
|
$hint['parent'] = $parent->load_grade_item()->id;
|
|
$this->aggregationhints[$grade_grade->itemid] = $hint;
|
|
}
|
|
}
|
|
|
|
/// Category
|
|
if ($type == 'category') {
|
|
$data['leader']['class'] = $class.' '.$alter."d$depth b1t b2b b1l";
|
|
$data['leader']['rowspan'] = $element['rowspan'];
|
|
|
|
if ($this->switch) { // alter style based on whether aggregation is first or last
|
|
$data['itemname']['class'] = $class.' '.$alter."d$depth b1b b1t";
|
|
} else {
|
|
$data['itemname']['class'] = $class.' '.$alter."d$depth b2t";
|
|
}
|
|
$data['itemname']['colspan'] = ($this->maxdepth - $depth + count($this->tablecolumns) - 1);
|
|
$data['itemname']['content'] = $fullname;
|
|
$data['itemname']['celltype'] = 'th';
|
|
$data['itemname']['id'] = "cat_{$grade_object->id}_{$this->user->id}";
|
|
}
|
|
|
|
/// Add this row to the overall system
|
|
foreach ($data as $key => $celldata) {
|
|
$data[$key]['class'] .= ' column-' . $key;
|
|
}
|
|
$this->tabledata[] = $data;
|
|
|
|
/// Recursively iterate through all child elements
|
|
if (isset($element['children'])) {
|
|
foreach ($element['children'] as $key=>$child) {
|
|
$this->fill_table_recursive($element['children'][$key]);
|
|
}
|
|
}
|
|
|
|
// Check we are showing this column, and we are looking at the root of the table.
|
|
// This should be the very last thing this fill_table_recursive function does.
|
|
if ($this->showcontributiontocoursetotal && ($type == 'category' && $depth == 1)) {
|
|
// We should have collected all the hints by now - walk the tree again and build the contributions column.
|
|
|
|
$this->fill_contributions_column($element);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This function is called after the table has been built and the aggregationhints
|
|
* have been collected. We need this info to walk up the list of parents of each
|
|
* grade_item.
|
|
*
|
|
* @param $element - An array containing the table data for the current row.
|
|
*/
|
|
public function fill_contributions_column($element) {
|
|
|
|
// Recursively iterate through all child elements.
|
|
if (isset($element['children'])) {
|
|
foreach ($element['children'] as $key=>$child) {
|
|
$this->fill_contributions_column($element['children'][$key]);
|
|
}
|
|
} else if ($element['type'] == 'item') {
|
|
// This is a grade item (We don't do this for categories or we would double count).
|
|
$grade_object = $element['object'];
|
|
$itemid = $grade_object->id;
|
|
|
|
// Ignore anything with no hint - e.g. a hidden row.
|
|
if (isset($this->aggregationhints[$itemid])) {
|
|
|
|
// Normalise the gradeval.
|
|
$gradecat = $grade_object->load_parent_category();
|
|
if ($gradecat->aggregation == GRADE_AGGREGATE_SUM) {
|
|
// Natural aggregation/Sum of grades does not consider the mingrade, cannot traditionnally normalise it.
|
|
$graderange = $this->aggregationhints[$itemid]['grademax'];
|
|
$gradeval = $this->aggregationhints[$itemid]['grade'] / $graderange;
|
|
} else {
|
|
$gradeval = grade_grade::standardise_score($this->aggregationhints[$itemid]['grade'],
|
|
$this->aggregationhints[$itemid]['grademin'], $this->aggregationhints[$itemid]['grademax'], 0, 1);
|
|
}
|
|
|
|
// Multiply the normalised value by the weight
|
|
// of all the categories higher in the tree.
|
|
do {
|
|
if (!is_null($this->aggregationhints[$itemid]['weight'])) {
|
|
$gradeval *= $this->aggregationhints[$itemid]['weight'];
|
|
}
|
|
|
|
// The second part of this if is to prevent infinite loops
|
|
// in case of crazy data.
|
|
if (isset($this->aggregationhints[$itemid]['parent']) &&
|
|
$this->aggregationhints[$itemid]['parent'] != $itemid) {
|
|
$parent = $this->aggregationhints[$itemid]['parent'];
|
|
$itemid = $parent;
|
|
} else {
|
|
// We are at the top of the tree.
|
|
$parent = false;
|
|
}
|
|
} while ($parent);
|
|
|
|
// Convert to percent.
|
|
$gradeval *= 100;
|
|
|
|
// Now we need to loop through the "built" table data and update the
|
|
// contributions column for the current row.
|
|
$header_row = "row_{$grade_object->id}_{$this->user->id}";
|
|
foreach ($this->tabledata as $key => $row) {
|
|
if (isset($row['itemname']) && ($row['itemname']['id'] == $header_row)) {
|
|
// Found it - update the column.
|
|
$decimals = $grade_object->get_decimals();
|
|
$this->tabledata[$key]['contributiontocoursetotal']['content'] = format_float($gradeval, $decimals, true) . ' %';
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prints or returns the HTML from the flexitable.
|
|
* @param bool $return Whether or not to return the data instead of printing it directly.
|
|
* @return string
|
|
*/
|
|
public function print_table($return=false) {
|
|
$maxspan = $this->maxdepth;
|
|
|
|
/// Build table structure
|
|
$html = "
|
|
<table cellspacing='0'
|
|
cellpadding='0'
|
|
summary='" . s($this->get_lang_string('tablesummary', 'gradereport_user')) . "'
|
|
class='boxaligncenter generaltable user-grade'>
|
|
<thead>
|
|
<tr>
|
|
<th id='".$this->tablecolumns[0]."' class=\"header column-{$this->tablecolumns[0]}\" colspan='$maxspan'>".$this->tableheaders[0]."</th>\n";
|
|
|
|
for ($i = 1; $i < count($this->tableheaders); $i++) {
|
|
$html .= "<th id='".$this->tablecolumns[$i]."' class=\"header column-{$this->tablecolumns[$i]}\">".$this->tableheaders[$i]."</th>\n";
|
|
}
|
|
|
|
$html .= "
|
|
</tr>
|
|
</thead>
|
|
<tbody>\n";
|
|
|
|
/// Print out the table data
|
|
for ($i = 0; $i < count($this->tabledata); $i++) {
|
|
$html .= "<tr>\n";
|
|
if (isset($this->tabledata[$i]['leader'])) {
|
|
$rowspan = $this->tabledata[$i]['leader']['rowspan'];
|
|
$class = $this->tabledata[$i]['leader']['class'];
|
|
$html .= "<td class='$class' rowspan='$rowspan'></td>\n";
|
|
}
|
|
for ($j = 0; $j < count($this->tablecolumns); $j++) {
|
|
$name = $this->tablecolumns[$j];
|
|
$class = (isset($this->tabledata[$i][$name]['class'])) ? $this->tabledata[$i][$name]['class'] : '';
|
|
$colspan = (isset($this->tabledata[$i][$name]['colspan'])) ? "colspan='".$this->tabledata[$i][$name]['colspan']."'" : '';
|
|
$content = (isset($this->tabledata[$i][$name]['content'])) ? $this->tabledata[$i][$name]['content'] : null;
|
|
$celltype = (isset($this->tabledata[$i][$name]['celltype'])) ? $this->tabledata[$i][$name]['celltype'] : 'td';
|
|
$id = (isset($this->tabledata[$i][$name]['id'])) ? "id='{$this->tabledata[$i][$name]['id']}'" : '';
|
|
$headers = (isset($this->tabledata[$i][$name]['headers'])) ? "headers='{$this->tabledata[$i][$name]['headers']}'" : '';
|
|
if (isset($content)) {
|
|
$html .= "<$celltype $id $headers class='$class' $colspan>$content</$celltype>\n";
|
|
}
|
|
}
|
|
$html .= "</tr>\n";
|
|
}
|
|
|
|
$html .= "</tbody></table>";
|
|
|
|
if ($return) {
|
|
return $html;
|
|
} else {
|
|
echo $html;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Processes the data sent by the form (grades and feedbacks).
|
|
* @var array $data
|
|
* @return bool Success or Failure (array of errors).
|
|
*/
|
|
function process_data($data) {
|
|
}
|
|
function process_action($target, $action) {
|
|
}
|
|
|
|
/**
|
|
* Builds the grade item averages.
|
|
*/
|
|
function calculate_averages() {
|
|
global $USER, $DB;
|
|
|
|
if ($this->showaverage) {
|
|
// This settings are actually grader report settings (not user report)
|
|
// however we're using them as having two separate but identical settings the
|
|
// user would have to keep in sync would be annoying.
|
|
$averagesdisplaytype = $this->get_pref('averagesdisplaytype');
|
|
$averagesdecimalpoints = $this->get_pref('averagesdecimalpoints');
|
|
$meanselection = $this->get_pref('meanselection');
|
|
$shownumberofgrades = $this->get_pref('shownumberofgrades');
|
|
|
|
$avghtml = '';
|
|
$groupsql = $this->groupsql;
|
|
$groupwheresql = $this->groupwheresql;
|
|
$totalcount = $this->get_numusers(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');
|
|
|
|
// Limit to users with a gradeable role ie students.
|
|
list($gradebookrolessql, $gradebookrolesparams) = $DB->get_in_or_equal(explode(',', $this->gradebookroles), SQL_PARAMS_NAMED, 'grbr0');
|
|
|
|
// Limit to users with an active enrolment.
|
|
list($enrolledsql, $enrolledparams) = get_enrolled_sql($this->context);
|
|
|
|
$params = array_merge($this->groupwheresql_params, $gradebookrolesparams, $enrolledparams, $relatedctxparams);
|
|
$params['courseid'] = $this->courseid;
|
|
|
|
// find sums of all grade items in course
|
|
$sql = "SELECT gg.itemid, SUM(gg.finalgrade) AS sum
|
|
FROM {grade_items} gi
|
|
JOIN {grade_grades} gg ON gg.itemid = gi.id
|
|
JOIN {user} u ON u.id = gg.userid
|
|
JOIN ($enrolledsql) je ON je.id = gg.userid
|
|
JOIN (
|
|
SELECT DISTINCT ra.userid
|
|
FROM {role_assignments} ra
|
|
WHERE ra.roleid $gradebookrolessql
|
|
AND ra.contextid $relatedctxsql
|
|
) rainner ON rainner.userid = u.id
|
|
$groupsql
|
|
WHERE gi.courseid = :courseid
|
|
AND u.deleted = 0
|
|
AND gg.finalgrade IS NOT NULL
|
|
AND gg.hidden = 0
|
|
$groupwheresql
|
|
GROUP BY gg.itemid";
|
|
|
|
$sum_array = array();
|
|
$sums = $DB->get_recordset_sql($sql, $params);
|
|
foreach ($sums as $itemid => $csum) {
|
|
$sum_array[$itemid] = $csum->sum;
|
|
}
|
|
$sums->close();
|
|
|
|
$columncount=0;
|
|
|
|
// Empty grades must be evaluated as grademin, NOT always 0
|
|
// This query returns a count of ungraded grades (NULL finalgrade OR no matching record in grade_grades table)
|
|
// No join condition when joining grade_items and user to get a grade item row for every user
|
|
// Then left join with grade_grades and look for rows with null final grade (which includes grade items with no grade_grade)
|
|
$sql = "SELECT gi.id, COUNT(u.id) AS count
|
|
FROM {grade_items} gi
|
|
JOIN {user} u ON u.deleted = 0
|
|
JOIN ($enrolledsql) je ON je.id = u.id
|
|
JOIN (
|
|
SELECT DISTINCT ra.userid
|
|
FROM {role_assignments} ra
|
|
WHERE ra.roleid $gradebookrolessql
|
|
AND ra.contextid $relatedctxsql
|
|
) rainner ON rainner.userid = u.id
|
|
LEFT JOIN {grade_grades} gg
|
|
ON (gg.itemid = gi.id AND gg.userid = u.id AND gg.finalgrade IS NOT NULL AND gg.hidden = 0)
|
|
$groupsql
|
|
WHERE gi.courseid = :courseid
|
|
AND gg.finalgrade IS NULL
|
|
$groupwheresql
|
|
GROUP BY gi.id";
|
|
|
|
$ungraded_counts = $DB->get_records_sql($sql, $params);
|
|
|
|
foreach ($this->gtree->items as $itemid=>$unused) {
|
|
if (!empty($this->gtree->items[$itemid]->avg)) {
|
|
continue;
|
|
}
|
|
$item = $this->gtree->items[$itemid];
|
|
|
|
if ($item->needsupdate) {
|
|
$avghtml .= '<td class="cell c' . $columncount++.'"><span class="gradingerror">'.get_string('error').'</span></td>';
|
|
continue;
|
|
}
|
|
|
|
if (empty($sum_array[$item->id])) {
|
|
$sum_array[$item->id] = 0;
|
|
}
|
|
|
|
if (empty($ungraded_counts[$itemid])) {
|
|
$ungraded_count = 0;
|
|
} else {
|
|
$ungraded_count = $ungraded_counts[$itemid]->count;
|
|
}
|
|
|
|
//do they want the averages to include all grade items
|
|
if ($meanselection == GRADE_REPORT_MEAN_GRADED) {
|
|
$mean_count = $totalcount - $ungraded_count;
|
|
} else { // Bump up the sum by the number of ungraded items * grademin
|
|
$sum_array[$item->id] += ($ungraded_count * $item->grademin);
|
|
$mean_count = $totalcount;
|
|
}
|
|
|
|
// Determine which display type to use for this average
|
|
if (!empty($USER->gradeediting) && $USER->gradeediting[$this->courseid]) {
|
|
$displaytype = GRADE_DISPLAY_TYPE_REAL;
|
|
|
|
} else if ($averagesdisplaytype == GRADE_REPORT_PREFERENCE_INHERIT) { // no ==0 here, please resave the report and user preferences
|
|
$displaytype = $item->get_displaytype();
|
|
|
|
} else {
|
|
$displaytype = $averagesdisplaytype;
|
|
}
|
|
|
|
// Override grade_item setting if a display preference (not inherit) was set for the averages
|
|
if ($averagesdecimalpoints == GRADE_REPORT_PREFERENCE_INHERIT) {
|
|
$decimalpoints = $item->get_decimals();
|
|
} else {
|
|
$decimalpoints = $averagesdecimalpoints;
|
|
}
|
|
|
|
if (empty($sum_array[$item->id]) || $mean_count == 0) {
|
|
$this->gtree->items[$itemid]->avg = '-';
|
|
} else {
|
|
$sum = $sum_array[$item->id];
|
|
$avgradeval = $sum/$mean_count;
|
|
$gradehtml = grade_format_gradevalue($avgradeval, $item, true, $displaytype, $decimalpoints);
|
|
|
|
$numberofgrades = '';
|
|
if ($shownumberofgrades) {
|
|
$numberofgrades = " ($mean_count)";
|
|
}
|
|
|
|
$this->gtree->items[$itemid]->avg = $gradehtml.$numberofgrades;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function grade_report_user_settings_definition(&$mform) {
|
|
global $CFG;
|
|
|
|
$options = array(-1 => get_string('default', 'grades'),
|
|
0 => get_string('hide'),
|
|
1 => get_string('show'));
|
|
|
|
if (empty($CFG->grade_report_user_showrank)) {
|
|
$options[-1] = get_string('defaultprev', 'grades', $options[0]);
|
|
} else {
|
|
$options[-1] = get_string('defaultprev', 'grades', $options[1]);
|
|
}
|
|
|
|
$mform->addElement('select', 'report_user_showrank', get_string('showrank', 'grades'), $options);
|
|
$mform->addHelpButton('report_user_showrank', 'showrank', 'grades');
|
|
|
|
if (empty($CFG->grade_report_user_showpercentage)) {
|
|
$options[-1] = get_string('defaultprev', 'grades', $options[0]);
|
|
} else {
|
|
$options[-1] = get_string('defaultprev', 'grades', $options[1]);
|
|
}
|
|
|
|
$mform->addElement('select', 'report_user_showpercentage', get_string('showpercentage', 'grades'), $options);
|
|
$mform->addHelpButton('report_user_showpercentage', 'showpercentage', 'grades');
|
|
|
|
if (empty($CFG->grade_report_user_showgrade)) {
|
|
$options[-1] = get_string('defaultprev', 'grades', $options[0]);
|
|
} else {
|
|
$options[-1] = get_string('defaultprev', 'grades', $options[1]);
|
|
}
|
|
|
|
$mform->addElement('select', 'report_user_showgrade', get_string('showgrade', 'grades'), $options);
|
|
|
|
if (empty($CFG->grade_report_user_showfeedback)) {
|
|
$options[-1] = get_string('defaultprev', 'grades', $options[0]);
|
|
} else {
|
|
$options[-1] = get_string('defaultprev', 'grades', $options[1]);
|
|
}
|
|
|
|
$mform->addElement('select', 'report_user_showfeedback', get_string('showfeedback', 'grades'), $options);
|
|
|
|
if (empty($CFG->grade_report_user_showweight)) {
|
|
$options[-1] = get_string('defaultprev', 'grades', $options[0]);
|
|
} else {
|
|
$options[-1] = get_string('defaultprev', 'grades', $options[1]);
|
|
}
|
|
|
|
$mform->addElement('select', 'report_user_showweight', get_string('showweight', 'grades'), $options);
|
|
|
|
if (empty($CFG->grade_report_user_showaverage)) {
|
|
$options[-1] = get_string('defaultprev', 'grades', $options[0]);
|
|
} else {
|
|
$options[-1] = get_string('defaultprev', 'grades', $options[1]);
|
|
}
|
|
|
|
$mform->addElement('select', 'report_user_showaverage', get_string('showaverage', 'grades'), $options);
|
|
$mform->addHelpButton('report_user_showaverage', 'showaverage', 'grades');
|
|
|
|
if (empty($CFG->grade_report_user_showlettergrade)) {
|
|
$options[-1] = get_string('defaultprev', 'grades', $options[0]);
|
|
} else {
|
|
$options[-1] = get_string('defaultprev', 'grades', $options[1]);
|
|
}
|
|
|
|
$mform->addElement('select', 'report_user_showlettergrade', get_string('showlettergrade', 'grades'), $options);
|
|
if (empty($CFG->grade_report_user_showcontributiontocoursetotal)) {
|
|
$options[-1] = get_string('defaultprev', 'grades', $options[0]);
|
|
} else {
|
|
$options[-1] = get_string('defaultprev', 'grades', $options[$CFG->grade_report_user_showcontributiontocoursetotal]);
|
|
}
|
|
|
|
$mform->addElement('select', 'report_user_showcontributiontocoursetotal', get_string('showcontributiontocoursetotal', 'grades'), $options);
|
|
$mform->addHelpButton('report_user_showcontributiontocoursetotal', 'showcontributiontocoursetotal', 'grades');
|
|
|
|
if (empty($CFG->grade_report_user_showrange)) {
|
|
$options[-1] = get_string('defaultprev', 'grades', $options[0]);
|
|
} else {
|
|
$options[-1] = get_string('defaultprev', 'grades', $options[1]);
|
|
}
|
|
|
|
$mform->addElement('select', 'report_user_showrange', get_string('showrange', 'grades'), $options);
|
|
|
|
$options = array(0=>0, 1=>1, 2=>2, 3=>3, 4=>4, 5=>5);
|
|
if (! empty($CFG->grade_report_user_rangedecimals)) {
|
|
$options[-1] = $options[$CFG->grade_report_user_rangedecimals];
|
|
}
|
|
$mform->addElement('select', 'report_user_rangedecimals', get_string('rangedecimals', 'grades'), $options);
|
|
|
|
$options = array(-1 => get_string('default', 'grades'),
|
|
0 => get_string('shownohidden', 'grades'),
|
|
1 => get_string('showhiddenuntilonly', 'grades'),
|
|
2 => get_string('showallhidden', 'grades'));
|
|
|
|
if (empty($CFG->grade_report_user_showhiddenitems)) {
|
|
$options[-1] = get_string('defaultprev', 'grades', $options[0]);
|
|
} else {
|
|
$options[-1] = get_string('defaultprev', 'grades', $options[$CFG->grade_report_user_showhiddenitems]);
|
|
}
|
|
|
|
$mform->addElement('select', 'report_user_showhiddenitems', get_string('showhiddenitems', 'grades'), $options);
|
|
$mform->addHelpButton('report_user_showhiddenitems', 'showhiddenitems', 'grades');
|
|
|
|
//showtotalsifcontainhidden
|
|
$options = array(-1 => get_string('default', 'grades'),
|
|
GRADE_REPORT_HIDE_TOTAL_IF_CONTAINS_HIDDEN => get_string('hide'),
|
|
GRADE_REPORT_SHOW_TOTAL_IF_CONTAINS_HIDDEN => get_string('hidetotalshowexhiddenitems', 'grades'),
|
|
GRADE_REPORT_SHOW_REAL_TOTAL_IF_CONTAINS_HIDDEN => get_string('hidetotalshowinchiddenitems', 'grades') );
|
|
|
|
if (empty($CFG->grade_report_user_showtotalsifcontainhidden)) {
|
|
$options[-1] = get_string('defaultprev', 'grades', $options[0]);
|
|
} else {
|
|
$options[-1] = get_string('defaultprev', 'grades', $options[$CFG->grade_report_user_showtotalsifcontainhidden]);
|
|
}
|
|
|
|
$mform->addElement('select', 'report_user_showtotalsifcontainhidden', get_string('hidetotalifhiddenitems', 'grades'), $options);
|
|
$mform->addHelpButton('report_user_showtotalsifcontainhidden', 'hidetotalifhiddenitems', 'grades');
|
|
|
|
}
|
|
|
|
/**
|
|
* Profile report callback.
|
|
*
|
|
* @param object $course The course.
|
|
* @param object $user The user.
|
|
* @param boolean $viewasuser True when we are viewing this as the targetted user sees it.
|
|
*/
|
|
function grade_report_user_profilereport($course, $user, $viewasuser = false) {
|
|
global $OUTPUT;
|
|
if (!empty($course->showgrades)) {
|
|
|
|
$context = context_course::instance($course->id);
|
|
|
|
//first make sure we have proper final grades - this must be done before constructing of the grade tree
|
|
grade_regrade_final_grades($course->id);
|
|
|
|
/// return tracking object
|
|
$gpr = new grade_plugin_return(array('type'=>'report', 'plugin'=>'user', 'courseid'=>$course->id, 'userid'=>$user->id));
|
|
// Create a report instance
|
|
$report = new grade_report_user($course->id, $gpr, $context, $user->id, $viewasuser);
|
|
|
|
// print the page
|
|
echo '<div class="grade-report-user">'; // css fix to share styles with real report page
|
|
echo $OUTPUT->heading(get_string('pluginname', 'gradereport_user'). ' - '.fullname($report->user));
|
|
|
|
if ($report->fill_table()) {
|
|
echo $report->print_table(true);
|
|
}
|
|
echo '</div>';
|
|
}
|
|
}
|
|
|
|
|