grade/report/singleview/classes/local/screen/user.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/>.
  16
  17 /**
  18  * The user screen.
  19  *
  20  * @package   gradereport_singleview
  21  * @copyright 2014 Moodle Pty Ltd (http://moodle.com)
  22  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23  */
  24
  25 namespace gradereport_singleview\local\screen;
  26
  27 use grade_seq;
  28 use gradereport_singleview;
  29 use moodle_url;
  30 use pix_icon;
  31 use html_writer;
  32 use gradereport_singleview\local\ui\range;
  33 use gradereport_singleview\local\ui\bulk_insert;
  34 use grade_item;
  35 use grade_grade;
  36 use stdClass;
  37
  38 defined('MOODLE_INTERNAL') || die;
  39
  40 /**
  41  * The user screen.
  42  *
  43  * @package   gradereport_singleview
  44  * @copyright 2014 Moodle Pty Ltd (http://moodle.com)
  45  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  46  */
  47 class user extends tablelike implements selectable_items {
  48
  49     /** @var array $categories A cache for grade_item categories */
  50     private $categories = array();
  51
  52     /** @var int $requirespaging Do we have more items than the paging limit? */
  53     private $requirespaging = true;
  54
  55     /**
  56      * Get the description for the screen.
  57      *
  58      * @return string
  59      */
  60     public function description() {
  61         return get_string('gradeitems', 'grades');
  62     }
  63
  64     /**
  65      * Convert the list of items to a list of options.
  66      *
  67      * @return array
  68      */
  69     public function options() {
  70         $result = array();
  71         foreach ($this->items as $itemid => $item) {
  72             $result[$itemid] = $item->get_name();
  73         }
  74         return $result;
  75     }
  76
  77     /**
  78      * Get the type of items on this screen.
  79      *
  80      * @return string
  81      */
  82     public function item_type() {
  83         return 'grade';
  84     }
  85
  86     /**
  87      * Should we show the group selector on this screen?
  88      *
  89      * @return bool
  90      */
  91     public function display_group_selector() {
  92         return false;
  93     }
  94
  95     /**
  96      * Init the screen
  97      *
  98      * @param bool $selfitemisempty Have we selected an item yet?
  99      */
 100     public function init($selfitemisempty = false) {
 101         global $DB;
 102
 103         if (!$selfitemisempty) {
 104             $this->item = $DB->get_record('user', array('id' => $this->itemid));
 105         }
 106
 107         $params = array('courseid' => $this->courseid);
 108
 109         $seq = new grade_seq($this->courseid, true);
 110         foreach ($seq->items as $key => $item) {
 111             if (isset($item->itemmodule)) {
 112                 list($courseid, $cmid) = get_course_and_cm_from_instance($item->iteminstance, $item->itemmodule);
 113                 $seq->items[$key]->cmid = $cmid->id;
 114             }
 115         }
 116
 117         $this->items = array();
 118         foreach ($seq->items as $itemid => $item) {
 119             if (grade::filter($item)) {
 120                 $this->items[$itemid] = $item;
 121             }
 122         }
 123
 124         $this->requirespaging = count($this->items) > $this->perpage;
 125
 126         $this->setup_structure();
 127
 128         $this->definition = array(
 129             'finalgrade', 'feedback', 'override', 'exclude'
 130         );
 131         $this->set_headers($this->original_headers());
 132     }
 133
 134     /**
 135      * Get the list of headers for the table.
 136      *
 137      * @return array List of headers
 138      */
 139     public function original_headers() {
 140         return array(
 141             '', // For filter icon.
 142             get_string('assessmentname', 'gradereport_singleview'),
 143             get_string('gradecategory', 'grades'),
 144             get_string('range', 'grades'),
 145             get_string('grade', 'grades'),
 146             get_string('feedback', 'grades'),
 147             $this->make_toggle_links('override'),
 148             $this->make_toggle_links('exclude')
 149         );
 150     }
 151
 152     /**
 153      * Format each row of the table.
 154      *
 155      * @param grade_item $item
 156      * @return string
 157      */
 158     public function format_line($item) {
 159         global $OUTPUT;
 160
 161         $grade = $this->fetch_grade_or_default($item, $this->item->id);
 162         $lockicon = '';
 163
 164         $lockeditem = $lockeditemgrade = 0;
 165         if (!empty($grade->locked)) {
 166             $lockeditem = 1;
 167         }
 168         if (!empty($grade->grade_item->locked)) {
 169             $lockeditemgrade = 1;
 170         }
 171         // Check both grade and grade item.
 172         if ($lockeditem || $lockeditemgrade) {
 173              $lockicon = $OUTPUT->pix_icon('t/locked', 'grade is locked');
 174         }
 175
 176         $realmodid = '';
 177         if (isset($item->cmid)) {
 178             $realmodid = $item->cmid;
 179         }
 180
 181         $iconstring = get_string('filtergrades', 'gradereport_singleview', $item->get_name());
 182
 183         // Create a fake gradetreeitem so we can call get_element_header().
 184         // The type logic below is from grade_category->_get_children_recursion().
 185         $gradetreeitem = array();
 186         if (in_array($item->itemtype, array('course', 'category'))) {
 187             $gradetreeitem['type'] = $item->itemtype.'item';
 188         } else {
 189             $gradetreeitem['type'] = 'item';
 190         }
 191         $gradetreeitem['object'] = $item;
 192         $gradetreeitem['userid'] = $this->item->id;
 193
 194         $itemlabel = $this->structure->get_element_header($gradetreeitem, true, false, false, false, true);
 195         $grade->label = $item->get_name();
 196
 197         $line = array(
 198             $OUTPUT->action_icon($this->format_link('grade', $item->id), new pix_icon('t/editstring', $iconstring)),
 199             $this->format_icon($item) . $lockicon . $itemlabel,
 200             $this->category($item),
 201             new range($item)
 202         );
 203         $lineclasses = array(
 204             "action",
 205             "gradeitem",
 206             "category",
 207             "range"
 208         );
 209
 210         $outputline = array();
 211         $i = 0;
 212         foreach ($line as $key => $value) {
 213             $cell = new \html_table_cell($value);
 214             if ($isheader = $i == 1) {
 215                 $cell->header = $isheader;
 216                 $cell->scope = "row";
 217             }
 218             if (array_key_exists($key, $lineclasses)) {
 219                 $cell->attributes['class'] = $lineclasses[$key];
 220             }
 221             $outputline[] = $cell;
 222             $i++;
 223         }
 224
 225         return $this->format_definition($outputline, $grade);
 226     }
 227
 228     /**
 229      * Helper to get the icon for an item.
 230      *
 231      * @param grade_item $item
 232      * @return string
 233      */
 234     private function format_icon($item) {
 235         $element = array('type' => 'item', 'object' => $item);
 236         return $this->structure->get_element_icon($element);
 237     }
 238
 239     /**
 240      * Helper to get the category for an item.
 241      *
 242      * @param grade_item $item
 243      * @return grade_category
 244      */
 245     private function category($item) {
 246         global $DB;
 247
 248         if (empty($item->categoryid)) {
 249
 250             if ($item->itemtype == 'course') {
 251                 return $this->course->fullname;
 252             }
 253
 254             $params = array('id' => $item->iteminstance);
 255             $elem = $DB->get_record('grade_categories', $params);
 256
 257             return $elem->fullname;
 258         }
 259
 260         if (!isset($this->categories[$item->categoryid])) {
 261             $category = $item->get_parent_category();
 262
 263             $this->categories[$category->id] = $category;
 264         }
 265
 266         return $this->categories[$item->categoryid]->get_name();
 267     }
 268
 269     /**
 270      * Get the heading for the page.
 271      *
 272      * @return string
 273      */
 274     public function heading() {
 275         return fullname($this->item);
 276     }
 277
 278     /**
 279      * Get the summary for this table.
 280      *
 281      * @return string
 282      */
 283     public function summary() {
 284         return get_string('summaryuser', 'gradereport_singleview');
 285     }
 286
 287     /**
 288      * Default pager
 289      *
 290      * @return string
 291      */
 292     public function pager() {
 293         global $OUTPUT;
 294
 295         if (!$this->supports_paging()) {
 296             return '';
 297         }
 298
 299         return $OUTPUT->paging_bar(
 300             count($this->items), $this->page, $this->perpage,
 301             new moodle_url('/grade/report/singleview/index.php', array(
 302                 'perpage' => $this->perpage,
 303                 'id' => $this->courseid,
 304                 'groupid' => $this->groupid,
 305                 'itemid' => $this->itemid,
 306                 'item' => 'user'
 307             ))
 308         );
 309     }
 310
 311     /**
 312      * Does this page require paging?
 313      *
 314      * @return bool
 315      */
 316     public function supports_paging() {
 317         return $this->requirespaging;
 318     }
 319
 320
 321     /**
 322      * Process the data from the form.
 323      *
 324      * @param array $data
 325      * @return array of warnings
 326      */
 327     public function process($data) {
 328         $bulk = new bulk_insert($this->item);
 329         // Bulk insert messages the data to be passed in
 330         // ie: for all grades of empty grades apply the specified value.
 331         if ($bulk->is_applied($data)) {
 332             $filter = $bulk->get_type($data);
 333             $insertvalue = $bulk->get_insert_value($data);
 334             // Appropriately massage data that may not exist.
 335
 336             $userid = $this->item->id;
 337             foreach ($this->items as $gradeitemid => $gradeitem) {
 338                 $null = $gradeitem->gradetype == GRADE_TYPE_SCALE ? -1 : '';
 339                 $field = "finalgrade_{$gradeitem->id}_{$gradeitemid}";
 340                 if (isset($data->$field)) {
 341                     continue;
 342                 }
 343
 344                 $grade = grade_grade::fetch(array(
 345                     'itemid' => $gradeitem->id,
 346                     'userid' => $userid
 347                 ));
 348
 349                 $data->$field = empty($grade) ? $null : $grade->finalgrade;
 350                 $data->{"old$field"} = $data->$field;
 351             }
 352
 353             foreach ($data as $varname => $value) {
 354                 if (!preg_match('/^finalgrade_(\d+)_/', $varname, $matches)) {
 355                     continue;
 356                 }
 357
 358                 $gradeitem = grade_item::fetch(array(
 359                     'courseid' => $this->courseid,
 360                     'id' => $matches[1]
 361                 ));
 362
 363                 $isscale = ($gradeitem->gradetype == GRADE_TYPE_SCALE);
 364
 365                 $empties = (trim($value) === '' or ($isscale and $value == -1));
 366
 367                 if ($filter == 'all' or $empties) {
 368                     $data->$varname = ($isscale and empty($insertvalue)) ?
 369                         -1 : $insertvalue;
 370                 }
 371             }
 372         }
 373
 374         return parent::process($data);
 375     }
 376 }