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