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 enrol-users-page-action'));
  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         $iconenrolremove = $this->output->pix_url('t/delete');
 188
 189
 190
 191         // Get list of roles.
 192         $rolesoutput = '';
 193         foreach ($roles as $roleid=>$role) {
 194             if ($canassign and (is_siteadmin() or isset($assignableroles[$roleid])) and !$role['unchangeable']) {
 195                 $strunassign = get_string('unassignarole', 'role', $role['text']);
 196                 $icon = html_writer::empty_tag('img', array('alt'=>$strunassign, 'src'=>$iconenrolremove));
 197                 $url = new moodle_url($pageurl, array('action'=>'unassign', 'roleid'=>$roleid, 'user'=>$userid));
 198                 $rolesoutput .= html_writer::tag('div', $role['text'] . html_writer::link($url, $icon, array('class'=>'unassignrolelink', 'rel'=>$roleid, 'title'=>$strunassign)), array('class'=>'role role_'.$roleid));
 199             } else {
 200                 $rolesoutput .= html_writer::tag('div', $role['text'], array('class'=>'role unchangeable', 'rel'=>$roleid));
 201             }
 202         }
 203         $output = '';
 204         if (!empty($assignableroles) && $canassign) {
 205             $roleids = array_keys($roles);
 206             $hasallroles = true;
 207             foreach (array_keys($assignableroles) as $key) {
 208                 if (!in_array($key, $roleids)) {
 209                     $hasallroles = false;
 210                     break;
 211                 }
 212             }
 213             if (!$hasallroles) {
 214                 $url = new moodle_url($pageurl, array('action' => 'assign', 'user' => $userid));
 215                 $roleicon = $this->output->pix_icon('i/assignroles', get_string('assignroles', 'role'));
 216                 $link = html_writer::link($url, $roleicon, array('class' => 'assignrolelink'));
 217                 $output = html_writer::tag('div', $link, 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         $iconenrolremove = $this->output->pix_url('t/delete');
 236
 237         $groupicon = $this->output->pix_icon('i/group', 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         $output = '';
 250         if ($canmanagegroups && (count($groups) < count($allgroups))) {
 251             $url = new moodle_url($pageurl, array('action'=>'addmember', 'user'=>$userid));
 252             $output .= html_writer::tag('div', html_writer::link($url, $groupicon), array('class'=>'addgroup'));
 253         }
 254         $output = $output.html_writer::tag('div', $groupoutput, array('class'=>'groups'));
 255         return $output;
 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', 'firstnamephonetic', 'lastnamephonetic', 'middlename',
 424             'alternatename', 'idnumber', 'email', 'phone1', 'phone2', 'institution', 'department', 'lastaccess', 'lastcourseaccess' );
 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                         $sorturl = new moodle_url($url, array(self::SORTVAR => $n, self::SORTDIRECTIONVAR => $this->get_field_sort_direction($n)));
 517                         $link = html_writer::link($sorturl, $fields[$name][$n]);
 518                         if ($this->sort == $n) {
 519                             $link .= $this->get_direction_icon($output, $n);
 520                         }
 521                         $bits[] = html_writer::tag('span', $link, array('class'=>'subheading_'.$n));
 522
 523                     }
 524                 }
 525                 $newlabel = join(' / ', $bits);
 526             } else {
 527                 if (!in_array($name, self::$sortablefields)) {
 528                     $newlabel = $label;
 529                 } else {
 530                     $sorturl = new moodle_url($url, array(self::SORTVAR => $name, self::SORTDIRECTIONVAR => $this->get_field_sort_direction($name)));
 531                     $newlabel  = html_writer::link($sorturl, $fields[$name]);
 532                     if ($this->sort == $name) {
 533                         $newlabel .= $this->get_direction_icon($output, $name);
 534                     }
 535                 }
 536             }
 537             $this->head[] = $newlabel;
 538             $this->colclasses[] = 'field col_'.$name;
 539         }
 540     }
 541     /**
 542      * Sets the total number of users
 543      *
 544      * @param int $totalusers
 545      */
 546     public function set_total_users($totalusers) {
 547         $this->totalusers = $totalusers;
 548         $this->pages = ceil($this->totalusers / $this->perpage);
 549         if ($this->page > $this->pages) {
 550             $this->page = $this->pages;
 551         }
 552     }
 553     /**
 554      * Sets the users for this table
 555      *
 556      * @param array $users
 557      * @return void
 558      */
 559     public function set_users(array $users) {
 560         $this->users = $users;
 561         $hasbulkops = !empty($this->bulkoperations);
 562         foreach ($users as $userid=>$user) {
 563             $user = (array)$user;
 564             $row = new html_table_row();
 565             $row->attributes = array('class' => 'userinforow');
 566             $row->id = 'user_'.$userid;
 567             $row->cells = array();
 568             if ($hasbulkops) {
 569                 // Add a checkbox into the first column.
 570                 $input = html_writer::empty_tag('input', array('type' => 'checkbox', 'name' => 'bulkuser[]', 'value' => $userid));
 571                 $row->cells[] = new html_table_cell($input);
 572             }
 573             foreach ($this->fields as $field => $label) {
 574                 if (is_array($label)) {
 575                     $bits = array();
 576                     foreach (array_keys($label) as $subfield) {
 577                         if (array_key_exists($subfield, $user)) {
 578                             $bits[] = html_writer::tag('div', $user[$subfield], array('class'=>'subfield subfield_'.$subfield));
 579                         }
 580                     }
 581                     if (empty($bits)) {
 582                         $bits[] = '&nbsp;';
 583                     }
 584                     $row->cells[] = new html_table_cell(join(' ', $bits));
 585                 } else {
 586                     if (!array_key_exists($field, $user)) {
 587                         $user[$field] = '&nbsp;';
 588                     }
 589                     $row->cells[] = new html_table_cell($user[$field]);
 590                 }
 591             }
 592             $this->data[] = $row;
 593         }
 594     }
 595
 596     public function initialise_javascript() {
 597         if (has_capability('moodle/role:assign', $this->manager->get_context())) {
 598             $this->manager->get_moodlepage()->requires->strings_for_js(array(
 599                 'assignroles',
 600                 'confirmunassign',
 601                 'confirmunassigntitle',
 602                 'confirmunassignyes',
 603                 'confirmunassignno'
 604             ), 'role');
 605             $modules = array('moodle-enrol-rolemanager', 'moodle-enrol-rolemanager-skin');
 606             $function = 'M.enrol.rolemanager.init';
 607             $arguments = array(
 608                 'containerId'=>$this->id,
 609                 'userIds'=>array_keys($this->users),
 610                 'courseId'=>$this->manager->get_course()->id,
 611                 'otherusers'=>isset($this->otherusers));
 612             $this->manager->get_moodlepage()->requires->yui_module($modules, $function, array($arguments));
 613         }
 614     }
 615
 616     /**
 617      * Gets the paging bar instance for this table
 618      *
 619      * @return paging_bar
 620      */
 621     public function get_paging_bar() {
 622         if ($this->pagingbar == null) {
 623             $this->pagingbar = new paging_bar($this->totalusers, $this->page, $this->perpage, $this->manager->get_moodlepage()->url, self::PAGEVAR);
 624         }
 625         return $this->pagingbar;
 626     }
 627
 628     /**
 629      * Gets the direction icon for the sortable field within this table
 630      *
 631      * @param core_renderer $output
 632      * @param string $field
 633      * @return string
 634      */
 635     protected function get_direction_icon($output, $field) {
 636         $direction = self::DEFAULTSORTDIRECTION;
 637         if ($this->sort == $field) {
 638             $direction = $this->sortdirection;
 639         }
 640         if ($direction === 'ASC') {
 641             return html_writer::empty_tag('img', array('alt' => '', 'class' => 'iconsort',
 642                 'src' => $output->pix_url('t/sort_asc')));
 643         } else {
 644             return html_writer::empty_tag('img', array('alt' => '', 'class' => 'iconsort',
 645                 'src' => $output->pix_url('t/sort_desc')));
 646         }
 647     }
 648
 649     /**
 650      * Gets the params that will need to be added to the url in order to return to this page.
 651      *
 652      * @return array
 653      */
 654     public function get_url_params() {
 655         return array(
 656             self::PAGEVAR => $this->page,
 657             self::PERPAGEVAR => $this->perpage,
 658             self::SORTVAR => $this->sort,
 659             self::SORTDIRECTIONVAR => $this->sortdirection
 660         );
 661     }
 662
 663     /**
 664      * Returns an array of URL params for both the table and the manager.
 665      *
 666      * @return array
 667      */
 668     public function get_combined_url_params() {
 669         return $this->get_url_params() + $this->manager->get_url_params();
 670     }
 671
 672     /**
 673      * Sets the bulk operations for this table.
 674      *
 675      * @param array $bulkoperations
 676      */
 677     public function set_bulk_user_enrolment_operations(array $bulkoperations) {
 678         $this->bulkoperations = $bulkoperations;
 679     }
 680
 681     /**
 682      * Returns an array of bulk operations.
 683      *
 684      * @return array
 685      */
 686     public function get_bulk_user_enrolment_operations() {
 687         return $this->bulkoperations;
 688     }
 689
 690     /**
 691      * Returns true fi the table is aware of any bulk operations that can be performed on users
 692      * selected from the currently filtered enrolment plugins.
 693      *
 694      * @return bool
 695      */
 696     public function has_bulk_user_enrolment_operations() {
 697         return !empty($this->bulkoperations);
 698     }
 699 }
 700
 701 /**
 702  * Table control used for enrolled users
 703  *
 704  * @copyright 2010 Sam Hemelryk
 705  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 706  */
 707 class course_enrolment_users_table extends course_enrolment_table {
 708
 709 }
 710
 711 /**
 712  * Table used for other users
 713  *
 714  * Other users are users who have roles but are not enrolled.
 715  *
 716  * @copyright 2010 Sam Hemelryk
 717  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 718  */
 719 class course_enrolment_other_users_table extends course_enrolment_table {
 720
 721     public $otherusers = true;
 722
 723     /**
 724      * Constructs the table
 725      *
 726      * @param course_enrolment_manager $manager
 727      */
 728     public function __construct(course_enrolment_manager $manager) {
 729         parent::__construct($manager);
 730         $this->attributes = array('class'=>'userenrolment otheruserenrolment');
 731     }
 732
 733     /**
 734      * Gets a button to search users and assign them roles in the course.
 735      *
 736      * @staticvar int $count
 737      * @param int $page
 738      * @return single_button
 739      */
 740     public function get_user_search_button() {
 741         static $count = 0;
 742         if (!has_capability('moodle/role:assign', $this->manager->get_context())) {
 743             return false;
 744         }
 745         $count++;
 746         $url = new moodle_url('/admin/roles/assign.php', array('contextid'=>$this->manager->get_context()->id, 'sesskey'=>sesskey()));
 747         $control = new single_button($url, get_string('assignroles', 'role'), 'get');
 748         $control->class = 'singlebutton assignuserrole instance'.$count;
 749         if ($count == 1) {
 750             $this->manager->get_moodlepage()->requires->strings_for_js(array(
 751                     'ajaxoneuserfound',
 752                     'ajaxxusersfound',
 753                     'ajaxnext25',
 754                     'enrol',
 755                     'enrolmentoptions',
 756                     'enrolusers',
 757                     'enrolxusers',
 758                     'errajaxfailedenrol',
 759                     'errajaxsearch',
 760                     'foundxcohorts',
 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 }