72b0cb20d25fc10f2c9537b151ed981c780d275c
[moodle.git] / 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/>.
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  */
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 {
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) {
43         $table->initialise_javascript();
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         }
55         $content = '';
56         if (!empty($buttonhtml)) {
57             $content .= $buttonhtml;
58         }
59         $content .= $mform->render();
61         $content .= $this->output->render($table->get_paging_bar());
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');
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     }
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);
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);
118         // first the input element
119         $output = html_writer::empty_tag('input', $attributes);
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         }
130         // then div wrapper for xhtml strictness
131         $output = html_writer::tag('div', $output);
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);
147         // and finally one more wrapper with class
148         return html_writer::tag('div', $output, array('class' => $button->class));
149     }
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) {
159         $table->initialise_javascript();
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     }
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');
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     }
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');
237         $groupicon = $this->output->pix_icon('i/group', get_string('addgroup', 'group'));
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     }
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     }
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     }
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 {
309     /**
310      * The get/post variable that is used to identify the page.
311      * Default: page
312      */
313     const PAGEVAR = 'page';
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';
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';
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';
334     /**
335      * The default number of items per page.
336      * Default: 100
337      */
338     const DEFAULTPERPAGE = 100;
340     /**
341      * The default sort, options are course_enrolment_table::$sortablefields
342      * Default: lastname
343      */
344     const DEFAULTSORT = 'lastname';
346     /**
347      * The default direction
348      * Default: ASC
349      */
350     const DEFAULTSORTDIRECTION = 'ASC';
352     /**
353      * The current page, starting from 0
354      * @var int
355      */
356     public $page = 0;
358     /**
359      * The total number of pages
360      * @var int
361      */
362     public $pages = 0;
364     /**
365      * The number of items to display per page
366      * @var int
367      */
368     public $perpage = 0;
370     /**
371      * The sort field for this table, should be one of course_enrolment_table::$sortablefields
372      * @var string
373      */
374     public $sort;
376     /**
377      * The sort direction, either ASC or DESC
378      * @var string
379      */
380     public $sortdirection;
382     /**
383      * The course manager this table is displaying for
384      * @var course_enrolment_manager
385      */
386     protected $manager;
388     /**
389      * The paging bar that controls the paging for this table
390      * @var paging_bar
391      */
392     protected $pagingbar = null;
394     /**
395      * The total number of users enrolled in the course
396      * @var int
397      */
398     protected $totalusers = null;
400     /**
401      * The users enrolled in this course
402      * @var array
403      */
404     protected $users = null;
406     /**
407      * The fields for this table
408      * @var array
409      */
410     protected $fields = array();
412     /**
413      * An array of bulk user enrolment operations
414      * @var array
415      */
416     protected $bulkoperations = array();
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' );
426     /**
427      * Constructs the table
428      *
429      * @param course_enrolment_manager $manager
430      */
431     public function __construct(course_enrolment_manager $manager) {
433         $this->manager        = $manager;
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);
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         }
451         $this->id = html_writer::random_id();
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     }
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     }
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     }
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;
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         }
505         foreach ($fields as $name => $label) {
506             $newlabel = '';
507             if (is_array($label)) {
508                 $bits = array();
509                 foreach ($label as $n => $l) {
510                     if ($l === false) {
511                         continue;
512                     }
513                     if (!in_array($n, self::$sortablefields)) {
514                         $bits[] = $l;
515                     } else {
516                         $link = html_writer::link(new moodle_url($url, array(self::SORTVAR=>$n)), $fields[$name][$n]);
517                         if ($this->sort == $n) {
518                             $link .= html_writer::link(new moodle_url($url, array(self::SORTVAR=>$n, self::SORTDIRECTIONVAR=>$this->get_field_sort_direction($n))), $this->get_direction_icon($output, $n));
519                         }
520                         $bits[] = html_writer::tag('span', $link, array('class'=>'subheading_'.$n));
522                     }
523                 }
524                 $newlabel = join(' / ', $bits);
525             } else {
526                 if (!in_array($name, self::$sortablefields)) {
527                     $newlabel = $label;
528                 } else {
529                     $newlabel  = html_writer::link(new moodle_url($url, array(self::SORTVAR=>$name)), $fields[$name]);
530                     if ($this->sort == $name) {
531                         $newlabel .= html_writer::link(new moodle_url($url, array(self::SORTVAR=>$name, self::SORTDIRECTIONVAR=>$this->get_field_sort_direction($name))), $this->get_direction_icon($output, $name));
532                     }
533                 }
534             }
535             $this->head[] = $newlabel;
536             $this->colclasses[] = 'field col_'.$name;
537         }
538     }
539     /**
540      * Sets the total number of users
541      *
542      * @param int $totalusers
543      */
544     public function set_total_users($totalusers) {
545         $this->totalusers = $totalusers;
546         $this->pages = ceil($this->totalusers / $this->perpage);
547         if ($this->page > $this->pages) {
548             $this->page = $this->pages;
549         }
550     }
551     /**
552      * Sets the users for this table
553      *
554      * @param array $users
555      * @return void
556      */
557     public function set_users(array $users) {
558         $this->users = $users;
559         $hasbulkops = !empty($this->bulkoperations);
560         foreach ($users as $userid=>$user) {
561             $user = (array)$user;
562             $row = new html_table_row();
563             $row->attributes = array('class' => 'userinforow');
564             $row->id = 'user_'.$userid;
565             $row->cells = array();
566             if ($hasbulkops) {
567                 // Add a checkbox into the first column.
568                 $input = html_writer::empty_tag('input', array('type' => 'checkbox', 'name' => 'bulkuser[]', 'value' => $userid));
569                 $row->cells[] = new html_table_cell($input);
570             }
571             foreach ($this->fields as $field => $label) {
572                 if (is_array($label)) {
573                     $bits = array();
574                     foreach (array_keys($label) as $subfield) {
575                         if (array_key_exists($subfield, $user)) {
576                             $bits[] = html_writer::tag('div', $user[$subfield], array('class'=>'subfield subfield_'.$subfield));
577                         }
578                     }
579                     if (empty($bits)) {
580                         $bits[] = '&nbsp;';
581                     }
582                     $row->cells[] = new html_table_cell(join(' ', $bits));
583                 } else {
584                     if (!array_key_exists($field, $user)) {
585                         $user[$field] = '&nbsp;';
586                     }
587                     $row->cells[] = new html_table_cell($user[$field]);
588                 }
589             }
590             $this->data[] = $row;
591         }
592     }
594     public function initialise_javascript() {
595         if (has_capability('moodle/role:assign', $this->manager->get_context())) {
596             $this->manager->get_moodlepage()->requires->strings_for_js(array(
597                 'assignroles',
598                 'confirmunassign',
599                 'confirmunassigntitle',
600                 'confirmunassignyes',
601                 'confirmunassignno'
602             ), 'role');
603             $modules = array('moodle-enrol-rolemanager', 'moodle-enrol-rolemanager-skin');
604             $function = 'M.enrol.rolemanager.init';
605             $arguments = array(
606                 'containerId'=>$this->id,
607                 'userIds'=>array_keys($this->users),
608                 'courseId'=>$this->manager->get_course()->id,
609                 'otherusers'=>isset($this->otherusers));
610             $this->manager->get_moodlepage()->requires->yui_module($modules, $function, array($arguments));
611         }
612     }
614     /**
615      * Gets the paging bar instance for this table
616      *
617      * @return paging_bar
618      */
619     public function get_paging_bar() {
620         if ($this->pagingbar == null) {
621             $this->pagingbar = new paging_bar($this->totalusers, $this->page, $this->perpage, $this->manager->get_moodlepage()->url, self::PAGEVAR);
622         }
623         return $this->pagingbar;
624     }
626     /**
627      * Gets the direction icon for the sortable field within this table
628      *
629      * @param core_renderer $output
630      * @param string $field
631      * @return string
632      */
633     protected function get_direction_icon($output, $field) {
634         $direction = self::DEFAULTSORTDIRECTION;
635         if ($this->sort == $field) {
636             $direction = $this->sortdirection;
637         }
638         if ($direction === 'ASC') {
639             return html_writer::empty_tag('img', array('alt' => '', 'class' => 'iconsort',
640                 'src' => $output->pix_url('t/sort_asc')));
641         } else {
642             return html_writer::empty_tag('img', array('alt' => '', 'class' => 'iconsort',
643                 'src' => $output->pix_url('t/sort_desc')));
644         }
645     }
647     /**
648      * Gets the params that will need to be added to the url in order to return to this page.
649      *
650      * @return array
651      */
652     public function get_url_params() {
653         return array(
654             self::PAGEVAR => $this->page,
655             self::PERPAGEVAR => $this->perpage,
656             self::SORTVAR => $this->sort,
657             self::SORTDIRECTIONVAR => $this->sortdirection
658         );
659     }
661     /**
662      * Returns an array of URL params for both the table and the manager.
663      *
664      * @return array
665      */
666     public function get_combined_url_params() {
667         return $this->get_url_params() + $this->manager->get_url_params();
668     }
670     /**
671      * Sets the bulk operations for this table.
672      *
673      * @param array $bulkoperations
674      */
675     public function set_bulk_user_enrolment_operations(array $bulkoperations) {
676         $this->bulkoperations = $bulkoperations;
677     }
679     /**
680      * Returns an array of bulk operations.
681      *
682      * @return array
683      */
684     public function get_bulk_user_enrolment_operations() {
685         return $this->bulkoperations;
686     }
688     /**
689      * Returns true fi the table is aware of any bulk operations that can be performed on users
690      * selected from the currently filtered enrolment plugins.
691      *
692      * @return bool
693      */
694     public function has_bulk_user_enrolment_operations() {
695         return !empty($this->bulkoperations);
696     }
699 /**
700  * Table control used for enrolled users
701  *
702  * @copyright 2010 Sam Hemelryk
703  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
704  */
705 class course_enrolment_users_table extends course_enrolment_table {
707     /**
708      * An array of sortable fields
709      * @static
710      * @var array
711      */
712     protected static $sortablefields = array('firstname', 'lastname', 'firstnamephonetic', 'lastnamephonetic', 'middlename',
713             'alternatename', 'email', 'lastaccess');
716 /**
717  * Table used for other users
718  *
719  * Other users are users who have roles but are not enrolled.
720  *
721  * @copyright 2010 Sam Hemelryk
722  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
723  */
724 class course_enrolment_other_users_table extends course_enrolment_table {
726     public $otherusers = true;
728     /**
729      * Constructs the table
730      *
731      * @param course_enrolment_manager $manager
732      */
733     public function __construct(course_enrolment_manager $manager) {
734         parent::__construct($manager);
735         $this->attributes = array('class'=>'userenrolment otheruserenrolment');
736     }
738     /**
739      * Gets a button to search users and assign them roles in the course.
740      *
741      * @staticvar int $count
742      * @param int $page
743      * @return single_button
744      */
745     public function get_user_search_button() {
746         static $count = 0;
747         if (!has_capability('moodle/role:assign', $this->manager->get_context())) {
748             return false;
749         }
750         $count++;
751         $url = new moodle_url('/admin/roles/assign.php', array('contextid'=>$this->manager->get_context()->id, 'sesskey'=>sesskey()));
752         $control = new single_button($url, get_string('assignroles', 'role'), 'get');
753         $control->class = 'singlebutton assignuserrole instance'.$count;
754         if ($count == 1) {
755             $this->manager->get_moodlepage()->requires->strings_for_js(array(
756                     'ajaxoneuserfound',
757                     'ajaxxusersfound',
758                     'ajaxnext25',
759                     'enrol',
760                     'enrolmentoptions',
761                     'enrolusers',
762                     'enrolxusers',
763                     'errajaxfailedenrol',
764                     'errajaxsearch',
765                     'foundxcohorts',
766                     'none',
767                     'usersearch',
768                     'unlimitedduration',
769                     'startdatetoday',
770                     'durationdays',
771                     'enrolperiod'), 'enrol');
772             $this->manager->get_moodlepage()->requires->string_for_js('assignrole', 'role');
774             $modules = array('moodle-enrol-otherusersmanager', 'moodle-enrol-otherusersmanager-skin');
775             $function = 'M.enrol.otherusersmanager.init';
776             $arguments = array(
777                 'courseId'=> $this->manager->get_course()->id,
778                 'ajaxUrl' => '/enrol/ajax.php',
779                 'url' => $this->manager->get_moodlepage()->url->out(false));
780             $this->manager->get_moodlepage()->requires->yui_module($modules, $function, array($arguments));
781         }
782         return $control;
783     }