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 a class to represent a grade category

 *

 * @package   core_grades

 * @copyright 2006 Nicolas Connault

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

 */

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

require_once(__DIR__ . '/grade_object.php');

/**

 * grade_category is an object mapped to DB table {prefix}grade_categories

 *

 * @package   core_grades

 * @category  grade

 * @copyright 2007 Nicolas Connault

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

 */

class grade_category extends grade_object {

    /**

     * The DB table.

     * @var string $table

     */

    public $table = 'grade_categories';

    /**

     * Array of required table fields, must start with 'id'.

     * @var array $required_fields

     */

    public $required_fields = array('id', 'courseid', 'parent', 'depth', 'path', 'fullname', 'aggregation',

                                 'keephigh', 'droplow', 'aggregateonlygraded', 'aggregateoutcomes',

                                 'timecreated', 'timemodified', 'hidden');

    /**

     * The course this category belongs to.

     * @var int $courseid

     */

    public $courseid;

    /**

     * The category this category belongs to (optional).

     * @var int $parent

     */

    public $parent;

    /**

     * The grade_category object referenced by $this->parent (PK).

     * @var grade_category $parent_category

     */

    public $parent_category;

    /**

     * The number of parents this category has.

     * @var int $depth

     */

    public $depth = 0;

    /**

     * Shows the hierarchical path for this category as /1/2/3/ (like course_categories), the last number being

     * this category's autoincrement ID number.

     * @var string $path

     */

    public $path;

    /**

     * The name of this category.

     * @var string $fullname

     */

    public $fullname;

    /**

     * A constant pointing to one of the predefined aggregation strategies (none, mean, median, sum etc) .

     * @var int $aggregation

     */

    public $aggregation = GRADE_AGGREGATE_SUM;

    /**

     * Keep only the X highest items.

     * @var int $keephigh

     */

    public $keephigh = 0;

    /**

     * Drop the X lowest items.

     * @var int $droplow

     */

    public $droplow = 0;

    /**

     * Aggregate only graded items

     * @var int $aggregateonlygraded

     */

    public $aggregateonlygraded = 0;

    /**

     * Aggregate outcomes together with normal items

     * @var int $aggregateoutcomes

     */

    public $aggregateoutcomes = 0;

    /**

     * Array of grade_items or grade_categories nested exactly 1 level below this category

     * @var array $children

     */

    public $children;

    /**

     * A hierarchical array of all children below this category. This is stored separately from

     * $children because it is more memory-intensive and may not be used as often.

     * @var array $all_children

     */

    public $all_children;

    /**

     * An associated grade_item object, with itemtype=category, used to calculate and cache a set of grade values

     * for this category.

     * @var grade_item $grade_item

     */

    public $grade_item;

    /**

     * Temporary sortorder for speedup of children resorting

     * @var int $sortorder

     */

    public $sortorder;

    /**

     * List of options which can be "forced" from site settings.

     * @var array $forceable

     */

    public $forceable = array('aggregation', 'keephigh', 'droplow', 'aggregateonlygraded', 'aggregateoutcomes');

    /**

     * String representing the aggregation coefficient. Variable is used as cache.

     * @var string $coefstring

     */

    public $coefstring = null;

    /**

     * Static variable storing the result from {@link self::can_apply_limit_rules}.

     * @var bool

     */

    protected $canapplylimitrules;

    /**

     * e.g. 'category', 'course' and 'mod', 'blocks', 'import', etc...

     * @var string $itemtype

     */

    public $itemtype;

    /**

     * Builds this category's path string based on its parents (if any) and its own id number.

     * This is typically done just before inserting this object in the DB for the first time,

     * or when a new parent is added or changed. It is a recursive function: once the calling

     * object no longer has a parent, the path is complete.

     *

     * @param grade_category $grade_category A Grade_Category object

     * @return string The category's path string

     */

    public static function build_path($grade_category) {

        global $DB;

        if (empty($grade_category->parent)) {

            return '/'.$grade_category->id.'/';

        } else {

            $parent = $DB->get_record('grade_categories', array('id' => $grade_category->parent));

            return grade_category::build_path($parent).$grade_category->id.'/';

        }

    }

    /**

     * Finds and returns a grade_category instance based on params.

     *

     * @param array $params associative arrays varname=>value

     * @return grade_category The retrieved grade_category instance or false if none found.

     */

    public static function fetch($params) {

        if ($records = self::retrieve_record_set($params)) {

            return reset($records);

        }

        $record = grade_object::fetch_helper('grade_categories', 'grade_category', $params);

        // We store it as an array to keep a key => result set interface in the cache, grade_object::fetch_helper is

        // managing exceptions. We return only the first element though.

        $records = false;

        if ($record) {

            $records = array($record->id => $record);

        }

        self::set_record_set($params, $records);

        return $record;

    }

    /**

     * Finds and returns all grade_category instances based on params.

     *

     * @param array $params associative arrays varname=>value

     * @return array array of grade_category insatnces or false if none found.

     */

    public static function fetch_all($params) {

        if ($records = self::retrieve_record_set($params)) {

            return $records;

        }

        $records = grade_object::fetch_all_helper('grade_categories', 'grade_category', $params);

        self::set_record_set($params, $records);

        return $records;

    }

    /**

     * In addition to update() as defined in grade_object, call force_regrading of parent categories, if applicable.

     *

     * @param string $source from where was the object updated (mod/forum, manual, etc.)

     * @param bool $isbulkupdate If bulk grade update is happening.

     * @return bool success

     */

    public function update($source = null, $isbulkupdate = false) {

        // load the grade item or create a new one

        $this->load_grade_item();

        // force recalculation of path;

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

            $this->path  = grade_category::build_path($this);

            $this->depth = substr_count($this->path, '/') - 1;

            $updatechildren = true;

        } else {

            $updatechildren = false;

        }

        $this->apply_forced_settings();

        // these are exclusive

        if ($this->droplow > 0) {

            $this->keephigh = 0;

        } else if ($this->keephigh > 0) {

            $this->droplow = 0;

        }

        // Recalculate grades if needed

        if ($this->qualifies_for_regrading()) {

            $this->force_regrading();

        }

        $this->timemodified = time();

        $result = parent::update($source);

        // now update paths in all child categories

        if ($result and $updatechildren) {

            if ($children = grade_category::fetch_all(array('parent'=>$this->id))) {

                foreach ($children as $child) {

                    $child->path  = null;

                    $child->depth = 0;

                    $child->update($source);

                }

            }

        }

        return $result;

    }

    /**

     * If parent::delete() is successful, send force_regrading message to parent category.

     *

     * @param string $source from where was the object deleted (mod/forum, manual, etc.)

     * @return bool success

     */

    public function delete($source=null) {

        global $DB;

        try {

            $transaction = $DB->start_delegated_transaction();

            $grade_item = $this->load_grade_item();

            if ($this->is_course_category()) {

                if ($categories = self::fetch_all(['courseid' => $this->courseid])) {

                    foreach ($categories as $category) {

                        if ($category->id == $this->id) {

                            continue; // Do not delete course category yet.

                        }

                        $category->delete($source);

                    }

                }

                if ($items = grade_item::fetch_all(['courseid' => $this->courseid])) {

                    foreach ($items as $item) {

                        if ($item->id == $grade_item->id) {

                            continue; // Do not delete course item yet.

                        }

                        $item->delete($source);

                    }

                }

            } else {

                $this->force_regrading();

                $parent = $this->load_parent_category();

                // Update children's categoryid/parent field first.

                if ($children = grade_item::fetch_all(['categoryid' => $this->id])) {

                    foreach ($children as $child) {

                        $child->set_parent($parent->id);

                    }

                }

                if ($children = self::fetch_all(['parent' => $this->id])) {

                    foreach ($children as $child) {

                        $child->set_parent($parent->id);

                    }

                }

            }

            // First delete the attached grade item and grades.

            $grade_item->delete($source);

            // Delete category itself.

            $success = parent::delete($source);

            $transaction->allow_commit();

        } catch (Exception $e) {

            $transaction->rollback($e);

        }

        return $success;

    }

    /**

     * In addition to the normal insert() defined in grade_object, this method sets the depth

     * and path for this object, and update the record accordingly.

     *

     * We do this here instead of in the constructor as they both need to know the record's

     * ID number, which only gets created at insertion time.

     * This method also creates an associated grade_item if this wasn't done during construction.

     *

     * @param string $source from where was the object inserted (mod/forum, manual, etc.)

     * @param bool $isbulkupdate If bulk grade update is happening.

     * @return int PK ID if successful, false otherwise

     */

    public function insert($source = null, $isbulkupdate = false) {

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

            throw new \moodle_exception('cannotinsertgrade');

        }

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

            $course_category = grade_category::fetch_course_category($this->courseid);

            $this->parent = $course_category->id;

        }

        $this->path = null;

        $this->timecreated = $this->timemodified = time();

        if (!parent::insert($source)) {

            debugging("Could not insert this category: " . print_r($this, true));

            return false;

        }

        $this->force_regrading();

        // build path and depth

        $this->update($source);

        return $this->id;

    }

    /**

     * Internal function - used only from fetch_course_category()

     * Normal insert() can not be used for course category

     *

     * @param int $courseid The course ID

     * @return int The ID of the new course category

     */

    public function insert_course_category($courseid) {

        $this->courseid    = $courseid;

        $this->fullname    = '?';

        $this->path        = null;

        $this->parent      = null;

        $this->aggregation = GRADE_AGGREGATE_WEIGHTED_MEAN2;

        $this->apply_default_settings();

        $this->apply_forced_settings();

        $this->timecreated = $this->timemodified = time();

        if (!parent::insert('system')) {

            debugging("Could not insert this category: " . print_r($this, true));

            return false;

        }

        // build path and depth

        $this->update('system');

        return $this->id;

    }

    /**

     * Compares the values held by this object with those of the matching record in DB, and returns

     * whether or not these differences are sufficient to justify an update of all parent objects.

     * This assumes that this object has an ID number and a matching record in DB. If not, it will return false.

     *

     * @return bool

     */

    public function qualifies_for_regrading() {

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

            debugging("Can not regrade non existing category");

            return false;

        }

        $db_item = grade_category::fetch(array('id'=>$this->id));

        $aggregationdiff = $db_item->aggregation         != $this->aggregation;

        $keephighdiff    = $db_item->keephigh            != $this->keephigh;

        $droplowdiff     = $db_item->droplow             != $this->droplow;

        $aggonlygrddiff  = $db_item->aggregateonlygraded != $this->aggregateonlygraded;

        $aggoutcomesdiff = $db_item->aggregateoutcomes   != $this->aggregateoutcomes;

        return ($aggregationdiff || $keephighdiff || $droplowdiff || $aggonlygrddiff || $aggoutcomesdiff);

    }

    /**

     * Marks this grade categories' associated grade item as needing regrading

     */

    public function force_regrading() {

        $grade_item = $this->load_grade_item();

        $grade_item->force_regrading();

    }

    /**

     * Something that should be called before we start regrading the whole course.

     *

     * @return void

     */

    public function pre_regrade_final_grades() {

        $this->auto_update_weights();

        $this->auto_update_max();

    }

    /**

     * Generates and saves final grades in associated category grade item.

     * These immediate children must already have their own final grades.

     * The category's aggregation method is used to generate final grades.

     *

     * Please note that category grade is either calculated or aggregated, not both at the same time.

     *

     * This method must be used ONLY from grade_item::regrade_final_grades(),

     * because the calculation must be done in correct order!

     *

     * Steps to follow:

     *  1. Get final grades from immediate children

     *  3. Aggregate these grades

     *  4. Save them in final grades of associated category grade item

     *

     * @param int $userid The user ID if final grade generation should be limited to a single user

     * @param \core\progress\base|null $progress Optional progress indicator

     * @return bool

     */

    public function generate_grades($userid=null, ?\core\progress\base $progress = null) {

        global $CFG, $DB;

        $this->load_grade_item();

        if ($this->grade_item->is_locked()) {

            return true; // no need to recalculate locked items

        }

        // find grade items of immediate children (category or grade items) and force site settings

        $depends_on = $this->grade_item->depends_on();

        if (empty($depends_on)) {

            $items = false;

        } else {

            list($usql, $params) = $DB->get_in_or_equal($depends_on);

            $sql = "SELECT *

                      FROM {grade_items}

                     WHERE id $usql";

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

            foreach ($items as $id => $item) {

                $items[$id] = new grade_item($item, false);

            }

        }

        $grade_inst = new grade_grade();

        $fields = 'g.'.implode(',g.', $grade_inst->required_fields);

        // where to look for final grades - include grade of this item too, we will store the results there

        $gis = array_merge($depends_on, array($this->grade_item->id));

        list($usql, $params) = $DB->get_in_or_equal($gis);

        if ($userid) {

            $usersql = "AND g.userid=?";

            $params[] = $userid;

        } else {

            $usersql = "";

        }

        $sql = "SELECT $fields

                  FROM {grade_grades} g, {grade_items} gi

                 WHERE gi.id = g.itemid AND gi.id $usql $usersql

              ORDER BY g.userid";

        // group the results by userid and aggregate the grades for this user

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

        if ($rs->valid()) {

            $prevuser = 0;

            $grade_values = array();

            $excluded     = array();

            $oldgrade     = null;

            $grademaxoverrides = array();

            $grademinoverrides = array();

            foreach ($rs as $used) {

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

                if (isset($items[$grade->itemid])) {

                    // Prevent grade item to be fetched from DB.

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

                } else if ($grade->itemid == $this->grade_item->id) {

                    // This grade's grade item is not in $items.

                    $grade->grade_item =& $this->grade_item;

                }

                if ($grade->userid != $prevuser) {

                    $this->aggregate_grades($prevuser,

                                            $items,

                                            $grade_values,

                                            $oldgrade,

                                            $excluded,

                                            $grademinoverrides,

                                            $grademaxoverrides);

                    $prevuser = $grade->userid;

                    $grade_values = array();

                    $excluded     = array();

                    $oldgrade     = null;

                    $grademaxoverrides = array();

                    $grademinoverrides = array();

                }

                $grade_values[$grade->itemid] = $grade->finalgrade;

                $grademaxoverrides[$grade->itemid] = $grade->get_grade_max();

                $grademinoverrides[$grade->itemid] = $grade->get_grade_min();

                if ($grade->excluded) {

                    $excluded[] = $grade->itemid;

                }

                if ($this->grade_item->id == $grade->itemid) {

                    $oldgrade = $grade;

                }

                if ($progress) {

                    // Incrementing the progress by nothing causes it to send an update (once per second)

                    // to the web browser so as to prevent the connection timing out.

                    $progress->increment_progress(0);

                }

            }

            $this->aggregate_grades($prevuser,

                                    $items,

                                    $grade_values,

                                    $oldgrade,

                                    $excluded,

                                    $grademinoverrides,

                                    $grademaxoverrides);//the last one

        }

        $rs->close();

        return true;

    }

    /**

     * Internal function for grade category grade aggregation

     *

     * @param int    $userid The User ID

     * @param array  $items Grade items

     * @param array  $grade_values Array of grade values

     * @param object $oldgrade Old grade

     * @param array  $excluded Excluded

     * @param array  $grademinoverrides User specific grademin values if different to the grade_item grademin (key is itemid)

     * @param array  $grademaxoverrides User specific grademax values if different to the grade_item grademax (key is itemid)

     */

    private function aggregate_grades($userid,

                                      $items,

                                      $grade_values,

                                      $oldgrade,

                                      $excluded,

                                      $grademinoverrides,

                                      $grademaxoverrides) {

        global $CFG, $DB;

        // Remember these so we can set flags on them to describe how they were used in the aggregation.

        $novalue = array();

        $dropped = array();

        $extracredit = array();

        $usedweights = array();

        if (empty($userid)) {

            //ignore first call

            return;

        }

        if ($oldgrade) {

            $oldfinalgrade = $oldgrade->finalgrade;

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

            $grade->grade_item =& $this->grade_item;

        } else {

            // insert final grade - it will be needed later anyway

            $grade = new grade_grade(array('itemid'=>$this->grade_item->id, 'userid'=>$userid), false);

            $grade->grade_item =& $this->grade_item;

            $grade->insert('system');

            $oldfinalgrade = null;

        }

        // no need to recalculate locked or overridden grades

        if ($grade->is_locked() or $grade->is_overridden()) {

            return;

        }

        // can not use own final category grade in calculation

        unset($grade_values[$this->grade_item->id]);

        // Make sure a grade_grade exists for every grade_item.

        // We need to do this so we can set the aggregationstatus

        // with a set_field call instead of checking if each one exists and creating/updating.

        if (!empty($items)) {

            list($ggsql, $params) = $DB->get_in_or_equal(array_keys($items), SQL_PARAMS_NAMED, 'g');

            $params['userid'] = $userid;

            $sql = "SELECT itemid

                      FROM {grade_grades}

                     WHERE itemid $ggsql AND userid = :userid";

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

            $notexisting = array_diff(array_keys($items), array_keys($existingitems));

            foreach ($notexisting as $itemid) {

                $gradeitem = $items[$itemid];

                $gradegrade = new grade_grade(array('itemid' => $itemid,

                                                    'userid' => $userid,

                                                    'rawgrademin' => $gradeitem->grademin,

                                                    'rawgrademax' => $gradeitem->grademax), false);

                $gradegrade->grade_item = $gradeitem;

                $gradegrade->insert('system');

            }

        }

        // if no grades calculation possible or grading not allowed clear final grade

        if (empty($grade_values) or empty($items) or ($this->grade_item->gradetype != GRADE_TYPE_VALUE and $this->grade_item->gradetype != GRADE_TYPE_SCALE)) {

            $grade->finalgrade = null;

            if (!is_null($oldfinalgrade)) {

                $grade->timemodified = time();

                $success = $grade->update('aggregation');

                // If successful trigger a user_graded event.

                if ($success) {

                    \core\event\user_graded::create_from_grade($grade, \core\event\base::USER_OTHER)->trigger();

                }

            }

            $dropped = $grade_values;

            $this->set_usedinaggregation($userid, $usedweights, $novalue, $dropped, $extracredit);

            return;

        }

        // Normalize the grades first - all will have value 0...1

        // ungraded items are not used in aggregation.

        foreach ($grade_values as $itemid=>$v) {

            if (is_null($v)) {

                // If null, it means no grade.

                if ($this->aggregateonlygraded) {

                    unset($grade_values[$itemid]);

                    // Mark this item as "excluded empty" because it has no grade.

                    $novalue[$itemid] = 0;

                    continue;

                }

            }

            if (in_array($itemid, $excluded)) {

                unset($grade_values[$itemid]);

                $dropped[$itemid] = 0;

                continue;

            }

            // Check for user specific grade min/max overrides.

            $usergrademin = $items[$itemid]->grademin;

            $usergrademax = $items[$itemid]->grademax;

            if (isset($grademinoverrides[$itemid])) {

                $usergrademin = $grademinoverrides[$itemid];

            }

            if (isset($grademaxoverrides[$itemid])) {

                $usergrademax = $grademaxoverrides[$itemid];

            }

            if ($this->aggregation == GRADE_AGGREGATE_SUM) {

                // Assume that the grademin is 0 when standardising the score, to preserve negative grades.

                $grade_values[$itemid] = grade_grade::standardise_score($v, 0, $usergrademax, 0, 1);

            } else {

                $grade_values[$itemid] = grade_grade::standardise_score($v, $usergrademin, $usergrademax, 0, 1);

            }

        }

        // First, check if all grades are null, because the final grade will be null

        // even when aggreateonlygraded is true.

        $allnull = true;

        foreach ($grade_values as $v) {

            if (!is_null($v)) {

                $allnull = false;

                break;

            }

        }

        // For items with no value, and not excluded - either set their grade to 0 or exclude them.

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

            if (!isset($grade_values[$itemid]) and !in_array($itemid, $excluded)) {

                if (!$this->aggregateonlygraded) {

                    $grade_values[$itemid] = 0;

                } else {

                    // We are specifically marking these items as "excluded empty".

                    $novalue[$itemid] = 0;

                }

            }

        }

        // limit and sort

        $allvalues = $grade_values;

        if ($this->can_apply_limit_rules()) {

            $this->apply_limit_rules($grade_values, $items);

        }

        $moredropped = array_diff($allvalues, $grade_values);

        foreach ($moredropped as $drop => $unused) {

            $dropped[$drop] = 0;

        }

        foreach ($grade_values as $itemid => $val) {

            if (self::is_extracredit_used() && ($items[$itemid]->aggregationcoef > 0)) {

                $extracredit[$itemid] = 0;

            }

        }

        asort($grade_values, SORT_NUMERIC);

        // let's see we have still enough grades to do any statistics

        if (count($grade_values) == 0) {

            // not enough attempts yet

            $grade->finalgrade = null;

            if (!is_null($oldfinalgrade)) {

                $grade->timemodified = time();

                $success = $grade->update('aggregation');

                // If successful trigger a user_graded event.

                if ($success) {

                    \core\event\user_graded::create_from_grade($grade, \core\event\base::USER_OTHER)->trigger();

                }

            }

            $this->set_usedinaggregation($userid, $usedweights, $novalue, $dropped, $extracredit);

            return;

        }

        // do the maths

        $result = $this->aggregate_values_and_adjust_bounds($grade_values,

                                                            $items,

                                                            $usedweights,

                                                            $grademinoverrides,

                                                            $grademaxoverrides);

        $agg_grade = $result['grade'];

        // Set the actual grademin and max to bind the grade properly.

        $this->grade_item->grademin = $result['grademin'];

        $this->grade_item->grademax = $result['grademax'];

        if ($this->aggregation == GRADE_AGGREGATE_SUM) {

            // The natural aggregation always displays the range as coming from 0 for categories.

            // However, when we bind the grade we allow for negative values.

            $result['grademin'] = 0;

        }

        if ($allnull) {

            $grade->finalgrade = null;

        } else {

            // Recalculate the grade back to requested range.

            $finalgrade = grade_grade::standardise_score($agg_grade, 0, 1, $result['grademin'], $result['grademax']);

            $grade->finalgrade = $this->grade_item->bounded_grade($finalgrade);

        }

        $oldrawgrademin = $grade->rawgrademin;

        $oldrawgrademax = $grade->rawgrademax;

        $grade->rawgrademin = $result['grademin'];

        $grade->rawgrademax = $result['grademax'];

        // Update in db if changed.

        if (grade_floats_different($grade->finalgrade, $oldfinalgrade) ||

                grade_floats_different($grade->rawgrademax, $oldrawgrademax) ||

                grade_floats_different($grade->rawgrademin, $oldrawgrademin)) {

            $grade->timemodified = time();

            $success = $grade->update('aggregation');

            // If successful trigger a user_graded event.

            if ($success) {

                \core\event\user_graded::create_from_grade($grade, \core\event\base::USER_OTHER)->trigger();

            }

        }

        $this->set_usedinaggregation($userid, $usedweights, $novalue, $dropped, $extracredit);

        return;

    }

    /**

     * Set the flags on the grade_grade items to indicate how individual grades are used

     * in the aggregation.

     *

     * WARNING: This function is called a lot during gradebook recalculation, be very performance considerate.

     *

     * @param int $userid The user we have aggregated the grades for.

     * @param array $usedweights An array with keys for each of the grade_item columns included in the aggregation. The value are the relative weight.

     * @param array $novalue An array with keys for each of the grade_item columns skipped because

     *                       they had no value in the aggregation.

     * @param array $dropped An array with keys for each of the grade_item columns dropped

     *                       because of any drop lowest/highest settings in the aggregation.

     * @param array $extracredit An array with keys for each of the grade_item columns

     *                       considered extra credit by the aggregation.

     */

    private function set_usedinaggregation($userid, $usedweights, $novalue, $dropped, $extracredit) {

        global $DB;

        // We want to know all current user grades so we can decide whether they need to be updated or they already contain the

        // expected value.

        $sql = "SELECT gi.id, gg.aggregationstatus, gg.aggregationweight FROM {grade_grades} gg

                  JOIN {grade_items} gi ON (gg.itemid = gi.id)

                 WHERE gg.userid = :userid";

        $params = array('categoryid' => $this->id, 'userid' => $userid);

        // These are all grade_item ids which grade_grades will NOT end up being 'unknown' (because they are not unknown or

        // because we will update them to something different that 'unknown').

        $giids = array_keys($usedweights + $novalue + $dropped + $extracredit);

        if ($giids) {

            // We include grade items that might not be in categoryid.

            list($itemsql, $itemlist) = $DB->get_in_or_equal($giids, SQL_PARAMS_NAMED, 'gg');

            $sql .= ' AND (gi.categoryid = :categoryid OR gi.id ' . $itemsql . ')';

            $params = $params + $itemlist;

        } else {

            $sql .= ' AND gi.categoryid = :categoryid';

        }

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

        // We will store here the grade_item ids that need to be updated on db.

        $toupdate = array();

        if ($currentgrades->valid()) {

            // Iterate through the user grades to see if we really need to update any of them.

            foreach ($currentgrades as $currentgrade) {

                // Unset $usedweights that we do not need to update.

                if (!empty($usedweights) && isset($usedweights[$currentgrade->id]) && $currentgrade->aggregationstatus === 'used') {

                    // We discard the ones that already have the contribution specified in $usedweights and are marked as 'used'.

                    if (grade_floats_equal($currentgrade->aggregationweight, $usedweights[$currentgrade->id])) {

                        unset($usedweights[$currentgrade->id]);

                    }

                    // Used weights can be present in multiple set_usedinaggregation arguments.

                    if (!isset($novalue[$currentgrade->id]) && !isset($dropped[$currentgrade->id]) &&

                            !isset($extracredit[$currentgrade->id])) {

                        continue;

                    }

                }

                // No value grades.

                if (!empty($novalue) && isset($novalue[$currentgrade->id])) {

                    if ($currentgrade->aggregationstatus !== 'novalue' ||

                            grade_floats_different($currentgrade->aggregationweight, 0)) {

                        $toupdate['novalue'][] = $currentgrade->id;

                    }

                    continue;

                }

                // Dropped grades.

                if (!empty($dropped) && isset($dropped[$currentgrade->id])) {

                    if ($currentgrade->aggregationstatus !== 'dropped' ||

                            grade_floats_different($currentgrade->aggregationweight, 0)) {

                        $toupdate['dropped'][] = $currentgrade->id;

                    }

                    continue;

                }

                // Extra credit grades.

                if (!empty($extracredit) && isset($extracredit[$currentgrade->id])) {

                    // If this grade item is already marked as 'extra' and it already has the provided $usedweights value would be

                    // silly to update to 'used' to later update to 'extra'.

                    if (!empty($usedweights) && isset($usedweights[$currentgrade->id]) &&

                            grade_floats_equal($currentgrade->aggregationweight, $usedweights[$currentgrade->id])) {

                        unset($usedweights[$currentgrade->id]);

                    }

                    // Update the item to extra if it is not already marked as extra in the database or if the item's

                    // aggregationweight will be updated when going through $usedweights items.

                    if ($currentgrade->aggregationstatus !== 'extra' ||

                            (!empty($usedweights) && isset($usedweights[$currentgrade->id]))) {

                        $toupdate['extracredit'][] = $currentgrade->id;

                    }

                    continue;

                }

                // If is not in any of the above groups it should be set to 'unknown', checking that the item is not already

                // unknown, if it is we don't need to update it.

                if ($currentgrade->aggregationstatus !== 'unknown' || grade_floats_different($currentgrade->aggregationweight, 0)) {

                    $toupdate['unknown'][] = $currentgrade->id;

                }

            }

            $currentgrades->close();

        }

        // Update items to 'unknown' status.

        if (!empty($toupdate['unknown'])) {

            list($itemsql, $itemlist) = $DB->get_in_or_equal($toupdate['unknown'], SQL_PARAMS_NAMED, 'g');

            $itemlist['userid'] = $userid;

            $sql = "UPDATE {grade_grades}

                       SET aggregationstatus = 'unknown',

                           aggregationweight = 0

                     WHERE itemid $itemsql AND userid = :userid";

            $DB->execute($sql, $itemlist);

        }

        // Update items to 'used' status and setting the proper weight.

        if (!empty($usedweights)) {

            // The usedweights items are updated individually to record the weights.

            foreach ($usedweights as $gradeitemid => $contribution) {

                $sql = "UPDATE {grade_grades}

                           SET aggregationstatus = 'used',

                               aggregationweight = :contribution

                         WHERE itemid = :itemid AND userid = :userid";

                $params = array('contribution' => $contribution, 'itemid' => $gradeitemid, 'userid' => $userid);

                $DB->execute($sql, $params);

            }

        }

        // Update items to 'novalue' status.

        if (!empty($toupdate['novalue'])) {

            list($itemsql, $itemlist) = $DB->get_in_or_equal($toupdate['novalue'], SQL_PARAMS_NAMED, 'g');

            $itemlist['userid'] = $userid;

            $sql = "UPDATE {grade_grades}

                       SET aggregationstatus = 'novalue',

                           aggregationweight = 0

                     WHERE itemid $itemsql AND userid = :userid";

            $DB->execute($sql, $itemlist);

        }

        // Update items to 'dropped' status.

        if (!empty($toupdate['dropped'])) {

            list($itemsql, $itemlist) = $DB->get_in_or_equal($toupdate['dropped'], SQL_PARAMS_NAMED, 'g');

            $itemlist['userid'] = $userid;

            $sql = "UPDATE {grade_grades}

                       SET aggregationstatus = 'dropped',

                           aggregationweight = 0

                     WHERE itemid $itemsql AND userid = :userid";

            $DB->execute($sql, $itemlist);

        }

        // Update items to 'extracredit' status.

        if (!empty($toupdate['extracredit'])) {

            list($itemsql, $itemlist) = $DB->get_in_or_equal($toupdate['extracredit'], SQL_PARAMS_NAMED, 'g');

            $itemlist['userid'] = $userid;

            $DB->set_field_select('grade_grades',

                                  'aggregationstatus',

                                  'extra',

                                  "itemid $itemsql AND userid = :userid",

                                  $itemlist);