/**

* The courseid.

* @var int $courseid

*/

public $courseid;

/**

* The course.

* @var object $course

*/

public $course;

/** Grade plugin return tracking object.

* @var object $gpr

*/

public $gpr;

/**

* The context.

*

* @var context $context

*/

public $context;

/**

* The grade_tree object.

* @var grade_tree $gtree

*/

public $gtree;

/**

* User preferences related to this report.

* @var array $prefs

*/

public $prefs = array();

/**

* The roles for this report.

* @var string $gradebookroles

*/

public $gradebookroles;

/**

* base url for sorting by first/last name.

* @var string $baseurl

*/

public $baseurl;

/**

* base url for paging.

* @var string $pbarurl

*/

public $pbarurl;

/**

* Current page (for paging).

* @var int $page

*/

public $page;

// GROUP VARIABLES (including SQL)

/**

* The current group being displayed.

* @var int $currentgroup

*/

public $currentgroup;

/**

* The current groupname being displayed.

* @var string $currentgroupname

*/

public $currentgroupname;

/**

* Current course group mode

* @var int $groupmode

*/

public $groupmode;

/**

* A HTML select element used to select the current group.

* @var string $group_selector

*/

public $group_selector;

/**

* An SQL fragment used to add linking information to the group tables.

* @var string $groupsql

*/

protected $groupsql;

/**

* An SQL constraint to append to the queries used by this object to build the report.

* @var string $groupwheresql

*/

protected $groupwheresql;

/**

* The ordered params for $groupwheresql

* @var array $groupwheresql_params

*/

protected $groupwheresql_params = array();

// USER VARIABLES (including SQL).

/**

* An SQL constraint to append to the queries used by this object to build the report.

* @var string $userwheresql

*/

protected $userwheresql;

/**

* The ordered params for $userwheresql

* @var array $userwheresql_params

*/

protected $userwheresql_params = array();

/**

* To store user data

* @var stdClass $user

*/

public $user;

/**

* show course/category totals if they contain hidden items

* @var array $showtotalsifcontainhidden

*/

public $showtotalsifcontainhidden = [];

/**

* To store a link to preferences page

* @var string $preferences_page

*/

protected $preferences_page;

/**

* If the user is wanting to search for a particular user within searchable fields their needle will be placed here.

* @var string $usersearch

*/

protected string $usersearch = '';

/**

* If the user is wanting to show only one particular user their id will be placed here.

* @var int $userid

*/

protected int $userid = -1;

/**

* 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)

*/

public function __construct($courseid, $gpr, $context, $page=null) {

global $CFG, $COURSE, $DB;

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

throw new \moodle_exception('norolesdefined', 'grades');

}

$this->courseid = $courseid;

if ($this->courseid == $COURSE->id) {

$this->course = $COURSE;

} else {

$this->course = $DB->get_record('course', array('id' => $this->courseid));

}

$this->gpr = $gpr;

$this->context = $context;

$this->page = $page;

// roles to be displayed in the gradebook

$this->gradebookroles = $CFG->gradebookroles;

// Set up link to preferences page

$this->preferences_page = $CFG->wwwroot.'/grade/report/grader/preferences.php?id='.$courseid;

// init gtree in child class

// Set any url params.

$this->usersearch = optional_param('gpr_search', '', PARAM_NOTAGS);

$this->userid = optional_param('gpr_userid', -1, PARAM_INT);

}

/**

* Given the name of a user preference (without grade_report_ prefix), locally saves then returns

* the value of that preference. If the preference has already been fetched before,

* the saved value is returned. If the preference is not set at the User level, the $CFG equivalent

* is given (site default).

* Can be called statically, but then doesn't benefit from caching

* @param string $pref The name of the preference (do not include the grade_report_ prefix)

* @param int $objectid An optional itemid or categoryid to check for a more fine-grained preference

* @return mixed The value of the preference

*/

public function get_pref($pref, $objectid=null) {

global $CFG;

$fullprefname = 'grade_report_' . $pref;

$shortprefname = 'grade_' . $pref;

$retval = null;

if (!isset($this) OR get_class($this) != 'grade_report') {

if (!empty($objectid)) {

$retval = get_user_preferences($fullprefname . $objectid, self::get_pref($pref));

} else if (isset($CFG->$fullprefname)) {

$retval = get_user_preferences($fullprefname, $CFG->$fullprefname);

} else if (isset($CFG->$shortprefname)) {

$retval = get_user_preferences($fullprefname, $CFG->$shortprefname);

} else {

$retval = null;

}

} else {

if (empty($this->prefs[$pref.$objectid])) {

if (!empty($objectid)) {

$retval = get_user_preferences($fullprefname . $objectid);

if (empty($retval)) {

// No item pref found, we are returning the global preference

$retval = $this->get_pref($pref);

$objectid = null;

}

} else {

$retval = get_user_preferences($fullprefname, $CFG->$fullprefname);

}

$this->prefs[$pref.$objectid] = $retval;

} else {

$retval = $this->prefs[$pref.$objectid];

}

}

return $retval;

}

/**

* Uses set_user_preferences() to update the value of a user preference. If 'default' is given as the value,

* the preference will be removed in favour of a higher-level preference.

* @param string $pref The name of the preference.

* @param mixed $pref_value The value of the preference.

* @param int $itemid An optional itemid to which the preference will be assigned

* @return bool Success or failure.

*/

public function set_pref($pref, $pref_value='default', $itemid=null) {

$fullprefname = 'grade_report_' . $pref;

if ($pref_value == 'default') {

return unset_user_preference($fullprefname.$itemid);

} else {

return set_user_preference($fullprefname.$itemid, $pref_value);

}

}

/**

* Handles form data sent by this report for this report. Abstract method to implement in all children.

* @abstract

* @param array $data

* @return mixed True or array of errors

*/

abstract public function process_data($data);

/**

* Processes a single action against a category, grade_item or grade.

* @param string $target Sortorder

* @param string $action Which action to take (edit, delete etc...)

* @return

*/

abstract public function process_action($target, $action);

/**

* Add additional links specific to plugin

* @param context_course $context Course context

* @param int $courseid Course ID

* @param array $element An array representing an element in the grade_tree

* @param grade_plugin_return $gpr A grade_plugin_return object

* @param string $mode Mode (user or grade item)

* @param stdClass $templatecontext Template context

* @param bool $otherplugins If we need to insert links to other plugins

* @return ?stdClass Updated template context

*/

public static function get_additional_context(context_course $context, int $courseid, array $element,

grade_plugin_return $gpr, string $mode, stdClass $templatecontext, bool $otherplugins = false): ?stdClass {

if (!$otherplugins) {

$component = 'gradereport_' . $gpr->plugin;

$params = [$context, $courseid, $element, $gpr, $mode, $templatecontext];

return component_callback($component, 'get_report_link', $params);

} else {

// Loop through all installed grade reports.

foreach (core_component::get_plugin_list('gradereport') as $plugin => $plugindir) {

$params = [$context, $courseid, $element, $gpr, $mode, $templatecontext];

$component = 'gradereport_' . $plugin;

$templatecontextupdated = component_callback($component, 'get_report_link', $params);

if ($templatecontextupdated) {

$templatecontext = $templatecontextupdated;

}

}

return $templatecontext;

}

}

/**

* First checks the cached language strings, then returns match if found, or uses get_string()

* to get it from the DB, caches it then returns it.

*

* @deprecated since 4.2

* @todo MDL-77307 This will be deleted in Moodle 4.6.

* @param string $strcode

* @param string $section Optional language section

* @return string

*/

public function get_lang_string($strcode, $section=null) {

debugging('grade_report::get_lang_string() is deprecated, please use' .

' get_string() instead.', DEBUG_DEVELOPER);

if (empty($this->lang_strings[$strcode])) {

$this->lang_strings[$strcode] = get_string($strcode, $section);

}

return $this->lang_strings[$strcode];

}

/**

* Fetches and returns a count of all the users that will be shown on this page.

* @param boolean $groups include groups limit

* @param boolean $users include users limit - default false, used for searching purposes

* @return int Count of users

*/

public function get_numusers($groups = true, $users = false) {

global $CFG, $DB;

$userwheresql = "";

$groupsql = "";

$groupwheresql = "";

// Limit to users with a gradeable role.

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

// Limit to users with an active enrollment.

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

// 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');

$params = array_merge($gradebookrolesparams, $enrolledparams, $relatedctxparams);

if ($users) {

$userwheresql = $this->userwheresql;

$params = array_merge($params, $this->userwheresql_params);

}

if ($groups) {

$groupsql = $this->groupsql;

$groupwheresql = $this->groupwheresql;

$params = array_merge($params, $this->groupwheresql_params);

}

$sql = "SELECT DISTINCT u.id

FROM {user} u

JOIN ($enrolledsql) je

ON je.id = u.id

JOIN {role_assignments} ra

ON u.id = ra.userid

$groupsql

WHERE ra.roleid $gradebookrolessql

AND u.deleted = 0

$userwheresql

$groupwheresql

AND ra.contextid $relatedctxsql";

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

$count = 0;

// Check if user's enrolment is active and should be displayed.

if (!empty($selectedusers)) {

$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);

if ($showonlyactiveenrol) {

$useractiveenrolments = get_enrolled_users($coursecontext, '', 0, 'u.id', null, 0, 0, true);

}

foreach ($selectedusers as $id => $value) {

if (!$showonlyactiveenrol || ($showonlyactiveenrol && array_key_exists($id, $useractiveenrolments))) {

$count++;

}

}

}

return $count;

}

/**

* Shows support for being used as a 'Grades' report.

*/

public static function supports_mygrades() {

return false;

}

/**

* Sets up this object's group variables, mainly to restrict the selection of users to display.

*/

protected function setup_groups() {

// find out current groups mode

if ($this->groupmode = groups_get_course_groupmode($this->course)) {

if (empty($this->gpr->groupid)) {

$this->currentgroup = groups_get_course_group($this->course, true);

} else {

$this->currentgroup = $this->gpr->groupid;

}

$this->group_selector = groups_print_course_menu($this->course, $this->pbarurl, true);

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

$this->currentgroup = -2; // means can not access any groups at all

}

if ($this->currentgroup) {

if ($group = groups_get_group($this->currentgroup)) {

$this->currentgroupname = $group->name;

}

$this->groupsql = " JOIN {groups_members} gm ON gm.userid = u.id ";

$this->groupwheresql = " AND gm.groupid = :gr_grpid ";

$this->groupwheresql_params = array('gr_grpid'=>$this->currentgroup);

}

}

}

/**

* Sets up this report's user criteria to restrict the selection of users to display.

*/

public function setup_users() {

global $SESSION, $DB;

$filterfirstnamekey = "filterfirstname-{$this->context->id}";

$filtersurnamekey = "filtersurname-{$this->context->id}";

$this->userwheresql = "";

$this->userwheresql_params = array();

if (!empty($SESSION->gradereport[$filterfirstnamekey])) {

$this->userwheresql .= ' AND '.$DB->sql_like('u.firstname', ':firstname', false, false);

$this->userwheresql_params['firstname'] = $SESSION->gradereport[$filterfirstnamekey] . '%';

}

if (!empty($SESSION->gradereport[$filtersurnamekey])) {

$this->userwheresql .= ' AND '.$DB->sql_like('u.lastname', ':lastname', false, false);

$this->userwheresql_params['lastname'] = $SESSION->gradereport[$filtersurnamekey] . '%';

}

// When a user wants to view a particular user rather than a set of users.

// By omission when selecting one user, also allow passing the search value around.

if ($this->userid !== -1) {

$this->userwheresql .= " AND u.id = :uid";

$this->userwheresql_params['uid'] = $this->userid;

}

// A user wants to return a subset of learners that match their search criteria.

if ($this->usersearch !== '' && $this->userid === -1) {

// Get the fields for all contexts because there is a special case later where it allows

// matches of fields you can't access if they are on your own account.

$userfields = fields::for_identity(null, false)->with_userpic();

['mappings' => $mappings] = (array)$userfields->get_sql('u', true);

[

'where' => $keywordswhere,

'params' => $keywordsparams,

] = $this->get_users_search_sql($mappings, (array)$userfields);

$this->userwheresql .= " AND $keywordswhere";

$this->userwheresql_params = array_merge($this->userwheresql_params, $keywordsparams);

}

}

/**

* Prepare SQL where clause and associated parameters for any user searching being performed.

* This mostly came from core_user\table\participants_search with some slight modifications four our use case.

*

* @param array $mappings Array of field mappings (fieldname => SQL code for the value)

* @param array $userfields An array that we cast from user profile fields to search within.

* @return array SQL query data in the format ['where' => '', 'params' => []].

*/

protected function get_users_search_sql(array $mappings, array $userfields): array {

global $DB, $USER;

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

$params = [];

$searchkey1 = 'search01';

$searchkey2 = 'search02';

$searchkey3 = 'search03';

$conditions = [];

// Search by fullname.

[$fullname, $fullnameparams] = fields::get_sql_fullname('u', $canviewfullnames);

$conditions[] = $DB->sql_like($fullname, ':' . $searchkey1, false, false);

$params = array_merge($params, $fullnameparams);

// Search by email.

$email = $DB->sql_like('email', ':' . $searchkey2, false, false);

if (!in_array('email', $userfields)) {

$maildisplay = 'maildisplay0';

$userid1 = 'userid01';

// Prevent users who hide their email address from being found by others

// who aren't allowed to see hidden email addresses.

$email = "(". $email ." AND (" .

"u.maildisplay <> :$maildisplay " .

"OR u.id = :$userid1". // Users can always find themselves.

"))";

$params[$maildisplay] = core_user::MAILDISPLAY_HIDE;

$params[$userid1] = $USER->id;

}

$conditions[] = $email;

// Search by idnumber.

$idnumber = $DB->sql_like('idnumber', ':' . $searchkey3, false, false);

if (!in_array('idnumber', $userfields)) {

$userid2 = 'userid02';

// Users who aren't allowed to see idnumbers should at most find themselves

// when searching for an idnumber.

$idnumber = "(". $idnumber . " AND u.id = :$userid2)";

$params[$userid2] = $USER->id;

}

$conditions[] = $idnumber;

// Search all user identify fields.

$extrasearchfields = fields::get_identity_fields(null, false);

foreach ($extrasearchfields as $fieldindex => $extrasearchfield) {

if (in_array($extrasearchfield, ['email', 'idnumber', 'country'])) {

// Already covered above.

continue;

}

// The param must be short (max 32 characters) so don't include field name.

$param = $searchkey3 . '_ident' . $fieldindex;

$fieldsql = $mappings[$extrasearchfield];

$condition = $DB->sql_like($fieldsql, ':' . $param, false, false);

$params[$param] = "%$this->usersearch%";

if (!in_array($extrasearchfield, $userfields)) {

// User cannot see this field, but allow match if their own account.

$userid3 = 'userid03_ident' . $fieldindex;

$condition = "(". $condition . " AND u.id = :$userid3)";

$params[$userid3] = $USER->id;

}

$conditions[] = $condition;

}

$where = "(". implode(" OR ", $conditions) .") ";

$params[$searchkey1] = "%$this->usersearch%";

$params[$searchkey2] = "%$this->usersearch%";

$params[$searchkey3] = "%$this->usersearch%";

return [

'where' => $where,

'params' => $params,

];

}

/**

* Returns an arrow icon inside an <a> tag, for the purpose of sorting a column.

* @param string $direction

* @param moodle_url|null $sortlink

*/

protected function get_sort_arrow(string $direction = 'down', ?moodle_url $sortlink = null) {

global $OUTPUT;

$pix = ['up' => 't/sort_desc', 'down' => 't/sort_asc'];

$matrix = ['up' => 'desc', 'down' => 'asc'];

$strsort = get_string($matrix[$direction], 'moodle');

$arrow = $OUTPUT->pix_icon($pix[$direction], '', '', ['class' => 'sorticon']);

if (!empty($sortlink)) {

$sortlink->param('sort', ($direction == 'up' ? 'asc' : 'desc'));

}

return html_writer::link($sortlink, $arrow, ['title' => $strsort, 'aria-label' => $strsort, 'data-collapse' => 'sort',

'class' => 'arrow_link py-1']);

}

/**

* Optionally blank out course/category totals if they contain any hidden items

* @param string $courseid the course id

* @param string $course_item an instance of grade_item

* @param string $finalgrade the grade for the course_item

* @return array[] containing values for 'grade', 'grademax', 'grademin', 'aggregationstatus' and 'aggregationweight'

*/

protected function blank_hidden_total_and_adjust_bounds($courseid, $course_item, $finalgrade) {

global $CFG, $DB;

static $hiding_affected = null;//array of items in this course affected by hiding

// If we're dealing with multiple users we need to know when we've moved on to a new user.

static $previous_userid = null;

// If we're dealing with multiple courses we need to know when we've moved on to a new course.

static $previous_courseid = null;

$coursegradegrade = grade_grade::fetch(array('userid'=>$this->user->id, 'itemid'=>$course_item->id));

$grademin = $course_item->grademin;

$grademax = $course_item->grademax;

if ($coursegradegrade) {

$grademin = $coursegradegrade->get_grade_min();

$grademax = $coursegradegrade->get_grade_max();

} else {

$coursegradegrade = new grade_grade(array('userid'=>$this->user->id, 'itemid'=>$course_item->id), false);

}

$hint = $coursegradegrade->get_aggregation_hint();

$aggregationstatus = $hint['status'];

$aggregationweight = $hint['weight'];

if (!is_array($this->showtotalsifcontainhidden)) {

debugging('showtotalsifcontainhidden should be an array', DEBUG_DEVELOPER);

$this->showtotalsifcontainhidden = array($courseid => $this->showtotalsifcontainhidden);

}

if ($this->showtotalsifcontainhidden[$courseid] == GRADE_REPORT_SHOW_REAL_TOTAL_IF_CONTAINS_HIDDEN) {

return array('grade' => $finalgrade,

'grademin' => $grademin,

'grademax' => $grademax,

'aggregationstatus' => $aggregationstatus,

'aggregationweight' => $aggregationweight);

}

// If we've moved on to another course or user, reload the grades.

if ($previous_userid != $this->user->id || $previous_courseid != $courseid) {

$hiding_affected = null;

$previous_userid = $this->user->id;

$previous_courseid = $courseid;

}

if (!$hiding_affected) {

$items = grade_item::fetch_all(array('courseid'=>$courseid));

$grades = array();

$sql = "SELECT g.*

FROM {grade_grades} g

JOIN {grade_items} gi ON gi.id = g.itemid

WHERE g.userid = {$this->user->id} AND gi.courseid = {$courseid}";

if ($gradesrecords = $DB->get_records_sql($sql)) {

foreach ($gradesrecords as $grade) {

$grades[$grade->itemid] = new grade_grade($grade, false);

}

unset($gradesrecords);

}

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

if (!isset($grades[$itemid])) {

$grade_grade = new grade_grade();

$grade_grade->userid = $this->user->id;

$grade_grade->itemid = $items[$itemid]->id;

$grades[$itemid] = $grade_grade;

}

$grades[$itemid]->grade_item =& $items[$itemid];

}

$hiding_affected = grade_grade::get_hiding_affected($grades, $items);

}

//if the item definitely depends on a hidden item

if (array_key_exists($course_item->id, $hiding_affected['altered']) ||

array_key_exists($course_item->id, $hiding_affected['alteredgrademin']) ||

array_key_exists($course_item->id, $hiding_affected['alteredgrademax']) ||

array_key_exists($course_item->id, $hiding_affected['alteredaggregationstatus']) ||

array_key_exists($course_item->id, $hiding_affected['alteredaggregationweight'])) {

if (!$this->showtotalsifcontainhidden[$courseid] && array_key_exists($course_item->id, $hiding_affected['altered'])) {

// Hide the grade, but only when it has changed.

$finalgrade = null;

} else {

//use reprocessed marks that exclude hidden items

if (array_key_exists($course_item->id, $hiding_affected['altered'])) {

$finalgrade = $hiding_affected['altered'][$course_item->id];

}

if (array_key_exists($course_item->id, $hiding_affected['alteredgrademin'])) {

$grademin = $hiding_affected['alteredgrademin'][$course_item->id];

}

if (array_key_exists($course_item->id, $hiding_affected['alteredgrademax'])) {

$grademax = $hiding_affected['alteredgrademax'][$course_item->id];

}

if (array_key_exists($course_item->id, $hiding_affected['alteredaggregationstatus'])) {

$aggregationstatus = $hiding_affected['alteredaggregationstatus'][$course_item->id];

}

if (array_key_exists($course_item->id, $hiding_affected['alteredaggregationweight'])) {

$aggregationweight = $hiding_affected['alteredaggregationweight'][$course_item->id];

}

if (!$this->showtotalsifcontainhidden[$courseid]) {

// If the course total is hidden we must hide the weight otherwise

// it can be used to compute the course total.

$aggregationstatus = 'unknown';

$aggregationweight = null;

}

}

} else if (array_key_exists($course_item->id, $hiding_affected['unknowngrades'])) {

//not sure whether or not this item depends on a hidden item

if (!$this->showtotalsifcontainhidden[$courseid]) {

//hide the grade

$finalgrade = null;

} else {

//use reprocessed marks that exclude hidden items

$finalgrade = $hiding_affected['unknowngrades'][$course_item->id];

if (array_key_exists($course_item->id, $hiding_affected['alteredgrademin'])) {

$grademin = $hiding_affected['alteredgrademin'][$course_item->id];

}

if (array_key_exists($course_item->id, $hiding_affected['alteredgrademax'])) {

$grademax = $hiding_affected['alteredgrademax'][$course_item->id];

}

if (array_key_exists($course_item->id, $hiding_affected['alteredaggregationstatus'])) {

$aggregationstatus = $hiding_affected['alteredaggregationstatus'][$course_item->id];

}

if (array_key_exists($course_item->id, $hiding_affected['alteredaggregationweight'])) {

$aggregationweight = $hiding_affected['alteredaggregationweight'][$course_item->id];

}

}

}

return array('grade' => $finalgrade, 'grademin' => $grademin, 'grademax' => $grademax, 'aggregationstatus'=>$aggregationstatus, 'aggregationweight'=>$aggregationweight);

}

/**

* Optionally blank out course/category totals if they contain any hidden items

* @deprecated since Moodle 2.8 - Call blank_hidden_total_and_adjust_bounds instead.

* @param string $courseid the course id

* @param string $course_item an instance of grade_item

* @param string $finalgrade the grade for the course_item

* @return string The new final grade

*/

protected function blank_hidden_total($courseid, $course_item, $finalgrade) {

// Note it is flawed to call this function directly because

// the aggregated grade does not make sense without the updated min and max information.

debugging('grade_report::blank_hidden_total() is deprecated.

Call grade_report::blank_hidden_total_and_adjust_bounds instead.', DEBUG_DEVELOPER);

$result = $this->blank_hidden_total_and_adjust_bounds($courseid, $course_item, $finalgrade);

return $result['grade'];

}

/**

* Calculate average grade for a given grade item.

*

* @param grade_item $gradeitem Grade item

* @param array $info Ungraded grade items counts and report preferences.

* @return array Average grade and meancount.

*/

public static function calculate_average(grade_item $gradeitem, array $info): array {

$meanselection = $info['report']['meanselection'];

$totalcount = $info['report']['totalcount'];

$ungradedcounts = $info['ungradedcounts'];

$sumarray = $info['sumarray'];

if (empty($sumarray[$gradeitem->id])) {

$sumarray[$gradeitem->id] = 0;

}

if (empty($ungradedcounts[$gradeitem->id])) {

$ungradedcounts = 0;

} else {

$ungradedcounts = $ungradedcounts[$gradeitem->id]->count;

}

// If they want the averages to include all grade items.

if ($meanselection == GRADE_REPORT_MEAN_GRADED) {

$meancount = $totalcount - $ungradedcounts;

} else {

// Bump up the sum by the number of ungraded items * grademin.

$sumarray[$gradeitem->id] += ($ungradedcounts * $gradeitem->grademin);

$meancount = $totalcount;

}

$aggr['meancount'] = $meancount;

if (empty($sumarray[$gradeitem->id]) || $meancount == 0) {

$aggr['average'] = null;

} else {

$sum = $sumarray[$gradeitem->id];

$aggr['average'] = $sum / $meancount;

}

return $aggr;

}

/**

* To check if we only need to include active enrolments.

*

* @return bool

*/

public function show_only_active(): bool {

global $CFG;

// Limit to users with an active enrolment.

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

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

return $showonlyactiveenrol ||

!has_capability('moodle/course:viewsuspendedusers', $this->context);

}

/**

* Get ungraded grade items info and sum of all grade items in a course.

*

* @param bool $grouponly If we want to compute group average only.

* @param bool $includehiddengrades Include hidden grades.

* @param bool $showonlyactiveenrol Whether to only include active enrolments.

* @return array Ungraded grade items counts with report preferences.

*/

public function ungraded_counts(bool $grouponly = false, bool $includehiddengrades = false, $showonlyactiveenrol = true): array {

global $DB;

$groupid = null;

if ($grouponly && isset($this->gpr->groupid)) {

$groupid = $this->gpr->groupid;

}

$info = [];

$info['report'] = [

'averagesdisplaytype' => $this->get_pref('averagesdisplaytype'),

'averagesdecimalpoints' => $this->get_pref('averagesdecimalpoints'),

'meanselection' => $this->get_pref('meanselection'),

'shownumberofgrades' => $this->get_pref('shownumberofgrades'),

'totalcount' => $this->get_numusers(!is_null($groupid)),

];

// 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');

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

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

$params['courseid'] = $this->courseid;

if (empty($groupid)) {

// Aggregate on whole course only.

$this->groupsql = null;

$this->groupwheresql = null;

}

$includesql = '';

if (!$includehiddengrades) {

$includesql = 'AND gg.hidden = 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 $includesql)

$this->groupsql

WHERE gi.courseid = :courseid

AND gg.finalgrade IS NULL

$this->groupwheresql

GROUP BY gi.id";

$info['ungradedcounts'] = $DB->get_records_sql($sql, $params);

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

$this->groupsql

WHERE gi.courseid = :courseid

AND u.deleted = 0

AND gg.finalgrade IS NOT NULL

$includesql

$this->groupwheresql

GROUP BY gg.itemid";

$sumarray = [];

$sums = $DB->get_recordset_sql($sql, $params);

foreach ($sums as $itemid => $csum) {

$sumarray[$itemid] = grade_floatval($csum->sum);

}

$sums->close();

$info['sumarray'] = $sumarray;

return $info;

}

/**

* Get grade item type names in a course to use in filter dropdown.

*

* @return array Item types.

*/

public function item_types(): array {

global $DB, $CFG;

$modnames = [];

$sql = "(SELECT gi.itemmodule

FROM {grade_items} gi

WHERE gi.courseid = :courseid1

AND gi.itemmodule IS NOT NULL)

UNION

(SELECT gi1.itemtype

FROM {grade_items} gi1

WHERE gi1.courseid = :courseid2

AND gi1.itemtype = 'manual')";

$itemtypes = $DB->get_records_sql($sql, ['courseid1' => $this->courseid, 'courseid2' => $this->courseid]);

foreach ($itemtypes as $itemtype => $value) {

if (file_exists("$CFG->dirroot/mod/$itemtype/lib.php")) {

$modnames[$itemtype] = get_string("modulename", $itemtype, null, true);

} else if ($itemtype == 'manual') {

$modnames[$itemtype] = get_string('manualitem', 'grades', null, true);

}

}

return $modnames;

}

/**

* Load a valid list of gradable users in a course.

*

* @param int $courseid The course ID.

* @param int|null $groupid The group ID (optional).

* @return array A list of enrolled gradable users.

*/

public static function get_gradable_users(int $courseid, ?int $groupid = null): array {

global $CFG;

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

$context = context_course::instance($courseid);

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

$onlyactiveenrol = get_user_preferences('grade_report_showonlyactiveenrol', $defaultgradeshowactiveenrol) ||

!has_capability('moodle/course:viewsuspendedusers', $context);

return get_gradable_users($courseid, $groupid, $onlyactiveenrol);

}

/**

* Returns a row of grade items averages

*

* @param array $ungradedcounts Ungraded grade items counts with report preferences.

* @return html_table_row Row with averages

*/

protected function format_averages(array $ungradedcounts): html_table_row {

$avgrow = new html_table_row();

$avgrow->attributes['class'] = 'avg';

$averagesdisplaytype = $ungradedcounts['report']['averagesdisplaytype'];

$averagesdecimalpoints = $ungradedcounts['report']['averagesdecimalpoints'];

$shownumberofgrades = $ungradedcounts['report']['shownumberofgrades'];

foreach ($this->gtree->items as $gradeitem) {

if ($gradeitem->needsupdate) {

$avgrow->cells[$gradeitem->id] = $this->format_average_cell($gradeitem);

} else {

$aggr = $this->calculate_average($gradeitem, $ungradedcounts);

if (empty($aggr['average'])) {

$avgrow->cells[$gradeitem->id] =

$this->format_average_cell($gradeitem, $aggr, $ungradedcounts['report']['shownumberofgrades']);