MDL-30335 formslib : phpdoc improvement
[moodle.git] / enrol / externallib.php
1 <?php
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/>.
18 /**
19  * External course participation api.
20  *
21  * This api is mostly read only, the actual enrol and unenrol
22  * support is in each enrol plugin.
23  *
24  * @package    core
25  * @subpackage enrol
26  * @copyright  2009 Moodle Pty Ltd (http://moodle.com)
27  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
28  */
30 defined('MOODLE_INTERNAL') || die();
32 require_once("$CFG->libdir/externallib.php");
34 /**
35  * Enrol functions
36  */
37 class core_enrol_external extends external_api {
39     /**
40      * Returns description of method parameters
41      * @return external_function_parameters
42      */
43     public static function get_users_courses_parameters() {
44         return new external_function_parameters(
45             array(
46                 'userid' => new external_value(PARAM_INT, 'user id'),
47             )
48         );
49     }
51     /**
52      * Get list of courses user is enrolled in (only active enrolments are returned).
53      *
54      * Please note the current user must be able to access the course, otherwise the course is not included.
55      *
56      * @param int $userid
57      * @return array of courses
58      */
59     public static function get_users_courses($userid) {
60         global $USER;
62         // Do basic automatic PARAM checks on incoming data, using params description
63         // If any problems are found then exceptions are thrown with helpful error messages
64         $params = self::validate_parameters(self::get_users_courses_parameters(), array('userid'=>$userid));
66         $courses = enrol_get_users_courses($params['userid'], true, 'id, shortname, fullname, idnumber, visible');
67         $result = array();
69         foreach ($courses as $course) {
70             $context = get_context_instance(CONTEXT_COURSE, $course->id);
71             try {
72                 self::validate_context($context);
73             } catch (Exception $e) {
74                 // current user can not access this course, sorry we can not disclose who is enrolled in this course!
75                 continue;
76             }
77             if ($userid != $USER->id and !has_capability('moodle/course:viewparticipants', $context)) {
78                 // we need capability to view participants
79                 continue;
80             }
82             $result[] = array('id'=>$course->id, 'shortname'=>$course->shortname, 'fullname'=>$course->fullname, 'idnumber'=>$course->idnumber,'visible'=>$course->visible);
83         }
85         return $result;
86     }
88     /**
89      * Returns description of method result value
90      * @return external_description
91      */
92     public static function get_users_courses_returns() {
93         return new external_multiple_structure(
94             new external_single_structure(
95                 array(
96                     'id'        => new external_value(PARAM_INT, 'id of course'),
97                     'shortname' => new external_value(PARAM_RAW, 'short name of course'),
98                     'fullname'  => new external_value(PARAM_RAW, 'long name of course'),
99                     'idnumber'  => new external_value(PARAM_RAW, 'id number of course'),
100                     'visible'   => new external_value(PARAM_INT, '1 means visible, 0 means hidden course'),
101                 )
102             )
103         );
104     }
106     /**
107      * Returns description of method parameters
108      * @return external_function_parameters
109      */
110     public static function get_enrolled_users_parameters() {
111         return new external_function_parameters(
112             array(
113                 'courseid' => new external_value(PARAM_INT, 'course id'),
114                 'options'  => new external_multiple_structure(
115                     new external_single_structure(
116                         array(
117                             'name'  => new external_value(PARAM_ALPHANUMEXT, 'option name'),
118                             'value' => new external_value(PARAM_RAW, 'option value')
119                         )
120                     ), 'method options', VALUE_DEFAULT, array()),
121             )
122         );
123     }
125     /**
126      * Get course participants details
127      * @param int $courseid  course id
128      * @param array $options options {
129      *          'name' => option name
130      *          'value' => option value
131      * }
132      * @return array An array of users
133      */
134     public static function get_enrolled_users($courseid, $options) {
135         global $CFG, $USER, $DB;
136         require_once($CFG->dirroot . "/user/lib.php");
138         $params = self::validate_parameters(
139             self::get_enrolled_users_parameters(),
140             array(
141                 'courseid'=>$courseid,
142                 'options'=>$options
143             )
144         );
145         $withcapability = '';
146         $groupid        = 0;
147         $onlyactive     = false;
148         foreach ($options as $option) {
149             switch ($option['name']) {
150             case 'withcapability':
151                 $withcapability = $option['value'];
152                 break;
153             case 'groupid':
154                 $groupid = (int)$option['value'];
155                 break;
156             case 'onlyactive':
157                 $onlyactive = !empty($option['value']);
158                 break;
159             }
160         }
162         // to overwrite this parameter, you need role:review capability
163         if ($withcapability) {
164             require_capability('moodle/role:review', $coursecontext);
165         }
166         // need accessallgroups capability if you want to overwrite this option
167         if (!empty($groupid) && groups_is_member($groupid)) {
168             require_capability('moodle/site:accessallgroups', $context);
169         }
170         // to overwrite this option, you need course:enrolereview permission
171         if ($onlyactive) {
172             require_capability('moodle/course:enrolreview', $coursecontext);
173         }
175         list($coursectxselect, $coursectxjoin) = context_instance_preload_sql('c.id', CONTEXT_COURSE, 'ctx');
176         $coursesql = "SELECT c.* $coursectxselect
177                         FROM {course} c $coursectxjoin
178                        WHERE c.id = $courseid";
179         $course = $DB->get_record_sql($coursesql);
180         context_instance_preload($course);
181         $coursecontext = get_context_instance(CONTEXT_COURSE, $params['courseid']);
182         if ($courseid == SITEID) {
183             $context = get_system_context();
184         } else {
185             $context = $coursecontext;
186         }
187         try {
188             self::validate_context($context);
189         } catch (Exception $e) {
190             $exceptionparam = new stdClass();
191             $exceptionparam->message = $e->getMessage();
192             $exceptionparam->courseid = $params['courseid'];
193             throw new moodle_exception(get_string('errorcoursecontextnotvalid' , 'webservice', $exceptionparam));
194         }
196         list($enrolledsql, $enrolledparams) = get_enrolled_sql($coursecontext, $withcapability, $groupid, $onlyactive);
197         list($ctxselect, $ctxjoin) = context_instance_preload_sql('u.id', CONTEXT_USER, 'ctx');
198         $records = $DB->get_records_sql($enrolledsql, $enrolledparams);
199         $sqlparams['courseid'] = $courseid;
200         $sql = "SELECT u.* $ctxselect
201                   FROM {user} u $ctxjoin
202                  WHERE u.id IN ($enrolledsql)
203                  ORDER BY u.id ASC";
204         $enrolledusers = $DB->get_recordset_sql($sql, $enrolledparams);
205         $users = array();
206         foreach ($enrolledusers as $user) {
207             if (!empty($user->deleted)) {
208                 continue;
209             }
210             context_instance_preload($user);
211             if ($userdetails = user_get_user_details($user, $course)) {
212                 $users[] = $userdetails;
213             }
214         }
215         $enrolledusers->close();
217         return $users;
218     }
220     /**
221      * Returns description of method result value
222      * @return external_description
223      */
224     public static function get_enrolled_users_returns() {
225         return new external_multiple_structure(
226             new external_single_structure(
227                 array(
228                     'id'    => new external_value(PARAM_NUMBER, 'ID of the user'),
229                     'username'    => new external_value(PARAM_RAW, 'Username policy is defined in Moodle security config', VALUE_OPTIONAL),
230                     'firstname'   => new external_value(PARAM_NOTAGS, 'The first name(s) of the user', VALUE_OPTIONAL),
231                     'lastname'    => new external_value(PARAM_NOTAGS, 'The family name of the user', VALUE_OPTIONAL),
232                     'fullname'    => new external_value(PARAM_NOTAGS, 'The fullname of the user'),
233                     'email'       => new external_value(PARAM_TEXT, 'An email address - allow email as root@localhost', VALUE_OPTIONAL),
234                     'address'     => new external_value(PARAM_MULTILANG, 'Postal address', VALUE_OPTIONAL),
235                     'phone1'      => new external_value(PARAM_NOTAGS, 'Phone 1', VALUE_OPTIONAL),
236                     'phone2'      => new external_value(PARAM_NOTAGS, 'Phone 2', VALUE_OPTIONAL),
237                     'icq'         => new external_value(PARAM_NOTAGS, 'icq number', VALUE_OPTIONAL),
238                     'skype'       => new external_value(PARAM_NOTAGS, 'skype id', VALUE_OPTIONAL),
239                     'yahoo'       => new external_value(PARAM_NOTAGS, 'yahoo id', VALUE_OPTIONAL),
240                     'aim'         => new external_value(PARAM_NOTAGS, 'aim id', VALUE_OPTIONAL),
241                     'msn'         => new external_value(PARAM_NOTAGS, 'msn number', VALUE_OPTIONAL),
242                     'department'  => new external_value(PARAM_TEXT, 'department', VALUE_OPTIONAL),
243                     'institution' => new external_value(PARAM_TEXT, 'institution', VALUE_OPTIONAL),
244                     'interests'   => new external_value(PARAM_TEXT, 'user interests (separated by commas)', VALUE_OPTIONAL),
245                     'firstaccess' => new external_value(PARAM_INT, 'first access to the site (0 if never)', VALUE_OPTIONAL),
246                     'lastaccess'  => new external_value(PARAM_INT, 'last access to the site (0 if never)', VALUE_OPTIONAL),
247                     'description' => new external_value(PARAM_RAW, 'User profile description', VALUE_OPTIONAL),
248                     'descriptionformat' => new external_value(PARAM_INT, 'User profile description format', VALUE_OPTIONAL),
249                     'city'        => new external_value(PARAM_NOTAGS, 'Home city of the user', VALUE_OPTIONAL),
250                     'url'         => new external_value(PARAM_URL, 'URL of the user', VALUE_OPTIONAL),
251                     'country'     => new external_value(PARAM_ALPHA, 'Home country code of the user, such as AU or CZ', VALUE_OPTIONAL),
252                     'profileimageurlsmall' => new external_value(PARAM_URL, 'User image profile URL - small version'),
253                     'profileimageurl' => new external_value(PARAM_URL, 'User image profile URL - big version'),
254                     'customfields' => new external_multiple_structure(
255                         new external_single_structure(
256                             array(
257                                 'type'  => new external_value(PARAM_ALPHANUMEXT, 'The type of the custom field - text field, checkbox...'),
258                                 'value' => new external_value(PARAM_RAW, 'The value of the custom field'),
259                                 'name' => new external_value(PARAM_RAW, 'The name of the custom field'),
260                                 'shortname' => new external_value(PARAM_RAW, 'The shortname of the custom field - to be able to build the field class in the code'),
261                             )
262                         ), 'User custom fields (also known as user profil fields)', VALUE_OPTIONAL),
263                     'groups' => new external_multiple_structure(
264                         new external_single_structure(
265                             array(
266                                 'id'  => new external_value(PARAM_INT, 'group id'),
267                                 'name' => new external_value(PARAM_RAW, 'group name'),
268                                 'description' => new external_value(PARAM_RAW, 'group description'),
269                             )
270                         ), 'user groups', VALUE_OPTIONAL),
271                     'roles' => new external_multiple_structure(
272                         new external_single_structure(
273                             array(
274                                 'roleid'       => new external_value(PARAM_INT, 'role id'),
275                                 'name'         => new external_value(PARAM_RAW, 'role name'),
276                                 'shortname'    => new external_value(PARAM_ALPHANUMEXT, 'role shortname'),
277                                 'sortorder'    => new external_value(PARAM_INT, 'role sortorder')
278                             )
279                         ), 'user roles', VALUE_OPTIONAL),
280                     'preferences' => new external_multiple_structure(
281                         new external_single_structure(
282                             array(
283                                 'name'  => new external_value(PARAM_ALPHANUMEXT, 'The name of the preferences'),
284                                 'value' => new external_value(PARAM_RAW, 'The value of the custom field'),
285                             )
286                     ), 'User preferences', VALUE_OPTIONAL),
287                     'enrolledcourses' => new external_multiple_structure(
288                         new external_single_structure(
289                             array(
290                                 'id'  => new external_value(PARAM_INT, 'Id of the course'),
291                                 'fullname' => new external_value(PARAM_RAW, 'Fullname of the course'),
292                                 'shortname' => new external_value(PARAM_RAW, 'Shortname of the course')
293                             )
294                     ), 'Courses where the user is enrolled - limited by which courses the user is able to see', VALUE_OPTIONAL)
295                 )
296             )
297         );
298     }
302 /**
303  * Role functions
304  */
305 class core_role_external extends external_api {
307     /**
308      * Returns description of method parameters
309      * @return external_function_parameters
310      */
311     public static function assign_roles_parameters() {
312         return new external_function_parameters(
313             array(
314                 'assignments' => new external_multiple_structure(
315                     new external_single_structure(
316                         array(
317                             'roleid'    => new external_value(PARAM_INT, 'Role to assign to the user'),
318                             'userid'    => new external_value(PARAM_INT, 'The user that is going to be assigned'),
319                             'contextid' => new external_value(PARAM_INT, 'The context to assign the user role in'),
320                         )
321                     )
322                 )
323             )
324         );
325     }
327     /**
328      * Manual role assignments to users
329      *
330      * @param array $assignment  An array of manual role assignment
331      * @return null
332      */
333     public static function assign_roles($assignments) {
334         global $DB;
336         // Do basic automatic PARAM checks on incoming data, using params description
337         // If any problems are found then exceptions are thrown with helpful error messages
338         $params = self::validate_parameters(self::assign_roles_parameters(), array('assignments'=>$assignments));
340         $transaction = $DB->start_delegated_transaction();
342         foreach ($params['assignments'] as $assignment) {
343             // Ensure the current user is allowed to run this function in the enrolment context
344             $context = get_context_instance_by_id($assignment['contextid']);
345             self::validate_context($context);
346             require_capability('moodle/role:assign', $context);
348             // throw an exception if user is not able to assign the role in this context
349             $roles = get_assignable_roles($context, ROLENAME_SHORT);
351             if (!key_exists($assignment['roleid'], $roles)) {
352                 throw new invalid_parameter_exception('Can not assign roleid='.$assignment['roleid'].' in contextid='.$assignment['contextid']);
353             }
355             role_assign($assignment['roleid'], $assignment['userid'], $assignment['contextid']);
356         }
358         $transaction->allow_commit();
359     }
361     /**
362      * Returns description of method result value
363      * @return external_description
364      */
365     public static function assign_roles_returns() {
366         return null;
367     }
370     /**
371      * Returns description of method parameters
372      * @return external_function_parameters
373      */
374     public static function unassign_roles_parameters() {
375         return new external_function_parameters(
376             array(
377                 'unassignments' => new external_multiple_structure(
378                     new external_single_structure(
379                         array(
380                             'roleid'    => new external_value(PARAM_INT, 'Role to assign to the user'),
381                             'userid'    => new external_value(PARAM_INT, 'The user that is going to be assigned'),
382                             'contextid' => new external_value(PARAM_INT, 'The context to unassign the user role from'),
383                         )
384                     )
385                 )
386             )
387         );
388     }
390      /**
391      * Unassign roles from users
392      *
393      * @param array $unassignment  An array of unassignment
394      * @return null
395      */
396     public static function unassign_roles($unassignments) {
397          global $DB;
399         // Do basic automatic PARAM checks on incoming data, using params description
400         // If any problems are found then exceptions are thrown with helpful error messages
401         $params = self::validate_parameters(self::unassign_roles_parameters(), array('unassignments'=>$unassignments));
403         $transaction = $DB->start_delegated_transaction();
405         foreach ($params['unassignments'] as $unassignment) {
406             // Ensure the current user is allowed to run this function in the unassignment context
407             $context = get_context_instance_by_id($unassignment['contextid']);
408             self::validate_context($context);
409             require_capability('moodle/role:assign', $context);
411             // throw an exception if user is not able to unassign the role in this context
412             $roles = get_assignable_roles($context, ROLENAME_SHORT);
413             if (!key_exists($unassignment['roleid'], $roles)) {
414                 throw new invalid_parameter_exception('Can not unassign roleid='.$unassignment['roleid'].' in contextid='.$unassignment['contextid']);
415             }
417             role_unassign($unassignment['roleid'], $unassignment['userid'], $unassignment['contextid']);
418         }
420         $transaction->allow_commit();
421     }
423    /**
424      * Returns description of method result value
425      * @return null
426      */
427     public static function unassign_roles_returns() {
428         return null;
429     }
433 /**
434  * Deprecated enroll and role functions
435  * @deprecated since Moodle 2.2 please use core_enrol_external or core_role_external instead
436  */
437 class moodle_enrol_external extends external_api {
440     /**
441      * Returns description of method parameters
442      * @deprecated since Moodle 2.2 please use core_enrol_external::get_enrolled_users_parameters() instead
443      * @return external_function_parameters
444      */
445     public static function get_enrolled_users_parameters() {
446         return new external_function_parameters(
447             array(
448                 'courseid'       => new external_value(PARAM_INT, 'Course id'),
449                 'withcapability' => new external_value(PARAM_CAPABILITY, 'User should have this capability', VALUE_DEFAULT, null),
450                 'groupid'        => new external_value(PARAM_INT, 'Group id, null means all groups', VALUE_DEFAULT, null),
451                 'onlyactive'     => new external_value(PARAM_INT, 'True means only active, false means all participants', VALUE_DEFAULT, 0),
452             )
453         );
454     }
456     /**
457      * Get list of course participants.
458      * @deprecated since Moodle 2.2 please use core_enrol_external::get_enrolled_users() instead
459      * @param int $courseid
460      * @param text $withcapability
461      * @param int $groupid
462      * @param bool $onlyactive
463      * @return array of course participants
464      */
465     public static function get_enrolled_users($courseid, $withcapability = null, $groupid = null, $onlyactive = false) {
466         global $DB, $CFG, $USER;
468         // Do basic automatic PARAM checks on incoming data, using params description
469         // If any problems are found then exceptions are thrown with helpful error messages
470         $params = self::validate_parameters(self::get_enrolled_users_parameters(), array(
471             'courseid'=>$courseid,
472             'withcapability'=>$withcapability,
473             'groupid'=>$groupid,
474             'onlyactive'=>$onlyactive)
475         );
477         $coursecontext = get_context_instance(CONTEXT_COURSE, $params['courseid']);
478         if ($courseid == SITEID) {
479             $context = get_context_instance(CONTEXT_SYSTEM);
480         } else {
481             $context = $coursecontext;
482         }
484         try {
485             self::validate_context($context);
486         } catch (Exception $e) {
487             $exceptionparam = new stdClass();
488             $exceptionparam->message = $e->getMessage();
489             $exceptionparam->courseid = $params['courseid'];
490             throw new moodle_exception(get_string('errorcoursecontextnotvalid' , 'webservice', $exceptionparam));
491         }
493         if ($courseid == SITEID) {
494             require_capability('moodle/site:viewparticipants', $context);
495         } else {
496             require_capability('moodle/course:viewparticipants', $context);
497         }
499         if ($withcapability) {
500             require_capability('moodle/role:review', $coursecontext);
501         }
502         if ($groupid && groups_is_member($groupid)) {
503             require_capability('moodle/site:accessallgroups', $coursecontext);
504         }
505         if ($onlyactive) {
506             require_capability('moodle/course:enrolreview', $coursecontext);
507         }
509         list($sqlparams, $params) =  get_enrolled_sql($coursecontext, $withcapability, $groupid, $onlyactive);
510         $sql = "SELECT ue.userid, e.courseid, u.firstname, u.lastname, u.username, c.id as usercontextid
511                   FROM {user_enrolments} ue
512                   JOIN {enrol} e ON (e.id = ue.enrolid)
513                   JOIN {user} u ON (ue.userid = u.id)
514                   JOIN {context} c ON (u.id = c.instanceid AND contextlevel = " . CONTEXT_USER . ")
515                   WHERE e.courseid = :courseid AND ue.userid IN ($sqlparams)
516                   GROUP BY ue.userid, e.courseid, u.firstname, u.lastname, u.username, c.id";
517         $params['courseid'] = $courseid;
518         $enrolledusers = $DB->get_records_sql($sql, $params);
519         $result = array();
520         $isadmin = is_siteadmin($USER);
521         $canviewfullnames = has_capability('moodle/site:viewfullnames', $context);
522         foreach ($enrolledusers as $enrolleduser) {
523             $profilimgurl = moodle_url::make_pluginfile_url($enrolleduser->usercontextid, 'user', 'icon', NULL, '/', 'f1');
524             $profilimgurlsmall = moodle_url::make_pluginfile_url($enrolleduser->usercontextid, 'user', 'icon', NULL, '/', 'f2');
525             $resultuser = array(
526                 'courseid' => $enrolleduser->courseid,
527                 'userid' => $enrolleduser->userid,
528                 'fullname' => fullname($enrolleduser),
529                 'profileimgurl' => $profilimgurl->out(false),
530                 'profileimgurlsmall' => $profilimgurlsmall->out(false)
531             );
532             // check if we can return username
533             if ($isadmin) {
534                 $resultuser['username'] = $enrolleduser->username;
535             }
536             // check if we can return first and last name
537             if ($isadmin or $canviewfullnames) {
538                 $resultuser['firstname'] = $enrolleduser->firstname;
539                 $resultuser['lastname'] = $enrolleduser->lastname;
540             }
541             $result[] = $resultuser;
542         }
544         return $result;
545     }
547     /**
548      * Returns description of method result value
549      * @deprecated since Moodle 2.2 please use core_enrol_external::get_enrolled_users_returns() instead
550      * @return external_description
551      */
552     public static function get_enrolled_users_returns() {
553         return new external_multiple_structure(
554             new external_single_structure(
555                 array(
556                     'courseid' => new external_value(PARAM_INT, 'id of course'),
557                     'userid' => new external_value(PARAM_INT, 'id of user'),
558                     'firstname' => new external_value(PARAM_RAW, 'first name of user', VALUE_OPTIONAL),
559                     'lastname' => new external_value(PARAM_RAW, 'last name of user', VALUE_OPTIONAL),
560                     'fullname' => new external_value(PARAM_RAW, 'fullname of user'),
561                     'username' => new external_value(PARAM_RAW, 'username of user', VALUE_OPTIONAL),
562                     'profileimgurl' => new external_value(PARAM_URL, 'url of the profile image'),
563                     'profileimgurlsmall' => new external_value(PARAM_URL, 'url of the profile image (small version)')
564                 )
565             )
566         );
567     }
569     /**
570      * Returns description of method parameters
571      * @deprecated since Moodle 2.2 please use core_enrol_external::get_users_courses_parameters() instead
572      * @return external_function_parameters
573      */
574     public static function get_users_courses_parameters() {
575         return core_enrol_external::get_users_courses_parameters();
576     }
578     /**
579      * Get list of courses user is enrolled in (only active enrolments are returned).
580      *
581      * Please note the current user must be able to access the course, otherwise the course is not included.
582      * @deprecated since Moodle 2.2 please use core_enrol_external::get_users_courses() instead
583      * @param int $userid
584      * @return array of courses
585      */
586     public static function get_users_courses($userid) {
587         return core_enrol_external::get_users_courses($userid);
588     }
590     /**
591      * Returns description of method result value
592      * @deprecated since Moodle 2.2 please use core_enrol_external::get_users_courses_returns() instead
593      * @return external_description
594      */
595     public static function get_users_courses_returns() {
596         return core_enrol_external::get_users_courses_returns();
597     }
600     /**
601      * Returns description of method parameters
602      * @deprecated since Moodle 2.2 please use core_role_external::assign_roles_parameters() instead
603      * @return external_function_parameters
604      */
605     public static function role_assign_parameters() {
606         return core_role_external::assign_roles_parameters();
607     }
609     /**
610      * Manual role assignments to users
611      * @deprecated since Moodle 2.2 please use core_role_external::assign_roles() instead
612      * @param array $assignment  An array of manual role assignment
613      * @return null
614      */
615     public static function role_assign($assignments) {
616         return core_role_external::assign_roles($assignments);
617     }
619     /**
620      * Returns description of method result value
621      * @deprecated since Moodle 2.2 please use core_role_external::assign_roles_returns() instead
622      * @return external_description
623      */
624     public static function role_assign_returns() {
625         return core_role_external::assign_roles_returns();
626     }
629     /**
630      * Returns description of method parameters
631      * @deprecated since Moodle 2.2 please use core_role_external::unassign_roles_parameters() instead
632      * @return external_function_parameters
633      */
634     public static function role_unassign_parameters() {
635         return core_role_external::unassign_roles_parameters();
636     }
638      /**
639      * Unassign roles from users
640      * @deprecated since Moodle 2.2 please use core_role_external::unassign_roles() instead
641      * @param array $unassignment  An array of unassignment
642      * @return null
643      */
644     public static function role_unassign($unassignments) {
645          return core_role_external::unassign_roles($unassignments);
646     }
648    /**
649      * Returns description of method result value
650     * @deprecated since Moodle 2.2 please use core_role_external::unassign_roles_returns() instead
651      * @return external_description
652      */
653     public static function role_unassign_returns() {
654         return core_role_external::unassign_roles_returns();
655     }