enrol/renderer.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  * This is the main renderer for the enrol section.
  19  *
  20  * @package    core_enrol
  21  * @copyright  2010 Sam Hemelryk
  22  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23  */
  24
  25 /**
  26  * This is the core renderer
  27  *
  28  * @copyright 2010 Sam Hemelryk
  29  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  30  */
  31 class core_enrol_renderer extends plugin_renderer_base {
  32
  33     /**
  34      * Renders a course enrolment table
  35      *
  36      * @param course_enrolment_table $table
  37      * @param moodleform $mform Form that contains filter controls
  38      * @return string
  39      */
  40     public function render_course_enrolment_users_table(course_enrolment_users_table $table,
  41             moodleform $mform) {
  42
  43         $table->initialise_javascript();
  44
  45         $buttons = $table->get_manual_enrol_buttons();
  46         $buttonhtml = '';
  47         if (count($buttons) > 0) {
  48             $buttonhtml .= html_writer::start_tag('div', array('class' => 'enrol_user_buttons'));
  49             foreach ($buttons as $button) {
  50                 $buttonhtml .= $this->render($button);
  51             }
  52             $buttonhtml .= html_writer::end_tag('div');
  53         }
  54
  55         $content = '';
  56         if (!empty($buttonhtml)) {
  57             $content .= $buttonhtml;
  58         }
  59         $content .= $mform->render();
  60
  61         $content .= $this->output->render($table->get_paging_bar());
  62
  63         // Check if the table has any bulk operations. If it does we want to wrap the table in a
  64         // form so that we can capture and perform any required bulk operations.
  65         if ($table->has_bulk_user_enrolment_operations()) {
  66             $content .= html_writer::start_tag('form', array('action' => new moodle_url('/enrol/bulkchange.php'), 'method' => 'post'));
  67             foreach ($table->get_combined_url_params() as $key => $value) {
  68                 if ($key == 'action') {
  69                     continue;
  70                 }
  71                 $content .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => $key, 'value' => $value));
  72             }
  73             $content .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => 'action', 'value' => 'bulkchange'));
  74             $content .= html_writer::table($table);
  75             $content .= html_writer::start_tag('div', array('class' => 'singleselect bulkuserop'));
  76             $content .= html_writer::start_tag('select', array('name' => 'bulkuserop'));
  77             $content .= html_writer::tag('option', get_string('withselectedusers', 'enrol'), array('value' => ''));
  78             $options = array('' => get_string('withselectedusers', 'enrol'));
  79             foreach ($table->get_bulk_user_enrolment_operations() as $operation) {
  80                 $content .= html_writer::tag('option', $operation->get_title(), array('value' => $operation->get_identifier()));
  81             }
  82             $content .= html_writer::end_tag('select');
  83             $content .= html_writer::empty_tag('input', array('type' => 'submit', 'value' => get_string('go')));
  84             $content .= html_writer::end_tag('div');
  85
  86             $content .= html_writer::end_tag('form');
  87         } else {
  88             $content .= html_writer::table($table);
  89         }
  90         $content .= $this->output->render($table->get_paging_bar());
  91         if (!empty($buttonhtml)) {
  92             $content .= $buttonhtml;
  93         }
  94         return $content;
  95     }
  96
  97     /**
  98      * Renderers the enrol_user_button.
  99      *
 100      * @param enrol_user_button $button
 101      * @return string XHTML
 102      */
 103     protected function render_enrol_user_button(enrol_user_button $button) {
 104         $attributes = array('type'     => 'submit',
 105                             'value'    => $button->label,
 106                             'disabled' => $button->disabled ? 'disabled' : null,
 107                             'title'    => $button->tooltip);
 108
 109         if ($button->actions) {
 110             $id = html_writer::random_id('single_button');
 111             $attributes['id'] = $id;
 112             foreach ($button->actions as $action) {
 113                 $this->add_action_handler($action, $id);
 114             }
 115         }
 116         $button->initialise_js($this->page);
 117
 118         // first the input element
 119         $output = html_writer::empty_tag('input', $attributes);
 120
 121         // then hidden fields
 122         $params = $button->url->params();
 123         if ($button->method === 'post') {
 124             $params['sesskey'] = sesskey();
 125         }
 126         foreach ($params as $var => $val) {
 127             $output .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => $var, 'value' => $val));
 128         }
 129
 130         // then div wrapper for xhtml strictness
 131         $output = html_writer::tag('div', $output);
 132
 133         // now the form itself around it
 134         if ($button->method === 'get') {
 135             $url = $button->url->out_omit_querystring(true); // url without params, the anchor part allowed
 136         } else {
 137             $url = $button->url->out_omit_querystring();     // url without params, the anchor part not allowed
 138         }
 139         if ($url === '') {
 140             $url = '#'; // there has to be always some action
 141         }
 142         $attributes = array('method' => $button->method,
 143                             'action' => $url,
 144                             'id'     => $button->formid);
 145         $output = html_writer::tag('form', $output, $attributes);
 146
 147         // and finally one more wrapper with class
 148         return html_writer::tag('div', $output, array('class' => $button->class));
 149     }
 150
 151     /**
 152      * Renders a course enrolment table
 153      *
 154      * @param course_enrolment_table $table
 155      * @return string
 156      */
 157     protected function render_course_enrolment_other_users_table(course_enrolment_other_users_table $table) {
 158
 159         $table->initialise_javascript();
 160
 161         $content = '';
 162         $searchbutton = $table->get_user_search_button();
 163         if ($searchbutton) {
 164             $content .= $this->output->render($searchbutton);
 165         }
 166         $content .= html_writer::tag('div', get_string('otheruserdesc', 'enrol'), array('class'=>'otherusersdesc'));
 167         $content .= $this->output->render($table->get_paging_bar());
 168         $content .= html_writer::table($table);
 169         $content .= $this->output->render($table->get_paging_bar());
 170         $searchbutton = $table->get_user_search_button();
 171         if ($searchbutton) {
 172             $content .= $this->output->render($searchbutton);
 173         }
 174         return $content;
 175     }
 176
 177     /**
 178      * Generates HTML to display the users roles and any available actions
 179      *
 180      * @param int $userid
 181      * @param array $roles
 182      * @param array $assignableroles
 183      * @param moodle_url $pageurl
 184      * @return string
 185      */
 186     public function user_roles_and_actions($userid, $roles, $assignableroles, $canassign, $pageurl) {
 187         $iconenroladd    = $this->output->pix_url('t/enroladd');
 188         $iconenrolremove = $this->output->pix_url('t/delete');
 189
 190         // get list of roles
 191         $rolesoutput = '';
 192         foreach ($roles as $roleid=>$role) {
 193             if ($canassign and (is_siteadmin() or isset($assignableroles[$roleid])) and !$role['unchangeable']) {
 194                 $strunassign = get_string('unassignarole', 'role', $role['text']);
 195                 $icon = html_writer::empty_tag('img', array('alt'=>$strunassign, 'src'=>$iconenrolremove));
 196                 $url = new moodle_url($pageurl, array('action'=>'unassign', 'roleid'=>$roleid, 'user'=>$userid));
 197                 $rolesoutput .= html_writer::tag('div', $role['text'] . html_writer::link($url, $icon, array('class'=>'unassignrolelink', 'rel'=>$roleid, 'title'=>$strunassign)), array('class'=>'role role_'.$roleid));
 198             } else {
 199                 $rolesoutput .= html_writer::tag('div', $role['text'], array('class'=>'role unchangeable', 'rel'=>$roleid));
 200             }
 201         }
 202         $output = '';
 203         if (!empty($assignableroles) && $canassign) {
 204             $roleids = array_keys($roles);
 205             $hasallroles = true;
 206             foreach (array_keys($assignableroles) as $key) {
 207                 if (!in_array($key, $roleids)) {
 208                     $hasallroles = false;
 209                     break;
 210                 }
 211             }
 212             if (!$hasallroles) {
 213                 $url = new moodle_url($pageurl, array('action'=>'assign', 'user'=>$userid));
 214                 $icon = html_writer::empty_tag('img', array('alt'=>get_string('assignroles', 'role'), 'src'=>$iconenroladd));
 215                 $output = html_writer::tag('div', html_writer::link($url, $icon, array('class'=>'assignrolelink', 'title'=>get_string('assignroles', 'role'))), array('class'=>'addrole'));
 216             }
 217         }
 218         $output .= html_writer::tag('div', $rolesoutput, array('class'=>'roles'));
 219         return $output;
 220     }
 221
 222     /**
 223      * Generates the HTML to view the users groups and available group actions
 224      *
 225      * @param int $userid
 226      * @param array $groups
 227      * @param array $allgroups
 228      * @param bool $canmanagegroups
 229      * @param moodle_url $pageurl
 230      * @return string
 231      */
 232     public function user_groups_and_actions($userid, $groups, $allgroups, $canmanagegroups, $pageurl) {
 233         $iconenroladd    = $this->output->pix_url('t/enroladd');
 234         $iconenrolremove = $this->output->pix_url('t/delete');
 235         $straddgroup = get_string('addgroup', 'group');
 236
 237         $groupoutput = '';
 238         foreach($groups as $groupid=>$name) {
 239             if ($canmanagegroups and groups_remove_member_allowed($groupid, $userid)) {
 240                 $icon = html_writer::empty_tag('img', array('alt'=>get_string('removefromgroup', 'group', $name), 'src'=>$iconenrolremove));
 241                 $url = new moodle_url($pageurl, array('action'=>'removemember', 'group'=>$groupid, 'user'=>$userid));
 242                 $groupoutput .= html_writer::tag('div', $name . html_writer::link($url, $icon), array('class'=>'group', 'rel'=>$groupid));
 243             } else {
 244                 $groupoutput .= html_writer::tag('div', $name, array('class'=>'group', 'rel'=>$groupid));
 245             }
 246         }
 247         $groupoutput = html_writer::tag('div', $groupoutput, array('class'=>'groups'));
 248         if ($canmanagegroups && (count($groups) < count($allgroups))) {
 249             $icon = html_writer::empty_tag('img', array('alt'=>$straddgroup, 'src'=>$iconenroladd));
 250             $url = new moodle_url($pageurl, array('action'=>'addmember', 'user'=>$userid));
 251             $groupoutput .= html_writer::tag('div', html_writer::link($url, $icon), array('class'=>'addgroup'));
 252         }
 253         return $groupoutput;
 254     }
 255
 256     /**
 257      * Generates the HTML for the given enrolments + available actions
 258      *
 259      * @param int $userid
 260      * @param array $enrolments
 261      * @param moodle_url $pageurl
 262      * @return string
 263      */
 264     public function user_enrolments_and_actions($enrolments) {
 265         $output = '';
 266         foreach ($enrolments as $ue) {
 267             $enrolmentoutput = $ue['text'].' '.$ue['period'];
 268             if ($ue['dimmed']) {
 269                 $enrolmentoutput = html_writer::tag('span', $enrolmentoutput, array('class'=>'dimmed_text'));
 270             } else {
 271                 $enrolmentoutput = html_writer::tag('span', $enrolmentoutput);
 272             }
 273             foreach ($ue['actions'] as $action) {
 274                 $enrolmentoutput .= $this->render($action);
 275             }
 276             $output .= html_writer::tag('div', $enrolmentoutput, array('class'=>'enrolment'));
 277         }
 278         return $output;
 279     }
 280
 281     /**
 282      * Renders a user enrolment action
 283      * @param user_enrolment_action $icon
 284      * @return string
 285      */
 286     protected function render_user_enrolment_action(user_enrolment_action $icon) {
 287         return html_writer::link($icon->get_url(), $this->output->render($icon->get_icon()), $icon->get_attributes());
 288     }
 289 }
 290
 291 /**
 292  * Main course enrolment table
 293  *
 294  * This table is used to display the enrolment information for a course.
 295  * It requires that a course enrolment manager be provided during constuct with
 296  * provides all of the information for the table.
 297  * The control then produces the table, the paging, and the associated JS actions
 298  * for the page.
 299  *
 300  * @package    core
 301  * @subpackage enrol
 302  * @copyright  2010 Sam Hemelryk
 303  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 304  */
 305 class course_enrolment_table extends html_table implements renderable {
 306
 307     /**
 308      * The get/post variable that is used to identify the page.
 309      * Default: page
 310      */
 311     const PAGEVAR = 'page';
 312
 313     /**
 314      * The get/post variable to is used to identify the number of items to display
 315      * per page.
 316      * Default: perpage
 317      */
 318     const PERPAGEVAR = 'perpage';
 319
 320     /**
 321      * The get/post variable that is used to identify the sort field for the table.
 322      * Default: sort
 323      */
 324     const SORTVAR = 'sort';
 325
 326     /**
 327      * The get/post variable that is used to identify the sort direction for the table.
 328      * Default: dir
 329      */
 330     const SORTDIRECTIONVAR = 'dir';
 331
 332     /**
 333      * The default number of items per page.
 334      * Default: 100
 335      */
 336     const DEFAULTPERPAGE = 100;
 337
 338     /**
 339      * The default sort, options are course_enrolment_table::$sortablefields
 340      * Default: lastname
 341      */
 342     const DEFAULTSORT = 'lastname';
 343
 344     /**
 345      * The default direction
 346      * Default: ASC
 347      */
 348     const DEFAULTSORTDIRECTION = 'ASC';
 349
 350     /**
 351      * The current page, starting from 0
 352      * @var int
 353      */
 354     public $page = 0;
 355
 356     /**
 357      * The total number of pages
 358      * @var int
 359      */
 360     public $pages = 0;
 361
 362     /**
 363      * The number of items to display per page
 364      * @var int
 365      */
 366     public $perpage = 0;
 367
 368     /**
 369      * The sort field for this table, should be one of course_enrolment_table::$sortablefields
 370      * @var string
 371      */
 372     public $sort;
 373
 374     /**
 375      * The sort direction, either ASC or DESC
 376      * @var string
 377      */
 378     public $sortdirection;
 379
 380     /**
 381      * The course manager this table is displaying for
 382      * @var course_enrolment_manager
 383      */
 384     protected $manager;
 385
 386     /**
 387      * The paging bar that controls the paging for this table
 388      * @var paging_bar
 389      */
 390     protected $pagingbar = null;
 391
 392     /**
 393      * The total number of users enrolled in the course
 394      * @var int
 395      */
 396     protected $totalusers = null;
 397
 398     /**
 399      * The users enrolled in this course
 400      * @var array
 401      */
 402     protected $users = null;
 403
 404     /**
 405      * The fields for this table
 406      * @var array
 407      */
 408     protected $fields = array();
 409
 410     /**
 411      * An array of bulk user enrolment operations
 412      * @var array
 413      */
 414     protected $bulkoperations = array();
 415
 416     /**
 417      * An array of sortable fields
 418      * @static
 419      * @var array
 420      */
 421     protected static $sortablefields = array('firstname', 'lastname', 'idnumber', 'email',
 422             'phone1', 'phone2', 'institution', 'department' );
 423
 424     /**
 425      * Constructs the table
 426      *
 427      * @param course_enrolment_manager $manager
 428      */
 429     public function __construct(course_enrolment_manager $manager) {
 430
 431         $this->manager        = $manager;
 432
 433         $this->page           = optional_param(self::PAGEVAR, 0, PARAM_INT);
 434         $this->perpage        = optional_param(self::PERPAGEVAR, self::DEFAULTPERPAGE, PARAM_INT);
 435         $this->sort           = optional_param(self::SORTVAR, self::DEFAULTSORT, PARAM_ALPHANUM);
 436         $this->sortdirection  = optional_param(self::SORTDIRECTIONVAR, self::DEFAULTSORTDIRECTION, PARAM_ALPHA);
 437
 438         $this->attributes = array('class'=>'userenrolment');
 439         if (!in_array($this->sort, self::$sortablefields)) {
 440             $this->sort = self::DEFAULTSORT;
 441         }
 442         if ($this->page < 0) {
 443             $this->page = 0;
 444         }
 445         if ($this->sortdirection !== 'ASC' && $this->sortdirection !== 'DESC') {
 446             $this->sortdirection = self::DEFAULTSORTDIRECTION;
 447         }
 448
 449         $this->id = html_writer::random_id();
 450
 451         // Collect the bulk operations for the currently filtered plugin if there is one.
 452         $plugin = $manager->get_filtered_enrolment_plugin();
 453         if ($plugin and enrol_is_enabled($plugin->get_name())) {
 454             $this->bulkoperations = $plugin->get_bulk_operations($manager);
 455         }
 456     }
 457
 458     /**
 459      * Returns an array of enrol_user_buttons that are created by the different
 460      * enrolment plugins available.
 461      *
 462      * @return array
 463      */
 464     public function get_manual_enrol_buttons() {
 465         return $this->manager->get_manual_enrol_buttons();
 466     }
 467
 468     /**
 469      * Gets the sort direction for a given field
 470      *
 471      * @param string $field
 472      * @return string ASC or DESC
 473      */
 474     public function get_field_sort_direction($field) {
 475         if ($field == $this->sort) {
 476             return ($this->sortdirection == 'ASC')?'DESC':'ASC';
 477         }
 478         return self::DEFAULTSORTDIRECTION;
 479     }
 480
 481     /**
 482      * Sets the fields for this table. These get added to the tables head as well.
 483      *
 484      * You can also use a multi dimensional array for this to have multiple fields
 485      * in a single column
 486      *
 487      * @param array $fields An array of fields to set
 488      * @param string $output
 489      */
 490     public function set_fields($fields, $output) {
 491         $this->fields = $fields;
 492         $this->head = array();
 493         $this->colclasses = array();
 494         $this->align = array();
 495         $url = $this->manager->get_moodlepage()->url;
 496
 497         if (!empty($this->bulkoperations)) {
 498             // If there are bulk operations add a column for checkboxes.
 499             $this->head[] = '';
 500             $this->colclasses[] = 'field col_bulkops';
 501         }
 502
 503         foreach ($fields as $name => $label) {
 504             $newlabel = '';
 505             if (is_array($label)) {
 506                 $bits = array();
 507                 foreach ($label as $n => $l) {
 508                     if ($l === false) {
 509                         continue;
 510                     }
 511                     if (!in_array($n, self::$sortablefields)) {
 512                         $bits[] = $l;
 513                     } else {
 514                         $link = html_writer::link(new moodle_url($url, array(self::SORTVAR=>$n)), $fields[$name][$n]);
 515                         if ($this->sort == $n) {
 516                             $link .= html_writer::link(new moodle_url($url, array(self::SORTVAR=>$n, self::SORTDIRECTIONVAR=>$this->get_field_sort_direction($n))), $this->get_direction_icon($output, $n));
 517                         }
 518                         $bits[] = html_writer::tag('span', $link, array('class'=>'subheading_'.$n));
 519
 520                     }
 521                 }
 522                 $newlabel = join(' / ', $bits);
 523             } else {
 524                 if (!in_array($name, self::$sortablefields)) {
 525                     $newlabel = $label;
 526                 } else {
 527                     $newlabel  = html_writer::link(new moodle_url($url, array(self::SORTVAR=>$name)), $fields[$name]);
 528                     if ($this->sort == $name) {
 529                         $newlabel .= html_writer::link(new moodle_url($url, array(self::SORTVAR=>$name, self::SORTDIRECTIONVAR=>$this->get_field_sort_direction($name))), $this->get_direction_icon($output, $name));
 530                     }
 531                 }
 532             }
 533             $this->head[] = $newlabel;
 534             $this->colclasses[] = 'field col_'.$name;
 535         }
 536     }
 537     /**
 538      * Sets the total number of users
 539      *
 540      * @param int $totalusers
 541      */
 542     public function set_total_users($totalusers) {
 543         $this->totalusers = $totalusers;
 544         $this->pages = ceil($this->totalusers / $this->perpage);
 545         if ($this->page > $this->pages) {
 546             $this->page = $this->pages;
 547         }
 548     }
 549     /**
 550      * Sets the users for this table
 551      *
 552      * @param array $users
 553      * @return void
 554      */
 555     public function set_users(array $users) {
 556         $this->users = $users;
 557         $hasbulkops = !empty($this->bulkoperations);
 558         foreach ($users as $userid=>$user) {
 559             $user = (array)$user;
 560             $row = new html_table_row();
 561             $row->attributes = array('class' => 'userinforow');
 562             $row->id = 'user_'.$userid;
 563             $row->cells = array();
 564             if ($hasbulkops) {
 565                 // Add a checkbox into the first column.
 566                 $input = html_writer::empty_tag('input', array('type' => 'checkbox', 'name' => 'bulkuser[]', 'value' => $userid));
 567                 $row->cells[] = new html_table_cell($input);
 568             }
 569             foreach ($this->fields as $field => $label) {
 570                 if (is_array($label)) {
 571                     $bits = array();
 572                     foreach (array_keys($label) as $subfield) {
 573                         if (array_key_exists($subfield, $user)) {
 574                             $bits[] = html_writer::tag('div', $user[$subfield], array('class'=>'subfield subfield_'.$subfield));
 575                         }
 576                     }
 577                     if (empty($bits)) {
 578                         $bits[] = '&nbsp;';
 579                     }
 580                     $row->cells[] = new html_table_cell(join(' ', $bits));
 581                 } else {
 582                     if (!array_key_exists($field, $user)) {
 583                         $user[$field] = '&nbsp;';
 584                     }
 585                     $row->cells[] = new html_table_cell($user[$field]);
 586                 }
 587             }
 588             $this->data[] = $row;
 589         }
 590     }
 591
 592     public function initialise_javascript() {
 593         if (has_capability('moodle/role:assign', $this->manager->get_context())) {
 594             $this->manager->get_moodlepage()->requires->strings_for_js(array(
 595                 'assignroles',
 596                 'confirmunassign',
 597                 'confirmunassigntitle',
 598                 'confirmunassignyes',
 599                 'confirmunassignno'
 600             ), 'role');
 601             $modules = array('moodle-enrol-rolemanager', 'moodle-enrol-rolemanager-skin');
 602             $function = 'M.enrol.rolemanager.init';
 603             $arguments = array(
 604                 'containerId'=>$this->id,
 605                 'userIds'=>array_keys($this->users),
 606                 'courseId'=>$this->manager->get_course()->id,
 607                 'otherusers'=>isset($this->otherusers));
 608             $this->manager->get_moodlepage()->requires->yui_module($modules, $function, array($arguments));
 609         }
 610     }
 611
 612     /**
 613      * Gets the paging bar instance for this table
 614      *
 615      * @return paging_bar
 616      */
 617     public function get_paging_bar() {
 618         if ($this->pagingbar == null) {
 619             $this->pagingbar = new paging_bar($this->totalusers, $this->page, $this->perpage, $this->manager->get_moodlepage()->url, self::PAGEVAR);
 620         }
 621         return $this->pagingbar;
 622     }
 623
 624     /**
 625      * Gets the direction icon for the sortable field within this table
 626      *
 627      * @param core_renderer $output
 628      * @param string $field
 629      * @return string
 630      */
 631     protected function get_direction_icon($output, $field) {
 632         $direction = self::DEFAULTSORTDIRECTION;
 633         if ($this->sort == $field) {
 634             $direction = $this->sortdirection;
 635         }
 636         if ($direction === 'ASC') {
 637             return html_writer::empty_tag('img', array('alt' => '', 'class' => 'iconsort',
 638                 'src' => $output->pix_url('t/sort_asc')));
 639         } else {
 640             return html_writer::empty_tag('img', array('alt' => '', 'class' => 'iconsort',
 641                 'src' => $output->pix_url('t/sort_desc')));
 642         }
 643     }
 644
 645     /**
 646      * Gets the params that will need to be added to the url in order to return to this page.
 647      *
 648      * @return array
 649      */
 650     public function get_url_params() {
 651         return array(
 652             self::PAGEVAR => $this->page,
 653             self::PERPAGEVAR => $this->perpage,
 654             self::SORTVAR => $this->sort,
 655             self::SORTDIRECTIONVAR => $this->sortdirection
 656         );
 657     }
 658
 659     /**
 660      * Returns an array of URL params for both the table and the manager.
 661      *
 662      * @return array
 663      */
 664     public function get_combined_url_params() {
 665         return $this->get_url_params() + $this->manager->get_url_params();
 666     }
 667
 668     /**
 669      * Sets the bulk operations for this table.
 670      *
 671      * @param array $bulkoperations
 672      */
 673     public function set_bulk_user_enrolment_operations(array $bulkoperations) {
 674         $this->bulkoperations = $bulkoperations;
 675     }
 676
 677     /**
 678      * Returns an array of bulk operations.
 679      *
 680      * @return array
 681      */
 682     public function get_bulk_user_enrolment_operations() {
 683         return $this->bulkoperations;
 684     }
 685
 686     /**
 687      * Returns true fi the table is aware of any bulk operations that can be performed on users
 688      * selected from the currently filtered enrolment plugins.
 689      *
 690      * @return bool
 691      */
 692     public function has_bulk_user_enrolment_operations() {
 693         return !empty($this->bulkoperations);
 694     }
 695 }
 696
 697 /**
 698  * Table control used for enrolled users
 699  *
 700  * @copyright 2010 Sam Hemelryk
 701  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 702  */
 703 class course_enrolment_users_table extends course_enrolment_table {
 704
 705     /**
 706      * An array of sortable fields
 707      * @static
 708      * @var array
 709      */
 710     protected static $sortablefields = array('firstname', 'lastname', 'email', 'lastaccess');
 711 }
 712
 713 /**
 714  * Table used for other users
 715  *
 716  * Other users are users who have roles but are not enrolled.
 717  *
 718  * @copyright 2010 Sam Hemelryk
 719  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 720  */
 721 class course_enrolment_other_users_table extends course_enrolment_table {
 722
 723     public $otherusers = true;
 724
 725     /**
 726      * Constructs the table
 727      *
 728      * @param course_enrolment_manager $manager
 729      */
 730     public function __construct(course_enrolment_manager $manager) {
 731         parent::__construct($manager);
 732         $this->attributes = array('class'=>'userenrolment otheruserenrolment');
 733     }
 734
 735     /**
 736      * Gets a button to search users and assign them roles in the course.
 737      *
 738      * @staticvar int $count
 739      * @param int $page
 740      * @return single_button
 741      */
 742     public function get_user_search_button() {
 743         static $count = 0;
 744         if (!has_capability('moodle/role:assign', $this->manager->get_context())) {
 745             return false;
 746         }
 747         $count++;
 748         $url = new moodle_url('/admin/roles/assign.php', array('contextid'=>$this->manager->get_context()->id, 'sesskey'=>sesskey()));
 749         $control = new single_button($url, get_string('assignroles', 'role'), 'get');
 750         $control->class = 'singlebutton assignuserrole instance'.$count;
 751         if ($count == 1) {
 752             $this->manager->get_moodlepage()->requires->strings_for_js(array(
 753                     'ajaxoneuserfound',
 754                     'ajaxxusersfound',
 755                     'ajaxnext25',
 756                     'enrol',
 757                     'enrolmentoptions',
 758                     'enrolusers',
 759                     'errajaxfailedenrol',
 760                     'errajaxsearch',
 761                     'none',
 762                     'usersearch',
 763                     'unlimitedduration',
 764                     'startdatetoday',
 765                     'durationdays',
 766                     'enrolperiod'), 'enrol');
 767             $this->manager->get_moodlepage()->requires->string_for_js('assignrole', 'role');
 768
 769             $modules = array('moodle-enrol-otherusersmanager', 'moodle-enrol-otherusersmanager-skin');
 770             $function = 'M.enrol.otherusersmanager.init';
 771             $arguments = array(
 772                 'courseId'=> $this->manager->get_course()->id,
 773                 'ajaxUrl' => '/enrol/ajax.php',
 774                 'url' => $this->manager->get_moodlepage()->url->out(false));
 775             $this->manager->get_moodlepage()->requires->yui_module($modules, $function, array($arguments));
 776         }
 777         return $control;
 778     }
 779 }