8b9e101fe19db913fd9371c821ad88fa85893782
[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);
119         $is_category_item = false;
120         if ($element['type'] == 'categoryitem' || $element['type'] == 'courseitem') {
121             $is_category_item = true;
122         }
124         $rowclasses = array();
125         foreach ($parents as $parent_eid) {
126             $rowclasses[] = $parent_eid;
127         }
129         $moveaction = '';
130         $actionsmenu = new action_menu();
131         $actionsmenu->initialise_js($PAGE);
132         $actionsmenu->set_menu_trigger(get_string('edit'));
133         $actionsmenu->set_owner_selector('grade-item-' . $eid);
134         $actionsmenu->set_alignment(action_menu::TL, action_menu::BL);
136         if (!$is_category_item && ($icon = $this->gtree->get_edit_icon($element, $this->gpr, true))) {
137             $actionsmenu->add($icon);
138         }
139         // MDL-49281 if grade_item already has calculation, it should be editable even if global setting is off.
140         $type = $element['type'];
141         $iscalculated = ($type == 'item' or $type == 'courseitem' or $type == 'categoryitem') && $object->is_calculated();
142         $icon = $this->gtree->get_calculation_icon($element, $this->gpr, true);
143         if ($iscalculated || ($this->show_calculations && $icon)) {
144             $actionsmenu->add($icon);
145         }
147         if ($element['type'] == 'item' or ($element['type'] == 'category' and $element['depth'] > 1)) {
148             if ($this->element_deletable($element)) {
149                 $aurl = new moodle_url('index.php', array('id' => $COURSE->id, 'action' => 'delete', 'eid' => $eid, 'sesskey' => sesskey()));
150                 $icon = new action_menu_link_secondary($aurl, new pix_icon('t/delete', get_string('delete')), get_string('delete'));
151                 $actionsmenu->add($icon);
152             }
154             $aurl = new moodle_url('index.php', array('id' => $COURSE->id, 'action' => 'moveselect', 'eid' => $eid, 'sesskey' => sesskey()));
155             $moveaction .= $OUTPUT->action_icon($aurl, new pix_icon('t/move', get_string('move')));
156         }
158         if ($icon = $this->gtree->get_hiding_icon($element, $this->gpr, true)) {
159             $actionsmenu->add($icon);
160         }
162         if ($icon = $this->gtree->get_reset_icon($element, $this->gpr, true)) {
163             $actionsmenu->add($icon);
164         }
166         $actions = $OUTPUT->render($actionsmenu);
168         $returnrows = array();
169         $root = false;
171         $id = required_param('id', PARAM_INT);
173         /// prepare move target if needed
174         $last = '';
176         /// print the list items now
177         if ($this->moving == $eid) {
178             // do not diplay children
179             $cell = new html_table_cell();
180             $cell->colspan = 12;
181             $cell->attributes['class'] = $element['type'] . ' moving column-name level' .
182                 ($level + 1) . ' level' . ($level % 2 ? 'even' : 'odd');
183             $cell->text = $object->name.' ('.get_string('move').')';
184             return array(new html_table_row(array($cell)));
185         }
187         if ($element['type'] == 'category') {
188             $level++;
189             $this->categories[$object->id] = $object->stripped_name;
190             $category = grade_category::fetch(array('id' => $object->id));
191             $item = $category->get_grade_item();
193             // Add aggregation coef input if not a course item and if parent category has correct aggregation type
194             $dimmed = ($item->is_hidden()) ? 'dimmed_text' : '';
196             // Before we print the category's row, we must find out how many rows will appear below it (for the filler cell's rowspan)
197             $aggregation_position = grade_get_setting($COURSE->id, 'aggregationposition', $CFG->grade_aggregationposition);
198             $category_total_data = null; // Used if aggregationposition is set to "last", so we can print it last
200             $html_children = array();
202             $row_count = 0;
204             foreach($element['children'] as $child_el) {
205                 $moveto = null;
207                 if (empty($child_el['object']->itemtype)) {
208                     $child_el['object']->itemtype = false;
209                 }
211                 if (($child_el['object']->itemtype == 'course' || $child_el['object']->itemtype == 'category') && !$totals) {
212                     continue;
213                 }
215                 $child_eid = $child_el['eid'];
216                 $first = '';
218                 if ($child_el['object']->itemtype == 'course' || $child_el['object']->itemtype == 'category') {
219                     $first = array('first' => 1);
220                     $child_eid = $eid;
221                 }
223                 if ($this->moving && $this->moving != $child_eid) {
225                     $strmove     = get_string('move');
226                     $strmovehere = get_string('movehere');
227                     $actions = $moveaction = ''; // no action icons when moving
229                     $aurl = new moodle_url('index.php', array('id' => $COURSE->id, 'action' => 'move', 'eid' => $this->moving, 'moveafter' => $child_eid, 'sesskey' => sesskey()));
230                     if ($first) {
231                         $aurl->params($first);
232                     }
234                     $cell = new html_table_cell();
235                     $cell->colspan = 12;
236                     $cell->attributes['class'] = 'movehere level' . ($level + 1) . ' level' . ($level % 2 ? 'even' : 'odd');
238                     $icon = new pix_icon('movehere', $strmovehere, null, array('class'=>'movetarget'));
239                     $cell->text = $OUTPUT->action_icon($aurl, $icon);
241                     $moveto = new html_table_row(array($cell));
242                 }
244                 $newparents = $parents;
245                 $newparents[] = $eid;
247                 $row_count++;
248                 $child_row_count = 0;
250                 // If moving, do not print course and category totals, but still print the moveto target box
251                 if ($this->moving && ($child_el['object']->itemtype == 'course' || $child_el['object']->itemtype == 'category')) {
252                     $html_children[] = $moveto;
253                 } elseif ($child_el['object']->itemtype == 'course' || $child_el['object']->itemtype == 'category') {
254                     // We don't build the item yet because we first need to know the deepest level of categories (for category/name colspans)
255                     $category_total_item = $this->build_html_tree($child_el, $totals, $newparents, $level, $child_row_count);
256                     if (!$aggregation_position) {
257                         $html_children = array_merge($html_children, $category_total_item);
258                     }
259                 } else {
260                     $html_children = array_merge($html_children, $this->build_html_tree($child_el, $totals, $newparents, $level, $child_row_count));
261                     if (!empty($moveto)) {
262                         $html_children[] = $moveto;
263                     }
265                     if ($this->moving) {
266                         $row_count++;
267                     }
268                 }
270                 $row_count += $child_row_count;
272                 // If the child is a category, increment row_count by one more (for the extra coloured row)
273                 if ($child_el['type'] == 'category') {
274                     $row_count++;
275                 }
276             }
278             // Print category total at the end if aggregation position is "last" (1)
279             if (!empty($category_total_item) && $aggregation_position) {
280                 $html_children = array_merge($html_children, $category_total_item);
281             }
283             // Determine if we are at the root
284             if (isset($element['object']->grade_item) && $element['object']->grade_item->is_course_item()) {
285                 $root = true;
286             }
288             $levelclass = "level$level level" . ($level % 2 ? 'odd' : 'even');
290             $courseclass = '';
291             if ($level == 1) {
292                 $courseclass = 'coursecategory';
293             }
295             $row = new html_table_row();
296             $row->id = 'grade-item-' . $eid;
297             $row->attributes['class'] = $courseclass . ' category ' . $dimmed;
298             $row->attributes['data-category'] = $eid;
299             $row->attributes['data-itemid'] = $category->get_grade_item()->id;
300             foreach ($rowclasses as $class) {
301                 $row->attributes['class'] .= ' ' . $class;
302             }
304             $headercell = new html_table_cell();
305             $headercell->header = true;
306             $headercell->scope = 'row';
307             $headercell->attributes['title'] = $object->stripped_name;
308             $headercell->attributes['class'] = 'cell column-rowspan rowspan ' . $levelclass;
309             $headercell->rowspan = $row_count + 1;
310             $row->cells[] = $headercell;
312             foreach ($this->columns as $column) {
313                 if (!($this->moving && $column->hide_when_moving)) {
314                     $row->cells[] = $column->get_category_cell($category, $levelclass, [
315                         'id' => $id,
316                         'name' => $object->name,
317                         'level' => $level,
318                         'actions' => $actions,
319                         'moveaction' => $moveaction,
320                         'eid' => $eid,
321                     ]);
322                 }
323             }
325             $returnrows[] = $row;
327             $returnrows = array_merge($returnrows, $html_children);
329             // Print a coloured row to show the end of the category across the table
330             $endcell = new html_table_cell();
331             $endcell->colspan = (19 - $level);
332             $endcell->attributes['class'] = 'emptyrow colspan ' . $levelclass;
334             $returnrows[] = new html_table_row(array($endcell));
336         } else { // Dealing with a grade item
338             $item = grade_item::fetch(array('id' => $object->id));
339             $element['type'] = 'item';
340             $element['object'] = $item;
342             $categoryitemclass = '';
343             if ($item->itemtype == 'category') {
344                 $categoryitemclass = 'categoryitem';
345             }
346             if ($item->itemtype == 'course') {
347                 $categoryitemclass = 'courseitem';
348             }
350             $dimmed = ($item->is_hidden()) ? "dimmed_text" : "";
351             $gradeitemrow = new html_table_row();
352             $gradeitemrow->id = 'grade-item-' . $eid;
353             $gradeitemrow->attributes['class'] = $categoryitemclass . ' item ' . $dimmed;
354             $gradeitemrow->attributes['data-itemid'] = $object->id;
355             foreach ($rowclasses as $class) {
356                 $gradeitemrow->attributes['class'] .= ' ' . $class;
357             }
359             foreach ($this->columns as $column) {
360                 if (!($this->moving && $column->hide_when_moving)) {
361                     $gradeitemrow->cells[] = $column->get_item_cell($item, array('id' => $id, 'name' => $object->name,
362                         'level' => $level, 'actions' => $actions, 'element' => $element, 'eid' => $eid,
363                         'moveaction' => $moveaction, 'itemtype' => $object->itemtype));
364                 }
365             }
367             $returnrows[] = $gradeitemrow;
368         }
370         return $returnrows;
372     }
374     /**
375      * Given a grade_item object, returns a labelled input if an aggregation coefficient (weight or extra credit) applies to it.
376      * @param grade_item $item
377      * @return string HTML
378      */
379     static function get_weight_input($item) {
380         global $OUTPUT;
382         if (!is_object($item) || get_class($item) !== 'grade_item') {
383             throw new Exception('grade_edit_tree::get_weight_input($item) was given a variable that is not of the required type (grade_item object)');
384             return false;
385         }
387         if ($item->is_course_item()) {
388             return '';
389         }
391         $parent_category = $item->get_parent_category();
392         $parent_category->apply_forced_settings();
393         $aggcoef = $item->get_coefstring();
395         $itemname = $item->itemname;
396         if ($item->is_category_item()) {
397             // Remember, the parent category of a category item is the category itself.
398             $itemname = $parent_category->get_name();
399         }
400         $str = '';
402         if ($aggcoef == 'aggregationcoefweight' || $aggcoef == 'aggregationcoef' || $aggcoef == 'aggregationcoefextraweight') {
403             return '<label class="accesshide" for="weight_'.$item->id.'">' .
404                 get_string('extracreditvalue', 'grades', $itemname).'</label>' .
405                 html_writer::empty_tag('input', [
406                     'type'          => 'text',
407                     'size'          => 6,
408                     'id'            => 'weight_' . $item->id,
409                     'name'          => 'weight_' . $item->id,
410                     'value'         => self::format_number($item->aggregationcoef),
411                 ]);
413         } else if ($aggcoef == 'aggregationcoefextraweightsum') {
415             $checkboxname = 'weightoverride_' . $item->id;
416             $checkboxlbl = html_writer::tag('label', get_string('overrideweightofa', 'grades', $itemname),
417                 array('for' => $checkboxname, 'class' => 'accesshide'));
418             $checkbox = html_writer::empty_tag('input', [
419                 'name'          => $checkboxname,
420                 'type'          => 'hidden',
421                 'value'         => 0,
422             ]);
424             $checkbox .= html_writer::empty_tag('input', [
425                 'name' => $checkboxname,
426                 'type' => 'checkbox',
427                 'value' => 1,
428                 'id' => $checkboxname,
429                 'class' => 'weightoverride',
430                 'checked' => ($item->weightoverride ? 'checked' : null),
431             ]);
433             $name = 'weight_' . $item->id;
434             $hiddenlabel = html_writer::tag(
435                 'label',
436                 get_string('weightofa', 'grades', $itemname),
437                 array(
438                     'class' => 'accesshide',
439                     'for' => $name
440                 )
441             );
443             $input = html_writer::empty_tag(
444                 'input',
445                 array(
446                     'type' =>   'text',
447                     'size' =>   6,
448                     'id' =>     $name,
449                     'name' =>   $name,
450                     'value' =>  grade_edit_tree::format_number($item->aggregationcoef2 * 100.0),
451                     'disabled' => ($item->weightoverride ? null : 'disabled')
452                 )
453             );
455             $str .= $checkboxlbl . $checkbox . $hiddenlabel . $input;
456         }
458         return $str;
459     }
461     // Trims trailing zeros.
462     // Used on the 'Gradebook setup' page for grade items settings like aggregation co-efficient.
463     // Grader report has its own decimal place settings so they are handled elsewhere.
464     static function format_number($number) {
465         $formatted = rtrim(format_float($number, 4),'0');
466         if (substr($formatted, -1)==get_string('decsep', 'langconfig')) { //if last char is the decimal point
467             $formatted .= '0';
468         }
469         return $formatted;
470     }
472     /**
473      * Given an element of the grade tree, returns whether it is deletable or not (only manual grade items are deletable)
474      *
475      * @param array $element
476      * @return bool
477      */
478     function element_deletable($element) {
479         global $COURSE;
481         if ($element['type'] != 'item') {
482             return true;
483         }
485         $grade_item = $element['object'];
487         if ($grade_item->itemtype != 'mod' or $grade_item->is_outcome_item() or $grade_item->gradetype == GRADE_TYPE_NONE) {
488             return true;
489         }
491         $modinfo = get_fast_modinfo($COURSE);
492         if (!isset($modinfo->instances[$grade_item->itemmodule][$grade_item->iteminstance])) {
493             // module does not exist
494             return true;
495         }
497         return false;
498     }
500     /**
501      * Given the grade tree and an array of element ids (e.g. c15, i42), and expecting the 'moveafter' URL param,
502      * moves the selected items to the requested location. Then redirects the user to the given $returnurl
503      *
504      * @param object $gtree The grade tree (a recursive representation of the grade categories and grade items)
505      * @param array $eids
506      * @param string $returnurl
507      */
508     function move_elements($eids, $returnurl) {
509         $moveafter = required_param('moveafter', PARAM_INT);
511         if (!is_array($eids)) {
512             $eids = array($eids);
513         }
515         if(!$after_el = $this->gtree->locate_element("cg$moveafter")) {
516             print_error('invalidelementid', '', $returnurl);
517         }
519         $after = $after_el['object'];
520         $parent = $after;
521         $sortorder = $after->get_sortorder();
523         foreach ($eids as $eid) {
524             if (!$element = $this->gtree->locate_element($eid)) {
525                 print_error('invalidelementid', '', $returnurl);
526             }
527             $object = $element['object'];
529             $object->set_parent($parent->id);
530             $object->move_after_sortorder($sortorder);
531             $sortorder++;
532         }
534         redirect($returnurl, '', 0);
535     }
537     /**
538      * Recurses through the entire grade tree to find and return the maximum depth of the tree.
539      * This should be run only once from the root element (course category), and is used for the
540      * indentation of the Name column's cells (colspan)
541      *
542      * @param array $element An array of values representing a grade tree's element (all grade items in this case)
543      * @param int $level The level of the current recursion
544      * @param int $deepest_level A value passed to each subsequent level of recursion and incremented if $level > $deepest_level
545      * @return int Deepest level
546      */
547     function get_deepest_level($element, $level=0, $deepest_level=1) {
548         $object = $element['object'];
550         $level++;
551         $coefstring = $element['object']->get_coefstring();
552         if ($element['type'] == 'category') {
553             if ($coefstring == 'aggregationcoefweight' || $coefstring == 'aggregationcoefextraweightsum' ||
554                     $coefstring == 'aggregationcoefextraweight') {
555                 $this->uses_weight = true;
556             }
558             foreach($element['children'] as $child_el) {
559                 if ($level > $deepest_level) {
560                     $deepest_level = $level;
561                 }
562                 $deepest_level = $this->get_deepest_level($child_el, $level, $deepest_level);
563             }
565             $category = grade_category::fetch(array('id' => $object->id));
566             $item = $category->get_grade_item();
567             if ($item->gradetype == GRADE_TYPE_NONE) {
568                 // Add 1 more level for grade category that has no total.
569                 $deepest_level++;
570             }
571         }
573         return $deepest_level;
574     }
577 /**
578  * Class grade_edit_tree_column
579  *
580  * @package   core_grades
581  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
582  */
583 abstract class grade_edit_tree_column {
584     public $forced;
585     public $hidden;
586     public $forced_hidden;
587     public $advanced_hidden;
588     public $hide_when_moving = true;
589     /**
590      * html_table_cell object used as a template for header cells in all categories.
591      * It must be cloned before being used.
592      * @var html_table_cell $headercell
593      */
594     public $headercell;
595     /**
596      * html_table_cell object used as a template for category cells in all categories.
597      * It must be cloned before being used.
598      * @var html_table_cell $categorycell
599      */
600     public $categorycell;
601     /**
602      * html_table_cell object used as a template for item cells in all categories.
603      * It must be cloned before being used.
604      * @var html_table_cell $itemcell
605      */
606     public $itemcell;
608     public static function factory($name, $params=array()) {
609         $class_name = "grade_edit_tree_column_$name";
610         if (class_exists($class_name)) {
611             return new $class_name($params);
612         }
613     }
615     public abstract function get_header_cell();
617     public function get_category_cell($category, $levelclass, $params) {
618         $cell = clone($this->categorycell);
619         $cell->attributes['class'] .= ' ' . $levelclass;
620         $cell->attributes['text'] = '';
621         return $cell;
622     }
624     public function get_item_cell($item, $params) {
625         $cell = clone($this->itemcell);
626         $cell->attributes['text'] = '';
627         if (isset($params['level'])) {
628             $level = $params['level'] + (($item->itemtype == 'category' || $item->itemtype == 'course') ? 0 : 1);
629             $cell->attributes['class'] .= ' level' . $level;
630             $cell->attributes['class'] .= ' level' . ($level % 2 ? 'odd' : 'even');
631         }
632         return $cell;
633     }
635     public function __construct() {
636         $this->headercell = new html_table_cell();
637         $this->headercell->header = true;
638         $this->headercell->attributes['class'] = 'header';
640         $this->categorycell = new html_table_cell();
641         $this->categorycell->attributes['class']  = 'cell';
643         $this->itemcell = new html_table_cell();
644         $this->itemcell->attributes['class'] = 'cell';
646         if (preg_match('/^grade_edit_tree_column_(\w*)$/', get_class($this), $matches)) {
647             $this->headercell->attributes['class'] .= ' column-' . $matches[1];
648             $this->categorycell->attributes['class'] .= ' column-' . $matches[1];
649             $this->itemcell->attributes['class'] .= ' column-' . $matches[1];
650         }
651     }
654 /**
655  * Class grade_edit_tree_column_name
656  *
657  * @package   core_grades
658  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
659  */
660 class grade_edit_tree_column_name extends grade_edit_tree_column {
661     public $forced = false;
662     public $hidden = false;
663     public $forced_hidden = false;
664     public $advanced_hidden = false;
665     public $deepest_level = 1;
666     public $hide_when_moving = false;
668     public function __construct($params) {
669         if (empty($params['deepest_level'])) {
670             throw new Exception('Tried to instantiate a grade_edit_tree_column_name object without the "deepest_level" param!');
671         }
673         $this->deepest_level = $params['deepest_level'];
674         parent::__construct();
675     }
677     public function get_header_cell() {
678         $headercell = clone($this->headercell);
679         $headercell->colspan = $this->deepest_level + 1;
680         $headercell->text = get_string('name');
681         return $headercell;
682     }
684     public function get_category_cell($category, $levelclass, $params) {
685         global $OUTPUT;
686         if (empty($params['name']) || empty($params['level'])) {
687             throw new Exception('Array key (name or level) missing from 3rd param of grade_edit_tree_column_name::get_category_cell($category, $levelclass, $params)');
688         }
689         $moveaction = isset($params['moveaction']) ? $params['moveaction'] : '';
690         $categorycell = parent::get_category_cell($category, $levelclass, $params);
691         $categorycell->colspan = ($this->deepest_level +1) - $params['level'];
692         $categorycell->text = $OUTPUT->heading($moveaction . $params['name'], 4);
693         return $categorycell;
694     }
696     public function get_item_cell($item, $params) {
697         global $CFG;
699         if (empty($params['element']) || empty($params['name']) || empty($params['level'])) {
700             throw new Exception('Array key (name, level or element) missing from 2nd param of grade_edit_tree_column_name::get_item_cell($item, $params)');
701         }
703         $name = $params['name'];
704         $moveaction = isset($params['moveaction']) ? $params['moveaction'] : '';
706         $itemcell = parent::get_item_cell($item, $params);
707         $itemcell->colspan = ($this->deepest_level + 1) - $params['level'];
708         $itemcell->text = $moveaction . $name;
709         return $itemcell;
710     }
713 /**
714  * Class grade_edit_tree_column_weight
715  *
716  * @package   core_grades
717  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
718  */
719 class grade_edit_tree_column_weight extends grade_edit_tree_column {
721     public function get_header_cell() {
722         global $OUTPUT;
723         $headercell = clone($this->headercell);
724         $headercell->text = get_string('weights', 'grades').$OUTPUT->help_icon('aggregationcoefweight', 'grades');
725         return $headercell;
726     }
728     public function get_category_cell($category, $levelclass, $params) {
730         $item = $category->get_grade_item();
731         $categorycell = parent::get_category_cell($category, $levelclass, $params);
732         $categorycell->text = grade_edit_tree::get_weight_input($item);
733         return $categorycell;
734     }
736     public function get_item_cell($item, $params) {
737         global $CFG;
738         if (empty($params['element'])) {
739             throw new Exception('Array key (element) missing from 2nd param of grade_edit_tree_column_weightorextracredit::get_item_cell($item, $params)');
740         }
741         $itemcell = parent::get_item_cell($item, $params);
742         $itemcell->text = '&nbsp;';
743         $object = $params['element']['object'];
745         if (!in_array($object->itemtype, array('courseitem', 'categoryitem', 'category'))
746                 && !in_array($object->gradetype, array(GRADE_TYPE_NONE, GRADE_TYPE_TEXT))
747                 && (!$object->is_outcome_item() || $object->load_parent_category()->aggregateoutcomes)
748                 && ($object->gradetype != GRADE_TYPE_SCALE || !empty($CFG->grade_includescalesinaggregation))) {
749             $itemcell->text = grade_edit_tree::get_weight_input($item);
750         }
752         return $itemcell;
753     }
756 /**
757  * Class grade_edit_tree_column_range
758  *
759  * @package   core_grades
760  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
761  */
762 class grade_edit_tree_column_range extends grade_edit_tree_column {
764     public function get_header_cell() {
765         $headercell = clone($this->headercell);
766         $headercell->text = get_string('maxgrade', 'grades');
767         return $headercell;
768     }
770     public function get_category_cell($category, $levelclass, $params) {
771         $categorycell = parent::get_category_cell($category, $levelclass, $params);
772         $categorycell->text = ' - ';
773         return $categorycell;
774     }
776     public function get_item_cell($item, $params) {
777         global $DB, $OUTPUT;
779         // If the parent aggregation is Natural, we should show the number, even for scales, as that value is used...
780         // ...in the computation. For text grades, the grademax is not used, so we can still show the no value string.
781         $parentcat = $item->get_parent_category();
782         if ($item->gradetype == GRADE_TYPE_TEXT) {
783             $grademax = ' - ';
784         } else if ($item->gradetype == GRADE_TYPE_SCALE) {
785             $scale = $DB->get_record('scale', array('id' => $item->scaleid));
786             $scale_items = null;
787             if (empty($scale)) { //if the item is using a scale that's been removed
788                 $scale_items = array();
789             } else {
790                 $scale_items = explode(',', $scale->scale);
791             }
792             if ($parentcat->aggregation == GRADE_AGGREGATE_SUM) {
793                 $grademax = end($scale_items) . ' (' .
794                         format_float($item->grademax, $item->get_decimals()) . ')';
795             } else {
796                 $grademax = end($scale_items) . ' (' . count($scale_items) . ')';
797             }
798         } else {
799             $grademax = format_float($item->grademax, $item->get_decimals());
800         }
802         $isextracredit = false;
803         if ($item->aggregationcoef > 0) {
804             // For category grade items, we need the grandparent category.
805             // The parent is just category the grade item represents.
806             if ($item->is_category_item()) {
807                 $grandparentcat = $parentcat->get_parent_category();
808                 if ($grandparentcat->is_extracredit_used()) {
809                     $isextracredit = true;
810                 }
811             } else if ($parentcat->is_extracredit_used()) {
812                 $isextracredit = true;
813             }
814         }
815         if ($isextracredit) {
816             $grademax .= ' ' . html_writer::tag('abbr', get_string('aggregationcoefextrasumabbr', 'grades'),
817                 array('title' => get_string('aggregationcoefextrasum', 'grades')));
818         }
820         $itemcell = parent::get_item_cell($item, $params);
821         $itemcell->text = $grademax;
822         return $itemcell;
823     }
826 /**
827  * Class grade_edit_tree_column_actions
828  *
829  * @package   core_grades
830  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
831  */
832 class grade_edit_tree_column_actions extends grade_edit_tree_column {
834     public function __construct($params) {
835         parent::__construct();
836     }
838     public function get_header_cell() {
839         $headercell = clone($this->headercell);
840         $headercell->text = get_string('actions');
841         return $headercell;
842     }
844     public function get_category_cell($category, $levelclass, $params) {
846         if (empty($params['actions'])) {
847             throw new Exception('Array key (actions) missing from 3rd param of grade_edit_tree_column_actions::get_category_actions($category, $levelclass, $params)');
848         }
850         $categorycell = parent::get_category_cell($category, $levelclass, $params);
851         $categorycell->text = $params['actions'];
852         return $categorycell;
853     }
855     public function get_item_cell($item, $params) {
856         if (empty($params['actions'])) {
857             throw new Exception('Array key (actions) missing from 2nd param of grade_edit_tree_column_actions::get_item_cell($item, $params)');
858         }
859         $itemcell = parent::get_item_cell($item, $params);
860         $itemcell->text = $params['actions'];
861         return $itemcell;
862     }
865 /**
866  * Class grade_edit_tree_column_select
867  *
868  * @package   core_grades
869  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
870  */
871 class grade_edit_tree_column_select extends grade_edit_tree_column {
873     public function get_header_cell() {
874         $headercell = clone($this->headercell);
875         $headercell->text = get_string('select');
876         return $headercell;
877     }
879     public function get_category_cell($category, $levelclass, $params) {
880         if (empty($params['eid'])) {
881             throw new Exception('Array key (eid) missing from 3rd param of grade_edit_tree_column_select::get_category_cell($category, $levelclass, $params)');
882         }
883         $selectall = html_writer::link('#', get_string('all'), [
884             'data-action' => 'grade_edittree-index-bulkselect',
885             'data-checked' => true,
886         ]);
887         $selectnone = html_writer::link('#', get_string('none'), [
888             'data-action' => 'grade_edittree-index-bulkselect',
889             'data-checked' => false,
890         ]);
892         $categorycell = parent::get_category_cell($category, $levelclass, $params);
893         $categorycell->text = $selectall . ' / ' . $selectnone;
894         return $categorycell;
895     }
897     public function get_item_cell($item, $params) {
898         if (empty($params['itemtype']) || empty($params['eid'])) {
899             print_error('missingitemtypeoreid', 'core_grades');
900         }
901         $itemcell = parent::get_item_cell($item, $params);
903         if ($params['itemtype'] != 'course' && $params['itemtype'] != 'category') {
904             $itemcell->text = '<label class="accesshide" for="select_'.$params['eid'].'">'.
905                 get_string('select', 'grades', $item->itemname).'</label>
906                 <input class="itemselect ignoredirty" type="checkbox" name="select_'.$params['eid'].'" id="select_'.$params['eid'].
907                 '"/>';
908         }
909         return $itemcell;
910     }