enrol/renderer.php

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