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