42161297754484fd7d8bc2a92f78d55ff9461518
[moodle.git] / grade / edit / tree / lib.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
17 /**
18  * A library of classes used by the grade edit pages
19  *
20  * @package   core_grades
21  * @copyright 2009 Nicolas Connault
22  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
23  */
25 class grade_edit_tree {
26     public $columns = array();
28     /**
29      * @var grade_tree $gtree   @see grade/lib.php
30      */
31     public $gtree;
33     /**
34      * @var grade_plugin_return @see grade/lib.php
35      */
36     public $gpr;
38     /**
39      * @var string              $moving The eid of the category or item being moved
40      */
41     public $moving;
43     public $deepest_level;
45     public $uses_weight = false;
47     public $table;
49     public $categories = array();
51     /**
52      * Show calculator icons next to manual grade items
53      * @var bool $show_calculations
54      */
55     private $show_calculations;
57     /**
58      * Constructor
59      */
60     public function __construct($gtree, $moving=false, $gpr) {
61         global $USER, $OUTPUT, $COURSE;
63         $systemdefault = get_config('moodle', 'grade_report_showcalculations');
64         $this->show_calculations = get_user_preferences('grade_report_showcalculations', $systemdefault);
66         $this->gtree = $gtree;
67         $this->moving = $moving;
68         $this->gpr = $gpr;
69         $this->deepest_level = $this->get_deepest_level($this->gtree->top_element);
71         $this->columns = array(grade_edit_tree_column::factory('name', array('deepest_level' => $this->deepest_level)));
73         if ($this->uses_weight) {
74             $this->columns[] = grade_edit_tree_column::factory('weight', array('adv' => 'weight'));
75         }
77         $this->columns[] = grade_edit_tree_column::factory('range'); // This is not a setting... How do we deal with it?
78         $this->columns[] = grade_edit_tree_column::factory('actions');
80         if ($this->deepest_level > 1) {
81             $this->columns[] = grade_edit_tree_column::factory('select');
82         }
84         $this->table = new html_table();
85         $this->table->id = "grade_edit_tree_table";
86         $this->table->attributes['class'] = 'generaltable simple setup-grades';
87         if ($this->moving) {
88             $this->table->attributes['class'] .= ' moving';
89         }
91         foreach ($this->columns as $column) {
92             if (!($this->moving && $column->hide_when_moving)) {
93                 $this->table->head[] = $column->get_header_cell();
94             }
95         }
97         $rowcount = 0;
98         $this->table->data = $this->build_html_tree($this->gtree->top_element, true, array(), 0, $rowcount);
99     }
101     /**
102      * Recursive function for building the table holding the grade categories and items,
103      * with CSS indentation and styles.
104      *
105      * @param array   $element The current tree element being rendered
106      * @param boolean $totals Whether or not to print category grade items (category totals)
107      * @param array   $parents An array of parent categories for the current element (used for indentation and row classes)
108      *
109      * @return string HTML
110      */
111     public function build_html_tree($element, $totals, $parents, $level, &$row_count) {
112         global $CFG, $COURSE, $PAGE, $OUTPUT;
114         $object = $element['object'];
115         $eid    = $element['eid'];
116         $object->name = $this->gtree->get_element_header($element, true, true, true, true, true);
117         $object->stripped_name = $this->gtree->get_element_header($element, false, false, false);
118         $is_category_item = false;
119         if ($element['type'] == 'categoryitem' || $element['type'] == 'courseitem') {
120             $is_category_item = true;
121         }
123         $rowclasses = array();
124         foreach ($parents as $parent_eid) {
125             $rowclasses[] = $parent_eid;
126         }
128         $moveaction = '';
129         $actionsmenu = new action_menu();
130         $actionsmenu->set_menu_trigger(get_string('edit'));
131         $actionsmenu->set_owner_selector('grade-item-' . $eid);
132         $actionsmenu->set_alignment(action_menu::TL, action_menu::BL);
134         if (!$is_category_item && ($icon = $this->gtree->get_edit_icon($element, $this->gpr, true))) {
135             $actionsmenu->add($icon);
136         }
137         // MDL-49281 if grade_item already has calculation, it should be editable even if global setting is off.
138         $type = $element['type'];
139         $iscalculated = ($type == 'item' or $type == 'courseitem' or $type == 'categoryitem') && $object->is_calculated();
140         $icon = $this->gtree->get_calculation_icon($element, $this->gpr, true);
141         if ($iscalculated || ($this->show_calculations && $icon)) {
142             $actionsmenu->add($icon);
143         }
145         if ($element['type'] == 'item' or ($element['type'] == 'category' and $element['depth'] > 1)) {
146             if ($this->element_deletable($element)) {
147                 $aurl = new moodle_url('index.php', array('id' => $COURSE->id, 'action' => 'delete', 'eid' => $eid, 'sesskey' => sesskey()));
148                 $icon = new action_menu_link_secondary($aurl, new pix_icon('t/delete', get_string('delete')), get_string('delete'));
149                 $actionsmenu->add($icon);
150             }
152             if ($this->element_duplicatable($element)) {
153                 $duplicateparams = array();
154                 $duplicateparams['id'] = $COURSE->id;
155                 $duplicateparams['action'] = 'duplicate';
156                 $duplicateparams['eid'] = $eid;
157                 $duplicateparams['sesskey'] = sesskey();
158                 $aurl = new moodle_url('index.php', $duplicateparams);
159                 $duplicateicon = new pix_icon('t/copy', get_string('duplicate'));
160                 $icon = new action_menu_link_secondary($aurl, $duplicateicon, get_string('duplicate'));
161                 $actionsmenu->add($icon);
162             }
164             $aurl = new moodle_url('index.php', array('id' => $COURSE->id, 'action' => 'moveselect', 'eid' => $eid, 'sesskey' => sesskey()));
165             $moveaction .= $OUTPUT->action_icon($aurl, new pix_icon('t/move', get_string('move')));
166         }
168         if ($icon = $this->gtree->get_hiding_icon($element, $this->gpr, true)) {
169             $actionsmenu->add($icon);
170         }
172         if ($icon = $this->gtree->get_reset_icon($element, $this->gpr, true)) {
173             $actionsmenu->add($icon);
174         }
176         $actions = $OUTPUT->render($actionsmenu);
178         $returnrows = array();
179         $root = false;
181         $id = required_param('id', PARAM_INT);
183         /// prepare move target if needed
184         $last = '';
186         /// print the list items now
187         if ($this->moving == $eid) {
188             // do not diplay children
189             $cell = new html_table_cell();
190             $cell->colspan = 12;
191             $cell->attributes['class'] = $element['type'] . ' moving column-name level' .
192                 ($level + 1) . ' level' . ($level % 2 ? 'even' : 'odd');
193             $cell->text = $object->name.' ('.get_string('move').')';
194             return array(new html_table_row(array($cell)));
195         }
197         if ($element['type'] == 'category') {
198             $level++;
199             $this->categories[$object->id] = $object->stripped_name;
200             $category = grade_category::fetch(array('id' => $object->id));
201             $item = $category->get_grade_item();
203             // Add aggregation coef input if not a course item and if parent category has correct aggregation type
204             $dimmed = ($item->is_hidden()) ? 'dimmed_text' : '';
206             // Before we print the category's row, we must find out how many rows will appear below it (for the filler cell's rowspan)
207             $aggregation_position = grade_get_setting($COURSE->id, 'aggregationposition', $CFG->grade_aggregationposition);
208             $category_total_data = null; // Used if aggregationposition is set to "last", so we can print it last
210             $html_children = array();
212             $row_count = 0;
214             foreach($element['children'] as $child_el) {
215                 $moveto = null;
217                 if (empty($child_el['object']->itemtype)) {
218                     $child_el['object']->itemtype = false;
219                 }
221                 if (($child_el['object']->itemtype == 'course' || $child_el['object']->itemtype == 'category') && !$totals) {
222                     continue;
223                 }
225                 $child_eid = $child_el['eid'];
226                 $first = '';
228                 if ($child_el['object']->itemtype == 'course' || $child_el['object']->itemtype == 'category') {
229                     $first = array('first' => 1);
230                     $child_eid = $eid;
231                 }
233                 if ($this->moving && $this->moving != $child_eid) {
235                     $strmove     = get_string('move');
236                     $strmovehere = get_string('movehere');
237                     $actions = $moveaction = ''; // no action icons when moving
239                     $aurl = new moodle_url('index.php', array('id' => $COURSE->id, 'action' => 'move', 'eid' => $this->moving, 'moveafter' => $child_eid, 'sesskey' => sesskey()));
240                     if ($first) {
241                         $aurl->params($first);
242                     }
244                     $cell = new html_table_cell();
245                     $cell->colspan = 12;
246                     $cell->attributes['class'] = 'movehere level' . ($level + 1) . ' level' . ($level % 2 ? 'even' : 'odd');
248                     $icon = new pix_icon('movehere', $strmovehere, null, array('class'=>'movetarget'));
249                     $cell->text = $OUTPUT->action_icon($aurl, $icon);
251                     $moveto = new html_table_row(array($cell));
252                 }
254                 $newparents = $parents;
255                 $newparents[] = $eid;
257                 $row_count++;
258                 $child_row_count = 0;
260                 // If moving, do not print course and category totals, but still print the moveto target box
261                 if ($this->moving && ($child_el['object']->itemtype == 'course' || $child_el['object']->itemtype == 'category')) {
262                     $html_children[] = $moveto;
263                 } elseif ($child_el['object']->itemtype == 'course' || $child_el['object']->itemtype == 'category') {
264                     // We don't build the item yet because we first need to know the deepest level of categories (for category/name colspans)
265                     $category_total_item = $this->build_html_tree($child_el, $totals, $newparents, $level, $child_row_count);
266                     if (!$aggregation_position) {
267                         $html_children = array_merge($html_children, $category_total_item);
268                     }
269                 } else {
270                     $html_children = array_merge($html_children, $this->build_html_tree($child_el, $totals, $newparents, $level, $child_row_count));
271                     if (!empty($moveto)) {
272                         $html_children[] = $moveto;
273                     }
275                     if ($this->moving) {
276                         $row_count++;
277                     }
278                 }
280                 $row_count += $child_row_count;
282                 // If the child is a category, increment row_count by one more (for the extra coloured row)
283                 if ($child_el['type'] == 'category') {
284                     $row_count++;
285                 }
286             }
288             // Print category total at the end if aggregation position is "last" (1)
289             if (!empty($category_total_item) && $aggregation_position) {
290                 $html_children = array_merge($html_children, $category_total_item);
291             }
293             // Determine if we are at the root
294             if (isset($element['object']->grade_item) && $element['object']->grade_item->is_course_item()) {
295                 $root = true;
296             }
298             $levelclass = "level$level level" . ($level % 2 ? 'odd' : 'even');
300             $courseclass = '';
301             if ($level == 1) {
302                 $courseclass = 'coursecategory';
303             }
305             $row = new html_table_row();
306             $row->id = 'grade-item-' . $eid;
307             $row->attributes['class'] = $courseclass . ' category ' . $dimmed;
308             $row->attributes['data-category'] = $eid;
309             $row->attributes['data-itemid'] = $category->get_grade_item()->id;
310             foreach ($rowclasses as $class) {
311                 $row->attributes['class'] .= ' ' . $class;
312             }
314             $headercell = new html_table_cell();
315             $headercell->header = true;
316             $headercell->scope = 'row';
317             $headercell->attributes['title'] = $object->stripped_name;
318             $headercell->attributes['class'] = 'cell column-rowspan rowspan ' . $levelclass;
319             $headercell->rowspan = $row_count + 1;
320             $row->cells[] = $headercell;
322             foreach ($this->columns as $column) {
323                 if (!($this->moving && $column->hide_when_moving)) {
324                     $row->cells[] = $column->get_category_cell($category, $levelclass, [
325                         'id' => $id,
326                         'name' => $object->name,
327                         'level' => $level,
328                         'actions' => $actions,
329                         'moveaction' => $moveaction,
330                         'eid' => $eid,
331                     ]);
332                 }
333             }
335             $returnrows[] = $row;
337             $returnrows = array_merge($returnrows, $html_children);
339             // Print a coloured row to show the end of the category across the table
340             $endcell = new html_table_cell();
341             $endcell->colspan = (19 - $level);
342             $endcell->attributes['class'] = 'emptyrow colspan ' . $levelclass;
344             $returnrows[] = new html_table_row(array($endcell));
346         } else { // Dealing with a grade item
348             $item = grade_item::fetch(array('id' => $object->id));
349             $element['type'] = 'item';
350             $element['object'] = $item;
352             $categoryitemclass = '';
353             if ($item->itemtype == 'category') {
354                 $categoryitemclass = 'categoryitem';
355             }
356             if ($item->itemtype == 'course') {
357                 $categoryitemclass = 'courseitem';
358             }
360             $dimmed = ($item->is_hidden()) ? "dimmed_text" : "";
361             $gradeitemrow = new html_table_row();
362             $gradeitemrow->id = 'grade-item-' . $eid;
363             $gradeitemrow->attributes['class'] = $categoryitemclass . ' item ' . $dimmed;
364             $gradeitemrow->attributes['data-itemid'] = $object->id;
365             foreach ($rowclasses as $class) {
366                 $gradeitemrow->attributes['class'] .= ' ' . $class;
367             }
369             foreach ($this->columns as $column) {
370                 if (!($this->moving && $column->hide_when_moving)) {
371                     $gradeitemrow->cells[] = $column->get_item_cell($item, array('id' => $id, 'name' => $object->name,
372                         'level' => $level, 'actions' => $actions, 'element' => $element, 'eid' => $eid,
373                         'moveaction' => $moveaction, 'itemtype' => $object->itemtype));
374                 }
375             }
377             $returnrows[] = $gradeitemrow;
378         }
380         return $returnrows;
382     }
384     /**
385      * Given a grade_item object, returns a labelled input if an aggregation coefficient (weight or extra credit) applies to it.
386      * @param grade_item $item
387      * @return string HTML
388      */
389     static function get_weight_input($item) {
390         global $OUTPUT;
392         if (!is_object($item) || get_class($item) !== 'grade_item') {
393             throw new Exception('grade_edit_tree::get_weight_input($item) was given a variable that is not of the required type (grade_item object)');
394             return false;
395         }
397         if ($item->is_course_item()) {
398             return '';
399         }
401         $parent_category = $item->get_parent_category();
402         $parent_category->apply_forced_settings();
403         $aggcoef = $item->get_coefstring();
405         $itemname = $item->itemname;
406         if ($item->is_category_item()) {
407             // Remember, the parent category of a category item is the category itself.
408             $itemname = $parent_category->get_name();
409         }
410         $str = '';
412         if ($aggcoef == 'aggregationcoefweight' || $aggcoef == 'aggregationcoef' || $aggcoef == 'aggregationcoefextraweight') {
414             return $OUTPUT->render_from_template('core_grades/weight_field', [
415                 'id' => $item->id,
416                 'itemname' => $itemname,
417                 'value' => self::format_number($item->aggregationcoef)
418             ]);
420         } else if ($aggcoef == 'aggregationcoefextraweightsum') {
422             $tpldata = [
423                 'id' => $item->id,
424                 'itemname' => $itemname,
425                 'value' => self::format_number($item->aggregationcoef2 * 100.0),
426                 'checked' => $item->weightoverride,
427                 'disabled' => !$item->weightoverride
428             ];
429             $str .= $OUTPUT->render_from_template('core_grades/weight_override_field', $tpldata);
431         }
433         return $str;
434     }
436     // Trims trailing zeros.
437     // Used on the 'Gradebook setup' page for grade items settings like aggregation co-efficient.
438     // Grader report has its own decimal place settings so they are handled elsewhere.
439     static function format_number($number) {
440         $formatted = rtrim(format_float($number, 4),'0');
441         if (substr($formatted, -1)==get_string('decsep', 'langconfig')) { //if last char is the decimal point
442             $formatted .= '0';
443         }
444         return $formatted;
445     }
447     /**
448      * Given an element of the grade tree, returns whether it is deletable or not (only manual grade items are deletable)
449      *
450      * @param array $element
451      * @return bool
452      */
453     function element_deletable($element) {
454         global $COURSE;
456         if ($element['type'] != 'item') {
457             return true;
458         }
460         $grade_item = $element['object'];
462         if ($grade_item->itemtype != 'mod' or $grade_item->is_outcome_item() or $grade_item->gradetype == GRADE_TYPE_NONE) {
463             return true;
464         }
466         $modinfo = get_fast_modinfo($COURSE);
467         if (!isset($modinfo->instances[$grade_item->itemmodule][$grade_item->iteminstance])) {
468             // module does not exist
469             return true;
470         }
472         return false;
473     }
475     /**
476      * Given an element of the grade tree, returns whether it is duplicatable or not (only manual grade items are duplicatable)
477      *
478      * @param array $element
479      * @return bool
480      */
481     public function element_duplicatable($element) {
482         if ($element['type'] != 'item') {
483             return false;
484         }
486         $gradeitem = $element['object'];
487         if ($gradeitem->itemtype != 'mod') {
488             return true;
489         }
490         return false;
491     }
493     /**
494      * Given the grade tree and an array of element ids (e.g. c15, i42), and expecting the 'moveafter' URL param,
495      * moves the selected items to the requested location. Then redirects the user to the given $returnurl
496      *
497      * @param object $gtree The grade tree (a recursive representation of the grade categories and grade items)
498      * @param array $eids
499      * @param string $returnurl
500      */
501     function move_elements($eids, $returnurl) {
502         $moveafter = required_param('moveafter', PARAM_INT);
504         if (!is_array($eids)) {
505             $eids = array($eids);
506         }
508         if(!$after_el = $this->gtree->locate_element("cg$moveafter")) {
509             print_error('invalidelementid', '', $returnurl);
510         }
512         $after = $after_el['object'];
513         $parent = $after;
514         $sortorder = $after->get_sortorder();
516         foreach ($eids as $eid) {
517             if (!$element = $this->gtree->locate_element($eid)) {
518                 print_error('invalidelementid', '', $returnurl);
519             }
520             $object = $element['object'];
522             $object->set_parent($parent->id);
523             $object->move_after_sortorder($sortorder);
524             $sortorder++;
525         }
527         redirect($returnurl, '', 0);
528     }
530     /**
531      * Recurses through the entire grade tree to find and return the maximum depth of the tree.
532      * This should be run only once from the root element (course category), and is used for the
533      * indentation of the Name column's cells (colspan)
534      *
535      * @param array $element An array of values representing a grade tree's element (all grade items in this case)
536      * @param int $level The level of the current recursion
537      * @param int $deepest_level A value passed to each subsequent level of recursion and incremented if $level > $deepest_level
538      * @return int Deepest level
539      */
540     function get_deepest_level($element, $level=0, $deepest_level=1) {
541         $object = $element['object'];
543         $level++;
544         $coefstring = $element['object']->get_coefstring();
545         if ($element['type'] == 'category') {
546             if ($coefstring == 'aggregationcoefweight' || $coefstring == 'aggregationcoefextraweightsum' ||
547                     $coefstring == 'aggregationcoefextraweight') {
548                 $this->uses_weight = true;
549             }
551             foreach($element['children'] as $child_el) {
552                 if ($level > $deepest_level) {
553                     $deepest_level = $level;
554                 }
555                 $deepest_level = $this->get_deepest_level($child_el, $level, $deepest_level);
556             }
558             $category = grade_category::fetch(array('id' => $object->id));
559             $item = $category->get_grade_item();
560             if ($item->gradetype == GRADE_TYPE_NONE) {
561                 // Add 1 more level for grade category that has no total.
562                 $deepest_level++;
563             }
564         }
566         return $deepest_level;
567     }
569     /**
570      * Updates the provided gradecategory item with the provided data.
571      *
572      * @param grade_category $gradecategory The category to update.
573      * @param stdClass $data the data to update the category with.
574      * @return void
575      */
576     public static function update_gradecategory(grade_category $gradecategory, stdClass $data) {
577         // If no fullname is entered for a course category, put ? in the DB.
578         if (!isset($data->fullname) || $data->fullname == '') {
579             $data->fullname = '?';
580         }
582         if (!isset($data->aggregateonlygraded)) {
583             $data->aggregateonlygraded = 0;
584         }
585         if (!isset($data->aggregateoutcomes)) {
586             $data->aggregateoutcomes = 0;
587         }
588         grade_category::set_properties($gradecategory, $data);
590         // CATEGORY.
591         if (empty($gradecategory->id)) {
592             $gradecategory->insert();
594         } else {
595             $gradecategory->update();
596         }
598         // GRADE ITEM.
599         // Grade item data saved with prefix "grade_item_".
600         $itemdata = new stdClass();
601         foreach ($data as $k => $v) {
602             if (preg_match('/grade_item_(.*)/', $k, $matches)) {
603                 $itemdata->{$matches[1]} = $v;
604             }
605         }
607         if (!isset($itemdata->aggregationcoef)) {
608             $itemdata->aggregationcoef = 0;
609         }
611         if (!isset($itemdata->gradepass) || $itemdata->gradepass == '') {
612             $itemdata->gradepass = 0;
613         }
615         if (!isset($itemdata->grademax) || $itemdata->grademax == '') {
616             $itemdata->grademax = 0;
617         }
619         if (!isset($itemdata->grademin) || $itemdata->grademin == '') {
620             $itemdata->grademin = 0;
621         }
623         $hidden      = empty($itemdata->hidden) ? 0 : $itemdata->hidden;
624         $hiddenuntil = empty($itemdata->hiddenuntil) ? 0 : $itemdata->hiddenuntil;
625         unset($itemdata->hidden);
626         unset($itemdata->hiddenuntil);
628         $locked   = empty($itemdata->locked) ? 0 : $itemdata->locked;
629         $locktime = empty($itemdata->locktime) ? 0 : $itemdata->locktime;
630         unset($itemdata->locked);
631         unset($itemdata->locktime);
633         $convert = array('grademax', 'grademin', 'gradepass', 'multfactor', 'plusfactor', 'aggregationcoef', 'aggregationcoef2');
634         foreach ($convert as $param) {
635             if (property_exists($itemdata, $param)) {
636                 $itemdata->$param = unformat_float($itemdata->$param);
637             }
638         }
639         if (isset($itemdata->aggregationcoef2)) {
640             $itemdata->aggregationcoef2 = $itemdata->aggregationcoef2 / 100.0;
641         }
643         // When creating a new category, a number of grade item fields are filled out automatically, and are required.
644         // If the user leaves these fields empty during creation of a category, we let the default values take effect.
645         // Otherwise, we let the user-entered grade item values take effect.
646         $gradeitem = $gradecategory->load_grade_item();
647         $gradeitemcopy = fullclone($gradeitem);
648         grade_item::set_properties($gradeitem, $itemdata);
650         if (empty($gradeitem->id)) {
651             $gradeitem->id = $gradeitemcopy->id;
652         }
653         if (empty($gradeitem->grademax) && $gradeitem->grademax != '0') {
654             $gradeitem->grademax = $gradeitemcopy->grademax;
655         }
656         if (empty($gradeitem->grademin) && $gradeitem->grademin != '0') {
657             $gradeitem->grademin = $gradeitemcopy->grademin;
658         }
659         if (empty($gradeitem->gradepass) && $gradeitem->gradepass != '0') {
660             $gradeitem->gradepass = $gradeitemcopy->gradepass;
661         }
662         if (empty($gradeitem->aggregationcoef) && $gradeitem->aggregationcoef != '0') {
663             $gradeitem->aggregationcoef = $gradeitemcopy->aggregationcoef;
664         }
666         // Handle null decimals value - must be done before update!
667         if (!property_exists($itemdata, 'decimals') or $itemdata->decimals < 0) {
668             $gradeitem->decimals = null;
669         }
671         // Change weightoverride flag. Check if the value is set, because it is not when the checkbox is not ticked.
672         $itemdata->weightoverride = isset($itemdata->weightoverride) ? $itemdata->weightoverride : 0;
673         if ($gradeitem->weightoverride != $itemdata->weightoverride && $gradecategory->aggregation == GRADE_AGGREGATE_SUM) {
674             // If we are using natural weight and the weight has been un-overriden, force parent category to recalculate weights.
675             $gradecategory->force_regrading();
676         }
677         $gradeitem->weightoverride = $itemdata->weightoverride;
679         $gradeitem->outcomeid = null;
681         if (!empty($data->grade_item_rescalegrades) && $data->grade_item_rescalegrades == 'yes') {
682             $gradeitem->rescale_grades_keep_percentage($gradeitemcopy->grademin, $gradeitemcopy->grademax,
683                 $gradeitem->grademin, $gradeitem->grademax, 'gradebook');
684         }
686         // Update hiding flag.
687         if ($hiddenuntil) {
688             $gradeitem->set_hidden($hiddenuntil, false);
689         } else {
690             $gradeitem->set_hidden($hidden, false);
691         }
693         $gradeitem->set_locktime($locktime); // Locktime first - it might be removed when unlocking.
694         $gradeitem->set_locked($locked, false, true);
696         $gradeitem->update(); // We don't need to insert it, it's already created when the category is created.
698         // Set parent if needed.
699         if (isset($data->parentcategory)) {
700             $gradecategory->set_parent($data->parentcategory, 'gradebook');
701         }
702     }
705 /**
706  * Class grade_edit_tree_column
707  *
708  * @package   core_grades
709  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
710  */
711 abstract class grade_edit_tree_column {
712     public $forced;
713     public $hidden;
714     public $forced_hidden;
715     public $advanced_hidden;
716     public $hide_when_moving = true;
717     /**
718      * html_table_cell object used as a template for header cells in all categories.
719      * It must be cloned before being used.
720      * @var html_table_cell $headercell
721      */
722     public $headercell;
723     /**
724      * html_table_cell object used as a template for category cells in all categories.
725      * It must be cloned before being used.
726      * @var html_table_cell $categorycell
727      */
728     public $categorycell;
729     /**
730      * html_table_cell object used as a template for item cells in all categories.
731      * It must be cloned before being used.
732      * @var html_table_cell $itemcell
733      */
734     public $itemcell;
736     public static function factory($name, $params=array()) {
737         $class_name = "grade_edit_tree_column_$name";
738         if (class_exists($class_name)) {
739             return new $class_name($params);
740         }
741     }
743     public abstract function get_header_cell();
745     public function get_category_cell($category, $levelclass, $params) {
746         $cell = clone($this->categorycell);
747         $cell->attributes['class'] .= ' ' . $levelclass;
748         $cell->attributes['text'] = '';
749         return $cell;
750     }
752     public function get_item_cell($item, $params) {
753         $cell = clone($this->itemcell);
754         $cell->attributes['text'] = '';
755         if (isset($params['level'])) {
756             $level = $params['level'] + (($item->itemtype == 'category' || $item->itemtype == 'course') ? 0 : 1);
757             $cell->attributes['class'] .= ' level' . $level;
758             $cell->attributes['class'] .= ' level' . ($level % 2 ? 'odd' : 'even');
759         }
760         return $cell;
761     }
763     public function __construct() {
764         $this->headercell = new html_table_cell();
765         $this->headercell->header = true;
766         $this->headercell->attributes['class'] = 'header';
768         $this->categorycell = new html_table_cell();
769         $this->categorycell->attributes['class']  = 'cell';
771         $this->itemcell = new html_table_cell();
772         $this->itemcell->attributes['class'] = 'cell';
774         if (preg_match('/^grade_edit_tree_column_(\w*)$/', get_class($this), $matches)) {
775             $this->headercell->attributes['class'] .= ' column-' . $matches[1];
776             $this->categorycell->attributes['class'] .= ' column-' . $matches[1];
777             $this->itemcell->attributes['class'] .= ' column-' . $matches[1];
778         }
779     }
782 /**
783  * Class grade_edit_tree_column_name
784  *
785  * @package   core_grades
786  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
787  */
788 class grade_edit_tree_column_name extends grade_edit_tree_column {
789     public $forced = false;
790     public $hidden = false;
791     public $forced_hidden = false;
792     public $advanced_hidden = false;
793     public $deepest_level = 1;
794     public $hide_when_moving = false;
796     public function __construct($params) {
797         if (empty($params['deepest_level'])) {
798             throw new Exception('Tried to instantiate a grade_edit_tree_column_name object without the "deepest_level" param!');
799         }
801         $this->deepest_level = $params['deepest_level'];
802         parent::__construct();
803     }
805     public function get_header_cell() {
806         $headercell = clone($this->headercell);
807         $headercell->colspan = $this->deepest_level + 1;
808         $headercell->text = get_string('name');
809         return $headercell;
810     }
812     public function get_category_cell($category, $levelclass, $params) {
813         global $OUTPUT;
814         if (empty($params['name']) || empty($params['level'])) {
815             throw new Exception('Array key (name or level) missing from 3rd param of grade_edit_tree_column_name::get_category_cell($category, $levelclass, $params)');
816         }
817         $moveaction = isset($params['moveaction']) ? $params['moveaction'] : '';
818         $categorycell = parent::get_category_cell($category, $levelclass, $params);
819         $categorycell->colspan = ($this->deepest_level +1) - $params['level'];
820         $categorycell->text = $OUTPUT->heading($moveaction . $params['name'], 4);
821         return $categorycell;
822     }
824     public function get_item_cell($item, $params) {
825         global $CFG;
827         if (empty($params['element']) || empty($params['name']) || empty($params['level'])) {
828             throw new Exception('Array key (name, level or element) missing from 2nd param of grade_edit_tree_column_name::get_item_cell($item, $params)');
829         }
831         $name = $params['name'];
832         $moveaction = isset($params['moveaction']) ? $params['moveaction'] : '';
834         $itemcell = parent::get_item_cell($item, $params);
835         $itemcell->colspan = ($this->deepest_level + 1) - $params['level'];
836         $itemcell->text = $moveaction . $name;
837         return $itemcell;
838     }
841 /**
842  * Class grade_edit_tree_column_weight
843  *
844  * @package   core_grades
845  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
846  */
847 class grade_edit_tree_column_weight extends grade_edit_tree_column {
849     public function get_header_cell() {
850         global $OUTPUT;
851         $headercell = clone($this->headercell);
852         $headercell->text = get_string('weights', 'grades').$OUTPUT->help_icon('aggregationcoefweight', 'grades');
853         return $headercell;
854     }
856     public function get_category_cell($category, $levelclass, $params) {
858         $item = $category->get_grade_item();
859         $categorycell = parent::get_category_cell($category, $levelclass, $params);
860         $categorycell->text = grade_edit_tree::get_weight_input($item);
861         return $categorycell;
862     }
864     public function get_item_cell($item, $params) {
865         global $CFG;
866         if (empty($params['element'])) {
867             throw new Exception('Array key (element) missing from 2nd param of grade_edit_tree_column_weightorextracredit::get_item_cell($item, $params)');
868         }
869         $itemcell = parent::get_item_cell($item, $params);
870         $itemcell->text = '&nbsp;';
871         $object = $params['element']['object'];
873         if (!in_array($object->itemtype, array('courseitem', 'categoryitem', 'category'))
874                 && !in_array($object->gradetype, array(GRADE_TYPE_NONE, GRADE_TYPE_TEXT))
875                 && (!$object->is_outcome_item() || $object->load_parent_category()->aggregateoutcomes)
876                 && ($object->gradetype != GRADE_TYPE_SCALE || !empty($CFG->grade_includescalesinaggregation))) {
877             $itemcell->text = grade_edit_tree::get_weight_input($item);
878         }
880         return $itemcell;
881     }
884 /**
885  * Class grade_edit_tree_column_range
886  *
887  * @package   core_grades
888  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
889  */
890 class grade_edit_tree_column_range extends grade_edit_tree_column {
892     public function get_header_cell() {
893         $headercell = clone($this->headercell);
894         $headercell->text = get_string('maxgrade', 'grades');
895         return $headercell;
896     }
898     public function get_category_cell($category, $levelclass, $params) {
899         $categorycell = parent::get_category_cell($category, $levelclass, $params);
900         $categorycell->text = ' - ';
901         return $categorycell;
902     }
904     public function get_item_cell($item, $params) {
905         global $DB, $OUTPUT;
907         // If the parent aggregation is Natural, we should show the number, even for scales, as that value is used...
908         // ...in the computation. For text grades, the grademax is not used, so we can still show the no value string.
909         $parentcat = $item->get_parent_category();
910         if ($item->gradetype == GRADE_TYPE_TEXT) {
911             $grademax = ' - ';
912         } else if ($item->gradetype == GRADE_TYPE_SCALE) {
913             $scale = $DB->get_record('scale', array('id' => $item->scaleid));
914             $scale_items = null;
915             if (empty($scale)) { //if the item is using a scale that's been removed
916                 $scale_items = array();
917             } else {
918                 $scale_items = explode(',', $scale->scale);
919             }
920             if ($parentcat->aggregation == GRADE_AGGREGATE_SUM) {
921                 $grademax = end($scale_items) . ' (' .
922                         format_float($item->grademax, $item->get_decimals()) . ')';
923             } else {
924                 $grademax = end($scale_items) . ' (' . count($scale_items) . ')';
925             }
926         } else {
927             $grademax = format_float($item->grademax, $item->get_decimals());
928         }
930         $isextracredit = false;
931         if ($item->aggregationcoef > 0) {
932             // For category grade items, we need the grandparent category.
933             // The parent is just category the grade item represents.
934             if ($item->is_category_item()) {
935                 $grandparentcat = $parentcat->get_parent_category();
936                 if ($grandparentcat->is_extracredit_used()) {
937                     $isextracredit = true;
938                 }
939             } else if ($parentcat->is_extracredit_used()) {
940                 $isextracredit = true;
941             }
942         }
943         if ($isextracredit) {
944             $grademax .= ' ' . html_writer::tag('abbr', get_string('aggregationcoefextrasumabbr', 'grades'),
945                 array('title' => get_string('aggregationcoefextrasum', 'grades')));
946         }
948         $itemcell = parent::get_item_cell($item, $params);
949         $itemcell->text = $grademax;
950         return $itemcell;
951     }
954 /**
955  * Class grade_edit_tree_column_actions
956  *
957  * @package   core_grades
958  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
959  */
960 class grade_edit_tree_column_actions extends grade_edit_tree_column {
962     public function __construct($params) {
963         parent::__construct();
964     }
966     public function get_header_cell() {
967         $headercell = clone($this->headercell);
968         $headercell->text = get_string('actions');
969         return $headercell;
970     }
972     public function get_category_cell($category, $levelclass, $params) {
974         if (empty($params['actions'])) {
975             throw new Exception('Array key (actions) missing from 3rd param of grade_edit_tree_column_actions::get_category_actions($category, $levelclass, $params)');
976         }
978         $categorycell = parent::get_category_cell($category, $levelclass, $params);
979         $categorycell->text = $params['actions'];
980         return $categorycell;
981     }
983     public function get_item_cell($item, $params) {
984         if (empty($params['actions'])) {
985             throw new Exception('Array key (actions) missing from 2nd param of grade_edit_tree_column_actions::get_item_cell($item, $params)');
986         }
987         $itemcell = parent::get_item_cell($item, $params);
988         $itemcell->text = $params['actions'];
989         return $itemcell;
990     }
993 /**
994  * Class grade_edit_tree_column_select
995  *
996  * @package   core_grades
997  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
998  */
999 class grade_edit_tree_column_select extends grade_edit_tree_column {
1001     public function get_header_cell() {
1002         $headercell = clone($this->headercell);
1003         $headercell->text = get_string('select');
1004         return $headercell;
1005     }
1007     public function get_category_cell($category, $levelclass, $params) {
1008         global $OUTPUT;
1010         if (empty($params['eid'])) {
1011             throw new Exception('Array key (eid) missing from 3rd param of grade_edit_tree_column_select::get_category_cell($category, $levelclass, $params)');
1012         }
1014         // Get toggle group for this master checkbox.
1015         $togglegroup = $this->get_checkbox_togglegroup($category);
1016         // Set label for this master checkbox.
1017         $masterlabel = get_string('all');
1018         // Use category name if available.
1019         if ($category->fullname !== '?') {
1020             $masterlabel = format_string($category->fullname);
1021             // Limit the displayed category name to prevent the Select column from getting too wide.
1022             if (core_text::strlen($masterlabel) > 20) {
1023                 $masterlabel = get_string('textellipsis', 'core', core_text::substr($masterlabel, 0, 12));
1024             }
1025         }
1026         // Build the master checkbox.
1027         $mastercheckbox = new \core\output\checkbox_toggleall($togglegroup, true, [
1028             'id' => $togglegroup,
1029             'name' => $togglegroup,
1030             'value' => 1,
1031             'classes' => 'itemselect ignoredirty',
1032             'label' => $masterlabel,
1033             // Consistent label to prevent the select column from resizing.
1034             'selectall' => $masterlabel,
1035             'deselectall' => $masterlabel,
1036             'labelclasses' => 'm-0',
1037         ]);
1039         $categorycell = parent::get_category_cell($category, $levelclass, $params);
1040         $categorycell->text = $OUTPUT->render($mastercheckbox);
1041         return $categorycell;
1042     }
1044     public function get_item_cell($item, $params) {
1045         if (empty($params['itemtype']) || empty($params['eid'])) {
1046             print_error('missingitemtypeoreid', 'core_grades');
1047         }
1048         $itemcell = parent::get_item_cell($item, $params);
1050         if ($params['itemtype'] != 'course' && $params['itemtype'] != 'category') {
1051             global $OUTPUT;
1053             // Fetch the grade item's category.
1054             $category = grade_category::fetch(['id' => $item->categoryid]);
1055             $togglegroup = $this->get_checkbox_togglegroup($category);
1057             $checkboxid = 'select_' . $params['eid'];
1058             $checkbox = new \core\output\checkbox_toggleall($togglegroup, false, [
1059                 'id' => $checkboxid,
1060                 'name' => $checkboxid,
1061                 'label' => get_string('select', 'grades', $item->itemname),
1062                 'labelclasses' => 'accesshide',
1063                 'classes' => 'itemselect ignoredirty',
1064             ]);
1065             $itemcell->text = $OUTPUT->render($checkbox);
1066         }
1067         return $itemcell;
1068     }
1070     /**
1071      * Generates a toggle group name for a bulk-action checkbox based on the given grade category.
1072      *
1073      * @param grade_category $category The grade category.
1074      * @return string
1075      */
1076     protected function get_checkbox_togglegroup(grade_category $category): string {
1077         $levels = [];
1078         $categories = explode('/', $category->path);
1079         foreach ($categories as $categoryid) {
1080             $level = 'category' . $categoryid;
1081             if (!in_array($level, $levels)) {
1082                 $levels[] = 'category' . $categoryid;
1083             }
1084         }
1085         $togglegroup = implode(' ', $levels);
1087         return $togglegroup;
1088     }