[Summary view]

Differences Between: [Versions 310 and 311] [Versions 311 and 400] [Versions 311 and 401] [Versions 311 and 402] [Versions 311 and 403] [Versions 39 and 311]

   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   * This file contains the User Filter API.
  19   *
  20   * @package   core_user
  21   * @category  user
  22   * @copyright 1999 Martin Dougiamas  http://dougiamas.com
  23   * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  24   */
  25  
  26  require_once($CFG->dirroot.'/user/filters/text.php');
  27  require_once($CFG->dirroot.'/user/filters/date.php');
  28  require_once($CFG->dirroot.'/user/filters/select.php');
  29  require_once($CFG->dirroot.'/user/filters/simpleselect.php');
  30  require_once($CFG->dirroot.'/user/filters/courserole.php');
  31  require_once($CFG->dirroot.'/user/filters/globalrole.php');
  32  require_once($CFG->dirroot.'/user/filters/profilefield.php');
  33  require_once($CFG->dirroot.'/user/filters/yesno.php');
  34  require_once($CFG->dirroot.'/user/filters/anycourses.php');
  35  require_once($CFG->dirroot.'/user/filters/cohort.php');
  36  require_once($CFG->dirroot.'/user/filters/user_filter_forms.php');
  37  require_once($CFG->dirroot.'/user/filters/checkbox.php');
  38  
  39  /**
  40   * User filtering wrapper class.
  41   *
  42   * @copyright 1999 Martin Dougiamas  http://dougiamas.com
  43   * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  44   */
  45  class user_filtering {
  46      /** @var array */
  47      public $_fields;
  48      /** @var \user_add_filter_form */
  49      public $_addform;
  50      /** @var \user_active_filter_form */
  51      public $_activeform;
  52  
  53      /**
  54       * Contructor
  55       * @param array $fieldnames array of visible user fields
  56       * @param string $baseurl base url used for submission/return, null if the same of current page
  57       * @param array $extraparams extra page parameters
  58       */
  59      public function __construct($fieldnames = null, $baseurl = null, $extraparams = null) {
  60          global $SESSION;
  61  
  62          if (!isset($SESSION->user_filtering)) {
  63              $SESSION->user_filtering = array();
  64          }
  65  
  66          if (empty($fieldnames)) {
  67              // As a start, add all fields as advanced fields (which are only available after clicking on "Show more").
  68              $fieldnames = array('realname' => 1, 'lastname' => 1, 'firstname' => 1, 'username' => 1, 'email' => 1, 'city' => 1,
  69                                  'country' => 1, 'confirmed' => 1, 'suspended' => 1, 'profile' => 1, 'courserole' => 1,
  70                                  'anycourses' => 1, 'systemrole' => 1, 'cohort' => 1, 'firstaccess' => 1, 'lastaccess' => 1,
  71                                  'neveraccessed' => 1, 'timemodified' => 1, 'nevermodified' => 1, 'auth' => 1, 'mnethostid' => 1,
  72                                  'idnumber' => 1, 'institution' => 1, 'department' => 1, 'lastip' => 1);
  73  
  74              // Get the config which filters the admin wanted to show by default.
  75              $userfiltersdefault = get_config('core', 'userfiltersdefault');
  76  
  77              // If the admin did not enable any filter, the form will not make much sense if all fields are hidden behind
  78              // "Show more". Thus, we enable the 'realname' filter automatically.
  79              if ($userfiltersdefault == '') {
  80                  $userfiltersdefault = array('realname');
  81  
  82                  // Otherwise, we split the enabled filters into an array.
  83              } else {
  84                  $userfiltersdefault = explode(',', $userfiltersdefault);
  85              }
  86  
  87              // Show these fields by default which the admin has enabled in the config.
  88              foreach ($userfiltersdefault as $key) {
  89                  $fieldnames[$key] = 0;
  90              }
  91          }
  92  
  93          $this->_fields  = array();
  94  
  95          foreach ($fieldnames as $fieldname => $advanced) {
  96              if ($field = $this->get_field($fieldname, $advanced)) {
  97                  $this->_fields[$fieldname] = $field;
  98              }
  99          }
 100  
 101          // Fist the new filter form.
 102          $this->_addform = new user_add_filter_form($baseurl, array('fields' => $this->_fields, 'extraparams' => $extraparams));
 103          if ($adddata = $this->_addform->get_data()) {
 104              // Clear previous filters.
 105              if (!empty($adddata->replacefilters)) {
 106                  $SESSION->user_filtering = [];
 107              }
 108  
 109              // Add new filters.
 110              foreach ($this->_fields as $fname => $field) {
 111                  $data = $field->check_data($adddata);
 112                  if ($data === false) {
 113                      continue; // Nothing new.
 114                  }
 115                  if (!array_key_exists($fname, $SESSION->user_filtering)) {
 116                      $SESSION->user_filtering[$fname] = array();
 117                  }
 118                  $SESSION->user_filtering[$fname][] = $data;
 119              }
 120          }
 121  
 122          // Now the active filters.
 123          $this->_activeform = new user_active_filter_form($baseurl, array('fields' => $this->_fields, 'extraparams' => $extraparams));
 124          if ($activedata = $this->_activeform->get_data()) {
 125              if (!empty($activedata->removeall)) {
 126                  $SESSION->user_filtering = array();
 127  
 128              } else if (!empty($activedata->removeselected) and !empty($activedata->filter)) {
 129                  foreach ($activedata->filter as $fname => $instances) {
 130                      foreach ($instances as $i => $val) {
 131                          if (empty($val)) {
 132                              continue;
 133                          }
 134                          unset($SESSION->user_filtering[$fname][$i]);
 135                      }
 136                      if (empty($SESSION->user_filtering[$fname])) {
 137                          unset($SESSION->user_filtering[$fname]);
 138                      }
 139                  }
 140              }
 141          }
 142  
 143          // Rebuild the forms if filters data was processed.
 144          if ($adddata || $activedata) {
 145              $_POST = []; // Reset submitted data.
 146              $this->_addform = new user_add_filter_form($baseurl, ['fields' => $this->_fields, 'extraparams' => $extraparams]);
 147              $this->_activeform = new user_active_filter_form($baseurl, ['fields' => $this->_fields, 'extraparams' => $extraparams]);
 148          }
 149      }
 150  
 151      /**
 152       * Creates known user filter if present
 153       * @param string $fieldname
 154       * @param boolean $advanced
 155       * @return object filter
 156       */
 157      public function get_field($fieldname, $advanced) {
 158          global $USER, $CFG, $DB, $SITE;
 159  
 160          switch ($fieldname) {
 161              case 'username':    return new user_filter_text('username', get_string('username'), $advanced, 'username');
 162              case 'realname':    return new user_filter_text('realname', get_string('fullnameuser'), $advanced, $DB->sql_fullname());
 163              case 'lastname':    return new user_filter_text('lastname', get_string('lastname'), $advanced, 'lastname');
 164              case 'firstname':    return new user_filter_text('firstname', get_string('firstname'), $advanced, 'firstname');
 165              case 'email':       return new user_filter_text('email', get_string('email'), $advanced, 'email');
 166              case 'city':        return new user_filter_text('city', get_string('city'), $advanced, 'city');
 167              case 'country':     return new user_filter_select('country', get_string('country'), $advanced, 'country', get_string_manager()->get_list_of_countries(), $USER->country);
 168              case 'confirmed':   return new user_filter_yesno('confirmed', get_string('confirmed', 'admin'), $advanced, 'confirmed');
 169              case 'suspended':   return new user_filter_yesno('suspended', get_string('suspended', 'auth'), $advanced, 'suspended');
 170              case 'profile':     return new user_filter_profilefield('profile', get_string('profilefields', 'admin'), $advanced);
 171              case 'courserole':  return new user_filter_courserole('courserole', get_string('courserole', 'filters'), $advanced);
 172              case 'anycourses':
 173                  return new user_filter_anycourses('anycourses', get_string('anycourses', 'filters'), $advanced, 'user_enrolments');
 174              case 'systemrole':  return new user_filter_globalrole('systemrole', get_string('globalrole', 'role'), $advanced);
 175              case 'firstaccess': return new user_filter_date('firstaccess', get_string('firstaccess', 'filters'), $advanced, 'firstaccess');
 176              case 'lastaccess':  return new user_filter_date('lastaccess', get_string('lastaccess'), $advanced, 'lastaccess');
 177              case 'neveraccessed': return new user_filter_checkbox('neveraccessed', get_string('neveraccessed', 'filters'), $advanced, 'firstaccess', array('lastaccess_sck', 'lastaccess_eck', 'firstaccess_eck', 'firstaccess_sck'));
 178              case 'timemodified': return new user_filter_date('timemodified', get_string('lastmodified'), $advanced, 'timemodified');
 179              case 'nevermodified': return new user_filter_checkbox('nevermodified', get_string('nevermodified', 'filters'), $advanced, array('timemodified', 'timecreated'), array('timemodified_sck', 'timemodified_eck'));
 180              case 'cohort':      return new user_filter_cohort($advanced);
 181              case 'idnumber':    return new user_filter_text('idnumber', get_string('idnumber'), $advanced, 'idnumber');
 182              case 'institution': return new user_filter_text('institution', get_string('institution'), $advanced, 'institution');
 183              case 'department': return new user_filter_text('department', get_string('department'), $advanced, 'department');
 184              case 'lastip':    return new user_filter_text('lastip', get_string('lastip'), $advanced, 'lastip');
 185              case 'auth':
 186                  $plugins = core_component::get_plugin_list('auth');
 187                  $choices = array();
 188                  foreach ($plugins as $auth => $unused) {
 189                      $choices[$auth] = get_string('pluginname', "auth_{$auth}");
 190                  }
 191                  return new user_filter_simpleselect('auth', get_string('authentication'), $advanced, 'auth', $choices);
 192  
 193              case 'mnethostid':
 194                  // Include all hosts even those deleted or otherwise problematic.
 195                  if (!$hosts = $DB->get_records('mnet_host', null, 'id', 'id, wwwroot, name')) {
 196                      $hosts = array();
 197                  }
 198                  $choices = array();
 199                  foreach ($hosts as $host) {
 200                      if ($host->id == $CFG->mnet_localhost_id) {
 201                          $choices[$host->id] = format_string($SITE->fullname).' ('.get_string('local').')';
 202                      } else if (empty($host->wwwroot)) {
 203                          // All hosts.
 204                          continue;
 205                      } else {
 206                          $choices[$host->id] = $host->name.' ('.$host->wwwroot.')';
 207                      }
 208                  }
 209                  if ($usedhosts = $DB->get_fieldset_sql("SELECT DISTINCT mnethostid FROM {user} WHERE deleted=0")) {
 210                      foreach ($usedhosts as $hostid) {
 211                          if (empty($hosts[$hostid])) {
 212                              $choices[$hostid] = 'id: '.$hostid.' ('.get_string('error').')';
 213                          }
 214                      }
 215                  }
 216                  if (count($choices) < 2) {
 217                      return null; // Filter not needed.
 218                  }
 219                  return new user_filter_simpleselect('mnethostid', get_string('mnetidprovider', 'mnet'), $advanced, 'mnethostid', $choices);
 220  
 221              default:
 222                  return null;
 223          }
 224      }
 225  
 226      /**
 227       * Returns sql where statement based on active user filters
 228       * @param string $extra sql
 229       * @param array $params named params (recommended prefix ex)
 230       * @return array sql string and $params
 231       */
 232      public function get_sql_filter($extra='', array $params=null) {
 233          global $SESSION;
 234  
 235          $sqls = array();
 236          if ($extra != '') {
 237              $sqls[] = $extra;
 238          }
 239          $params = (array)$params;
 240  
 241          if (!empty($SESSION->user_filtering)) {
 242              foreach ($SESSION->user_filtering as $fname => $datas) {
 243                  if (!array_key_exists($fname, $this->_fields)) {
 244                      continue; // Filter not used.
 245                  }
 246                  $field = $this->_fields[$fname];
 247                  foreach ($datas as $i => $data) {
 248                      list($s, $p) = $field->get_sql_filter($data);
 249                      $sqls[] = $s;
 250                      $params = $params + $p;
 251                  }
 252              }
 253          }
 254  
 255          if (empty($sqls)) {
 256              return array('', array());
 257          } else {
 258              $sqls = implode(' AND ', $sqls);
 259              return array($sqls, $params);
 260          }
 261      }
 262  
 263      /**
 264       * Print the add filter form.
 265       */
 266      public function display_add() {
 267          $this->_addform->display();
 268      }
 269  
 270      /**
 271       * Print the active filter form.
 272       */
 273      public function display_active() {
 274          $this->_activeform->display();
 275      }
 276  
 277  }
 278  
 279  /**
 280   * The base user filter class. All abstract classes must be implemented.
 281   *
 282   * @copyright 1999 Martin Dougiamas  http://dougiamas.com
 283   * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 284   */
 285  class user_filter_type {
 286      /**
 287       * The name of this filter instance.
 288       * @var string
 289       */
 290      public $_name;
 291  
 292      /**
 293       * The label of this filter instance.
 294       * @var string
 295       */
 296      public $_label;
 297  
 298      /**
 299       * Advanced form element flag
 300       * @var bool
 301       */
 302      public $_advanced;
 303  
 304      /**
 305       * Constructor
 306       * @param string $name the name of the filter instance
 307       * @param string $label the label of the filter instance
 308       * @param boolean $advanced advanced form element flag
 309       */
 310      public function __construct($name, $label, $advanced) {
 311          $this->_name     = $name;
 312          $this->_label    = $label;
 313          $this->_advanced = $advanced;
 314      }
 315  
 316      /**
 317       * Old syntax of class constructor. Deprecated in PHP7.
 318       *
 319       * @deprecated since Moodle 3.1
 320       */
 321      public function user_filter_type($name, $label, $advanced) {
 322          debugging('Use of class name as constructor is deprecated', DEBUG_DEVELOPER);
 323          self::__construct($name, $label, $advanced);
 324      }
 325  
 326      /**
 327       * Returns the condition to be used with SQL where
 328       * @param array $data filter settings
 329       * @return string the filtering condition or null if the filter is disabled
 330       */
 331      public function get_sql_filter($data) {
 332          print_error('mustbeoveride', 'debug', '', 'get_sql_filter');
 333      }
 334  
 335      /**
 336       * Retrieves data from the form data
 337       * @param stdClass $formdata data submited with the form
 338       * @return mixed array filter data or false when filter not set
 339       */
 340      public function check_data($formdata) {
 341          print_error('mustbeoveride', 'debug', '', 'check_data');
 342      }
 343  
 344      /**
 345       * Adds controls specific to this filter in the form.
 346       * @param moodleform $mform a MoodleForm object to setup
 347       */
 348      public function setupForm(&$mform) {
 349          print_error('mustbeoveride', 'debug', '', 'setupForm');
 350      }
 351  
 352      /**
 353       * Returns a human friendly description of the filter used as label.
 354       * @param array $data filter settings
 355       * @return string active filter label
 356       */
 357      public function get_label($data) {
 358          print_error('mustbeoveride', 'debug', '', 'get_label');
 359      }
 360  }