[Summary view] [Print] [Text view]

   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 label for the select box that chooses items for this page.
  57       * @return string
  58       */
  59      public function select_label() {
  60          return get_string('selectgrade', 'gradereport_singleview');
  61      }
  62  
  63      /**
  64       * Get the description for the screen.
  65       *
  66       * @return string
  67       */
  68      public function description() {
  69          return get_string('gradeitems', 'grades');
  70      }
  71  
  72      /**
  73       * Convert the list of items to a list of options.
  74       *
  75       * @return array
  76       */
  77      public function options() {
  78          $result = array();
  79          foreach ($this->items as $itemid => $item) {
  80              $result[$itemid] = $item->get_name();
  81          }
  82          return $result;
  83      }
  84  
  85      /**
  86       * Get the type of items on this screen.
  87       *
  88       * @return string
  89       */
  90      public function item_type() {
  91          return 'grade';
  92      }
  93  
  94      /**
  95       * Init the screen
  96       *
  97       * @param bool $selfitemisempty Have we selected an item yet?
  98       */
  99      public function init($selfitemisempty = false) {
 100          global $DB;
 101  
 102          if (!$selfitemisempty) {
 103              $validusers = $this->load_users();
 104              if (!isset($validusers[$this->itemid])) {
 105                  // If the passed user id is not valid, show the first user from the list instead.
 106                  $this->item = reset($validusers);
 107                  $this->itemid = $this->item->id;
 108              } else {
 109                  $this->item = $validusers[$this->itemid];
 110              }
 111          }
 112  
 113          $params = array('courseid' => $this->courseid);
 114  
 115          $seq = new grade_seq($this->courseid, true);
 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          $iconstring = get_string('filtergrades', 'gradereport_singleview', $item->get_name());
 177  
 178          // Create a fake gradetreeitem so we can call get_element_header().
 179          // The type logic below is from grade_category->_get_children_recursion().
 180          $gradetreeitem = array();
 181          if (in_array($item->itemtype, array('course', 'category'))) {
 182              $gradetreeitem['type'] = $item->itemtype.'item';
 183          } else {
 184              $gradetreeitem['type'] = 'item';
 185          }
 186          $gradetreeitem['object'] = $item;
 187          $gradetreeitem['userid'] = $this->item->id;
 188  
 189          $itemlabel = $this->structure->get_element_header($gradetreeitem, true, false, false, false, true);
 190          $grade->label = $item->get_name();
 191  
 192          $line = array(
 193              $OUTPUT->action_icon($this->format_link('grade', $item->id), new pix_icon('t/editstring', $iconstring)),
 194              $this->format_icon($item) . $lockicon . $itemlabel,
 195              $this->category($item),
 196              new range($item)
 197          );
 198          $lineclasses = array(
 199              "action",
 200              "gradeitem",
 201              "category",
 202              "range"
 203          );
 204  
 205          $outputline = array();
 206          $i = 0;
 207          foreach ($line as $key => $value) {
 208              $cell = new \html_table_cell($value);
 209              if ($isheader = $i == 1) {
 210                  $cell->header = $isheader;
 211                  $cell->scope = "row";
 212              }
 213              if (array_key_exists($key, $lineclasses)) {
 214                  $cell->attributes['class'] = $lineclasses[$key];
 215              }
 216              $outputline[] = $cell;
 217              $i++;
 218          }
 219  
 220          return $this->format_definition($outputline, $grade);
 221      }
 222  
 223      /**
 224       * Helper to get the icon for an item.
 225       *
 226       * @param grade_item $item
 227       * @return string
 228       */
 229      private function format_icon($item) {
 230          $element = array('type' => 'item', 'object' => $item);
 231          return $this->structure->get_element_icon($element);
 232      }
 233  
 234      /**
 235       * Helper to get the category for an item.
 236       *
 237       * @param grade_item $item
 238       * @return grade_category
 239       */
 240      private function category($item) {
 241          global $DB;
 242  
 243          if (empty($item->categoryid)) {
 244  
 245              if ($item->itemtype == 'course') {
 246                  return $this->course->fullname;
 247              }
 248  
 249              $params = array('id' => $item->iteminstance);
 250              $elem = $DB->get_record('grade_categories', $params);
 251  
 252              return $elem->fullname;
 253          }
 254  
 255          if (!isset($this->categories[$item->categoryid])) {
 256              $category = $item->get_parent_category();
 257  
 258              $this->categories[$category->id] = $category;
 259          }
 260  
 261          return $this->categories[$item->categoryid]->get_name();
 262      }
 263  
 264      /**
 265       * Get the heading for the page.
 266       *
 267       * @return string
 268       */
 269      public function heading() {
 270          return get_string('gradeuser', 'gradereport_singleview', fullname($this->item));
 271      }
 272  
 273      /**
 274       * Get the summary for this table.
 275       *
 276       * @return string
 277       */
 278      public function summary() {
 279          return get_string('summaryuser', 'gradereport_singleview');
 280      }
 281  
 282      /**
 283       * Default pager
 284       *
 285       * @return string
 286       */
 287      public function pager() {
 288          global $OUTPUT;
 289  
 290          if (!$this->supports_paging()) {
 291              return '';
 292          }
 293  
 294          return $OUTPUT->paging_bar(
 295              count($this->items), $this->page, $this->perpage,
 296              new moodle_url('/grade/report/singleview/index.php', array(
 297                  'perpage' => $this->perpage,
 298                  'id' => $this->courseid,
 299                  'group' => $this->groupid,
 300                  'itemid' => $this->itemid,
 301                  'item' => 'user'
 302              ))
 303          );
 304      }
 305  
 306      /**
 307       * Does this page require paging?
 308       *
 309       * @return bool
 310       */
 311      public function supports_paging() {
 312          return $this->requirespaging;
 313      }
 314  
 315  
 316      /**
 317       * Process the data from the form.
 318       *
 319       * @param array $data
 320       * @return array of warnings
 321       */
 322      public function process($data) {
 323          $bulk = new bulk_insert($this->item);
 324          // Bulk insert messages the data to be passed in
 325          // ie: for all grades of empty grades apply the specified value.
 326          if ($bulk->is_applied($data)) {
 327              $filter = $bulk->get_type($data);
 328              $insertvalue = $bulk->get_insert_value($data);
 329  
 330              $userid = $this->item->id;
 331              foreach ($this->items as $gradeitemid => $gradeitem) {
 332                  $null = $gradeitem->gradetype == GRADE_TYPE_SCALE ? -1 : '';
 333                  $field = "finalgrade_{$gradeitem->id}_{$this->itemid}";
 334                  if (isset($data->$field)) {
 335                      continue;
 336                  }
 337  
 338                  $oldfinalgradefield = "oldfinalgrade_{$gradeitem->id}_{$this->itemid}";
 339                  // Bulk grade changes for all grades need to be processed and shouldn't be skipped if they had a previous grade.
 340                  if ($gradeitem->is_course_item() || ($filter != 'all' && !empty($data->$oldfinalgradefield))) {
 341                      if ($gradeitem->is_course_item()) {
 342                          // The course total should not be overridden.
 343                          unset($data->$field);
 344                          unset($data->oldfinalgradefield);
 345                          $oldoverride = "oldoverride_{$gradeitem->id}_{$this->itemid}";
 346                          unset($data->$oldoverride);
 347                          $oldfeedback = "oldfeedback_{$gradeitem->id}_{$this->itemid}";
 348                          unset($data->$oldfeedback);
 349                      }
 350                      continue;
 351                  }
 352                  $grade = grade_grade::fetch(array(
 353                      'itemid' => $gradeitemid,
 354                      'userid' => $userid
 355                  ));
 356  
 357                  $data->$field = empty($grade) ? $null : $grade->finalgrade;
 358                  $data->{"old$field"} = $data->$field;
 359              }
 360  
 361              foreach ($data as $varname => $value) {
 362                  if (preg_match('/^oldoverride_(\d+)_(\d+)/', $varname, $matches)) {
 363                      // If we've selected overriding all grades.
 364                      if ($filter == 'all') {
 365                          $override = "override_{$matches[1]}_{$matches[2]}";
 366                          $data->$override = '1';
 367                      }
 368                  }
 369                  if (!preg_match('/^finalgrade_(\d+)_(\d+)/', $varname, $matches)) {
 370                      continue;
 371                  }
 372  
 373                  $gradeitem = grade_item::fetch(array(
 374                      'courseid' => $this->courseid,
 375                      'id' => $matches[1]
 376                  ));
 377  
 378                  $isscale = ($gradeitem->gradetype == GRADE_TYPE_SCALE);
 379  
 380                  $empties = (trim($value) === '' or ($isscale and $value == -1));
 381  
 382                  if ($filter == 'all' or $empties) {
 383                      $data->$varname = ($isscale and empty($insertvalue)) ?
 384                          -1 : $insertvalue;
 385                  }
 386              }
 387          }
 388          return parent::process($data);
 389      }
 390  }