[Summary view] [Print] [Text view]

   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   * External cohort API
  19   *
  20   * @package    core_cohort
  21   * @category   external
  22   * @copyright  MediaTouch 2000 srl
  23   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  24   */
  25  
  26  require_once("$CFG->libdir/externallib.php");
  27  
  28  class core_cohort_external extends external_api {
  29  
  30      /**
  31       * Returns description of method parameters
  32       *
  33       * @return external_function_parameters
  34       * @since Moodle 2.5
  35       */
  36      public static function create_cohorts_parameters() {
  37          return new external_function_parameters(
  38              array(
  39                  'cohorts' => new external_multiple_structure(
  40                      new external_single_structure(
  41                          array(
  42                              'categorytype' => new external_single_structure(
  43                                  array(
  44                                      'type' => new external_value(PARAM_TEXT, 'the name of the field: id (numeric value
  45                                          of course category id) or idnumber (alphanumeric value of idnumber course category)
  46                                          or system (value ignored)'),
  47                                      'value' => new external_value(PARAM_RAW, 'the value of the categorytype')
  48                                  )
  49                              ),
  50                              'name' => new external_value(PARAM_RAW, 'cohort name'),
  51                              'idnumber' => new external_value(PARAM_RAW, 'cohort idnumber'),
  52                              'description' => new external_value(PARAM_RAW, 'cohort description', VALUE_OPTIONAL),
  53                              'descriptionformat' => new external_format_value('description', VALUE_DEFAULT),
  54                              'visible' => new external_value(PARAM_BOOL, 'cohort visible', VALUE_OPTIONAL, true),
  55                          )
  56                      )
  57                  )
  58              )
  59          );
  60      }
  61  
  62      /**
  63       * Create one or more cohorts
  64       *
  65       * @param array $cohorts An array of cohorts to create.
  66       * @return array An array of arrays
  67       * @since Moodle 2.5
  68       */
  69      public static function create_cohorts($cohorts) {
  70          global $CFG, $DB;
  71          require_once("$CFG->dirroot/cohort/lib.php");
  72  
  73          $params = self::validate_parameters(self::create_cohorts_parameters(), array('cohorts' => $cohorts));
  74  
  75          $transaction = $DB->start_delegated_transaction();
  76  
  77          $syscontext = context_system::instance();
  78          $cohortids = array();
  79  
  80          foreach ($params['cohorts'] as $cohort) {
  81              $cohort = (object)$cohort;
  82  
  83              // Category type (context id).
  84              $categorytype = $cohort->categorytype;
  85              if (!in_array($categorytype['type'], array('idnumber', 'id', 'system'))) {
  86                  throw new invalid_parameter_exception('category type must be id, idnumber or system:' . $categorytype['type']);
  87              }
  88              if ($categorytype['type'] === 'system') {
  89                  $cohort->contextid = $syscontext->id;
  90              } else if ($catid = $DB->get_field('course_categories', 'id', array($categorytype['type'] => $categorytype['value']))) {
  91                  $catcontext = context_coursecat::instance($catid);
  92                  $cohort->contextid = $catcontext->id;
  93              } else {
  94                  throw new invalid_parameter_exception('category not exists: category '
  95                      .$categorytype['type'].' = '.$categorytype['value']);
  96              }
  97              // Make sure that the idnumber doesn't already exist.
  98              if ($DB->record_exists('cohort', array('idnumber' => $cohort->idnumber))) {
  99                  throw new invalid_parameter_exception('record already exists: idnumber='.$cohort->idnumber);
 100              }
 101              $context = context::instance_by_id($cohort->contextid, MUST_EXIST);
 102              if ($context->contextlevel != CONTEXT_COURSECAT and $context->contextlevel != CONTEXT_SYSTEM) {
 103                  throw new invalid_parameter_exception('Invalid context');
 104              }
 105              self::validate_context($context);
 106              require_capability('moodle/cohort:manage', $context);
 107  
 108              // Validate format.
 109              $cohort->descriptionformat = external_validate_format($cohort->descriptionformat);
 110              $cohort->id = cohort_add_cohort($cohort);
 111  
 112              list($cohort->description, $cohort->descriptionformat) =
 113                  external_format_text($cohort->description, $cohort->descriptionformat,
 114                          $context->id, 'cohort', 'description', $cohort->id);
 115              $cohortids[] = (array)$cohort;
 116          }
 117          $transaction->allow_commit();
 118  
 119          return $cohortids;
 120      }
 121  
 122      /**
 123       * Returns description of method result value
 124       *
 125       * @return external_description
 126       * @since Moodle 2.5
 127       */
 128      public static function create_cohorts_returns() {
 129          return new external_multiple_structure(
 130              new external_single_structure(
 131                  array(
 132                      'id' => new external_value(PARAM_INT, 'cohort id'),
 133                      'name' => new external_value(PARAM_RAW, 'cohort name'),
 134                      'idnumber' => new external_value(PARAM_RAW, 'cohort idnumber'),
 135                      'description' => new external_value(PARAM_RAW, 'cohort description'),
 136                      'descriptionformat' => new external_format_value('description'),
 137                      'visible' => new external_value(PARAM_BOOL, 'cohort visible'),
 138                  )
 139              )
 140          );
 141      }
 142  
 143      /**
 144       * Returns description of method parameters
 145       *
 146       * @return external_function_parameters
 147       * @since Moodle 2.5
 148       */
 149      public static function delete_cohorts_parameters() {
 150          return new external_function_parameters(
 151              array(
 152                  'cohortids' => new external_multiple_structure(new external_value(PARAM_INT, 'cohort ID')),
 153              )
 154          );
 155      }
 156  
 157      /**
 158       * Delete cohorts
 159       *
 160       * @param array $cohortids
 161       * @return null
 162       * @since Moodle 2.5
 163       */
 164      public static function delete_cohorts($cohortids) {
 165          global $CFG, $DB;
 166          require_once("$CFG->dirroot/cohort/lib.php");
 167  
 168          $params = self::validate_parameters(self::delete_cohorts_parameters(), array('cohortids' => $cohortids));
 169  
 170          $transaction = $DB->start_delegated_transaction();
 171  
 172          foreach ($params['cohortids'] as $cohortid) {
 173              // Validate params.
 174              $cohortid = validate_param($cohortid, PARAM_INT);
 175              $cohort = $DB->get_record('cohort', array('id' => $cohortid), '*', MUST_EXIST);
 176  
 177              // Now security checks.
 178              $context = context::instance_by_id($cohort->contextid, MUST_EXIST);
 179              if ($context->contextlevel != CONTEXT_COURSECAT and $context->contextlevel != CONTEXT_SYSTEM) {
 180                  throw new invalid_parameter_exception('Invalid context');
 181              }
 182              self::validate_context($context);
 183              require_capability('moodle/cohort:manage', $context);
 184              cohort_delete_cohort($cohort);
 185          }
 186          $transaction->allow_commit();
 187  
 188          return null;
 189      }
 190  
 191      /**
 192       * Returns description of method result value
 193       *
 194       * @return null
 195       * @since Moodle 2.5
 196       */
 197      public static function delete_cohorts_returns() {
 198          return null;
 199      }
 200  
 201      /**
 202       * Returns description of method parameters
 203       *
 204       * @return external_function_parameters
 205       * @since Moodle 2.5
 206       */
 207      public static function get_cohorts_parameters() {
 208          return new external_function_parameters(
 209              array(
 210                  'cohortids' => new external_multiple_structure(new external_value(PARAM_INT, 'Cohort ID')
 211                      , 'List of cohort id. A cohort id is an integer.'),
 212              )
 213          );
 214      }
 215  
 216      /**
 217       * Get cohorts definition specified by ids
 218       *
 219       * @param array $cohortids array of cohort ids
 220       * @return array of cohort objects (id, courseid, name)
 221       * @since Moodle 2.5
 222       */
 223      public static function get_cohorts($cohortids) {
 224          global $DB;
 225  
 226          $params = self::validate_parameters(self::get_cohorts_parameters(), array('cohortids' => $cohortids));
 227  
 228          $cohorts = array();
 229          foreach ($params['cohortids'] as $cohortid) {
 230              // Validate params.
 231              $cohort = $DB->get_record('cohort', array('id' => $cohortid), '*', MUST_EXIST);
 232  
 233              // Now security checks.
 234              $context = context::instance_by_id($cohort->contextid, MUST_EXIST);
 235              if ($context->contextlevel != CONTEXT_COURSECAT and $context->contextlevel != CONTEXT_SYSTEM) {
 236                  throw new invalid_parameter_exception('Invalid context');
 237              }
 238              self::validate_context($context);
 239              if (!has_any_capability(array('moodle/cohort:manage', 'moodle/cohort:view'), $context)) {
 240                  throw new required_capability_exception($context, 'moodle/cohort:view', 'nopermissions', '');
 241              }
 242  
 243              list($cohort->description, $cohort->descriptionformat) =
 244                  external_format_text($cohort->description, $cohort->descriptionformat,
 245                          $context->id, 'cohort', 'description', $cohort->id);
 246  
 247              $cohorts[] = (array) $cohort;
 248          }
 249  
 250          return $cohorts;
 251      }
 252  
 253      /**
 254       * Returns description of method result value
 255       *
 256       * @return external_description
 257       * @since Moodle 2.5
 258       */
 259      public static function get_cohorts_returns() {
 260          return new external_multiple_structure(
 261              new external_single_structure(
 262                  array(
 263                      'id' => new external_value(PARAM_INT, 'ID of the cohort'),
 264                      'name' => new external_value(PARAM_RAW, 'cohort name'),
 265                      'idnumber' => new external_value(PARAM_RAW, 'cohort idnumber'),
 266                      'description' => new external_value(PARAM_RAW, 'cohort description'),
 267                      'descriptionformat' => new external_format_value('description'),
 268                      'visible' => new external_value(PARAM_BOOL, 'cohort visible'),
 269                  )
 270              )
 271          );
 272      }
 273  
 274      /**
 275       * Returns description of method parameters
 276       *
 277       * @return external_function_parameters
 278       * @since Moodle 2.5
 279       */
 280      public static function update_cohorts_parameters() {
 281          return new external_function_parameters(
 282              array(
 283                  'cohorts' => new external_multiple_structure(
 284                      new external_single_structure(
 285                          array(
 286                              'id' => new external_value(PARAM_INT, 'ID of the cohort'),
 287                              'categorytype' => new external_single_structure(
 288                                  array(
 289                                      'type' => new external_value(PARAM_TEXT, 'the name of the field: id (numeric value
 290                                          of course category id) or idnumber (alphanumeric value of idnumber course category)
 291                                          or system (value ignored)'),
 292                                      'value' => new external_value(PARAM_RAW, 'the value of the categorytype')
 293                                  )
 294                              ),
 295                              'name' => new external_value(PARAM_RAW, 'cohort name'),
 296                              'idnumber' => new external_value(PARAM_RAW, 'cohort idnumber'),
 297                              'description' => new external_value(PARAM_RAW, 'cohort description', VALUE_OPTIONAL),
 298                              'descriptionformat' => new external_format_value('description', VALUE_DEFAULT),
 299                              'visible' => new external_value(PARAM_BOOL, 'cohort visible', VALUE_OPTIONAL),
 300                          )
 301                      )
 302                  )
 303              )
 304          );
 305      }
 306  
 307      /**
 308       * Update cohorts
 309       *
 310       * @param array $cohorts
 311       * @return null
 312       * @since Moodle 2.5
 313       */
 314      public static function update_cohorts($cohorts) {
 315          global $CFG, $DB;
 316          require_once("$CFG->dirroot/cohort/lib.php");
 317  
 318          $params = self::validate_parameters(self::update_cohorts_parameters(), array('cohorts' => $cohorts));
 319  
 320          $transaction = $DB->start_delegated_transaction();
 321          $syscontext = context_system::instance();
 322  
 323          foreach ($params['cohorts'] as $cohort) {
 324              $cohort = (object) $cohort;
 325  
 326              if (trim($cohort->name) == '') {
 327                  throw new invalid_parameter_exception('Invalid cohort name');
 328              }
 329  
 330              $oldcohort = $DB->get_record('cohort', array('id' => $cohort->id), '*', MUST_EXIST);
 331              $oldcontext = context::instance_by_id($oldcohort->contextid, MUST_EXIST);
 332              require_capability('moodle/cohort:manage', $oldcontext);
 333  
 334              // Category type (context id).
 335              $categorytype = $cohort->categorytype;
 336              if (!in_array($categorytype['type'], array('idnumber', 'id', 'system'))) {
 337                  throw new invalid_parameter_exception('category type must be id, idnumber or system:' . $categorytype['type']);
 338              }
 339              if ($categorytype['type'] === 'system') {
 340                  $cohort->contextid = $syscontext->id;
 341              } else if ($catid = $DB->get_field('course_categories', 'id', array($categorytype['type'] => $categorytype['value']))) {
 342                  $cohort->contextid = $DB->get_field('context', 'id', array('instanceid' => $catid,
 343                      'contextlevel' => CONTEXT_COURSECAT));
 344              } else {
 345                  throw new invalid_parameter_exception('category not exists: category='.$categorytype['value']);
 346              }
 347  
 348              if ($cohort->contextid != $oldcohort->contextid) {
 349                  $context = context::instance_by_id($cohort->contextid, MUST_EXIST);
 350                  if ($context->contextlevel != CONTEXT_COURSECAT and $context->contextlevel != CONTEXT_SYSTEM) {
 351                      throw new invalid_parameter_exception('Invalid context');
 352                  }
 353  
 354                  self::validate_context($context);
 355                  require_capability('moodle/cohort:manage', $context);
 356              }
 357  
 358              if (!empty($cohort->description)) {
 359                  $cohort->descriptionformat = external_validate_format($cohort->descriptionformat);
 360              }
 361  
 362              cohort_update_cohort($cohort);
 363          }
 364  
 365          $transaction->allow_commit();
 366  
 367          return null;
 368      }
 369  
 370      /**
 371       * Returns description of method result value
 372       *
 373       * @return null
 374       * @since Moodle 2.5
 375       */
 376      public static function update_cohorts_returns() {
 377          return null;
 378      }
 379  
 380      /**
 381       * Returns description of method parameters
 382       *
 383       * @return external_function_parameters
 384       * @since Moodle 2.5
 385       */
 386      public static function add_cohort_members_parameters() {
 387          return new external_function_parameters (
 388              array(
 389                  'members' => new external_multiple_structure (
 390                      new external_single_structure (
 391                          array (
 392                              'cohorttype' => new external_single_structure (
 393                                  array(
 394                                      'type' => new external_value(PARAM_ALPHANUMEXT, 'The name of the field: id
 395                                          (numeric value of cohortid) or idnumber (alphanumeric value of idnumber) '),
 396                                      'value' => new external_value(PARAM_RAW, 'The value of the cohort')
 397                                  )
 398                              ),
 399                              'usertype' => new external_single_structure (
 400                                  array(
 401                                      'type' => new external_value(PARAM_ALPHANUMEXT, 'The name of the field: id
 402                                          (numeric value of id) or username (alphanumeric value of username) '),
 403                                      'value' => new external_value(PARAM_RAW, 'The value of the cohort')
 404                                  )
 405                              )
 406                          )
 407                      )
 408                  )
 409              )
 410          );
 411      }
 412  
 413      /**
 414       * Add cohort members
 415       *
 416       * @param array $members of arrays with keys userid, cohortid
 417       * @since Moodle 2.5
 418       */
 419      public static function add_cohort_members($members) {
 420          global $CFG, $DB;
 421          require_once($CFG->dirroot."/cohort/lib.php");
 422  
 423          $params = self::validate_parameters(self::add_cohort_members_parameters(), array('members' => $members));
 424  
 425          $transaction = $DB->start_delegated_transaction();
 426          $warnings = array();
 427          foreach ($params['members'] as $member) {
 428              // Cohort parameters.
 429              $cohorttype = $member['cohorttype'];
 430              $cohortparam = array($cohorttype['type'] => $cohorttype['value']);
 431              // User parameters.
 432              $usertype = $member['usertype'];
 433              $userparam = array($usertype['type'] => $usertype['value']);
 434              try {
 435                  // Check parameters.
 436                  if ($cohorttype['type'] != 'id' && $cohorttype['type'] != 'idnumber') {
 437                      $warning = array();
 438                      $warning['warningcode'] = '1';
 439                      $warning['message'] = 'invalid parameter: cohortype='.$cohorttype['type'];
 440                      $warnings[] = $warning;
 441                      continue;
 442                  }
 443                  if ($usertype['type'] != 'id' && $usertype['type'] != 'username') {
 444                      $warning = array();
 445                      $warning['warningcode'] = '1';
 446                      $warning['message'] = 'invalid parameter: usertype='.$usertype['type'];
 447                      $warnings[] = $warning;
 448                      continue;
 449                  }
 450                  // Extract parameters.
 451                  if (!$cohortid = $DB->get_field('cohort', 'id', $cohortparam)) {
 452                      $warning = array();
 453                      $warning['warningcode'] = '2';
 454                      $warning['message'] = 'cohort '.$cohorttype['type'].'='.$cohorttype['value'].' not exists';
 455                      $warnings[] = $warning;
 456                      continue;
 457                  }
 458                  if (!$userid = $DB->get_field('user', 'id', array_merge($userparam, array('deleted' => 0,
 459                      'mnethostid' => $CFG->mnet_localhost_id)))) {
 460                      $warning = array();
 461                      $warning['warningcode'] = '2';
 462                      $warning['message'] = 'user '.$usertype['type'].'='.$usertype['value'].' not exists';
 463                      $warnings[] = $warning;
 464                      continue;
 465                  }
 466                  if ($DB->record_exists('cohort_members', array('cohortid' => $cohortid, 'userid' => $userid))) {
 467                      $warning = array();
 468                      $warning['warningcode'] = '3';
 469                      $warning['message'] = 'record already exists: cohort('.$cohorttype['type'].'='.$cohorttype['value'].' '.
 470                          $usertype['type'].'='.$usertype['value'].')';
 471                      $warnings[] = $warning;
 472                      continue;
 473                  }
 474                  $cohort = $DB->get_record('cohort', array('id'=>$cohortid), '*', MUST_EXIST);
 475                  $context = context::instance_by_id($cohort->contextid, MUST_EXIST);
 476                  if ($context->contextlevel != CONTEXT_COURSECAT and $context->contextlevel != CONTEXT_SYSTEM) {
 477                      $warning = array();
 478                      $warning['warningcode'] = '1';
 479                      $warning['message'] = 'Invalid context: '.$context->contextlevel;
 480                      $warnings[] = $warning;
 481                      continue;
 482                  }
 483                  self::validate_context($context);
 484              } catch (Exception $e) {
 485                  throw new moodle_exception('Error', 'cohort', '', $e->getMessage());
 486              }
 487              if (!has_any_capability(array('moodle/cohort:manage', 'moodle/cohort:assign'), $context)) {
 488                  throw new required_capability_exception($context, 'moodle/cohort:assign', 'nopermissions', '');
 489              }
 490              cohort_add_member($cohortid, $userid);
 491          }
 492          $transaction->allow_commit();
 493          // Return.
 494          $result = array();
 495          $result['warnings'] = $warnings;
 496          return $result;
 497      }
 498  
 499      /**
 500       * Returns description of method result value
 501       *
 502       * @return null
 503       * @since Moodle 2.5
 504       */
 505      public static function add_cohort_members_returns() {
 506          return new external_single_structure(
 507              array(
 508                  'warnings' => new external_warnings()
 509              )
 510          );
 511      }
 512  
 513      /**
 514       * Returns description of method parameters
 515       *
 516       * @return external_function_parameters
 517       * @since Moodle 2.5
 518       */
 519      public static function delete_cohort_members_parameters() {
 520          return new external_function_parameters(
 521              array(
 522                  'members' => new external_multiple_structure(
 523                      new external_single_structure(
 524                          array(
 525                              'cohortid' => new external_value(PARAM_INT, 'cohort record id'),
 526                              'userid' => new external_value(PARAM_INT, 'user id'),
 527                          )
 528                      )
 529                  )
 530              )
 531          );
 532      }
 533  
 534      /**
 535       * Delete cohort members
 536       *
 537       * @param array $members of arrays with keys userid, cohortid
 538       * @since Moodle 2.5
 539       */
 540      public static function delete_cohort_members($members) {
 541          global $CFG, $DB;
 542          require_once("$CFG->dirroot/cohort/lib.php");
 543  
 544          // Validate parameters.
 545          $params = self::validate_parameters(self::delete_cohort_members_parameters(), array('members' => $members));
 546  
 547          $transaction = $DB->start_delegated_transaction();
 548  
 549          foreach ($params['members'] as $member) {
 550              $cohortid = $member['cohortid'];
 551              $userid = $member['userid'];
 552  
 553              $cohort = $DB->get_record('cohort', array('id' => $cohortid), '*', MUST_EXIST);
 554              $user = $DB->get_record('user', array('id' => $userid, 'deleted' => 0, 'mnethostid' => $CFG->mnet_localhost_id),
 555                  '*', MUST_EXIST);
 556  
 557              // Now security checks.
 558              $context = context::instance_by_id($cohort->contextid, MUST_EXIST);
 559              if ($context->contextlevel != CONTEXT_COURSECAT and $context->contextlevel != CONTEXT_SYSTEM) {
 560                  throw new invalid_parameter_exception('Invalid context');
 561              }
 562              self::validate_context($context);
 563              if (!has_any_capability(array('moodle/cohort:manage', 'moodle/cohort:assign'), $context)) {
 564                  throw new required_capability_exception($context, 'moodle/cohort:assign', 'nopermissions', '');
 565              }
 566  
 567              cohort_remove_member($cohort->id, $user->id);
 568          }
 569          $transaction->allow_commit();
 570      }
 571  
 572      /**
 573       * Returns description of method result value
 574       *
 575       * @return null
 576       * @since Moodle 2.5
 577       */
 578      public static function delete_cohort_members_returns() {
 579          return null;
 580      }
 581  
 582      /**
 583       * Returns description of method parameters
 584       *
 585       * @return external_function_parameters
 586       * @since Moodle 2.5
 587       */
 588      public static function get_cohort_members_parameters() {
 589          return new external_function_parameters(
 590              array(
 591                  'cohortids' => new external_multiple_structure(new external_value(PARAM_INT, 'Cohort ID')),
 592              )
 593          );
 594      }
 595  
 596      /**
 597       * Return all members for a cohort
 598       *
 599       * @param array $cohortids array of cohort ids
 600       * @return array with cohort id keys containing arrays of user ids
 601       * @since Moodle 2.5
 602       */
 603      public static function get_cohort_members($cohortids) {
 604          global $DB;
 605          $params = self::validate_parameters(self::get_cohort_members_parameters(), array('cohortids' => $cohortids));
 606  
 607          $members = array();
 608  
 609          foreach ($params['cohortids'] as $cohortid) {
 610              // Validate params.
 611              $cohort = $DB->get_record('cohort', array('id' => $cohortid), '*', MUST_EXIST);
 612              // Now security checks.
 613              $context = context::instance_by_id($cohort->contextid, MUST_EXIST);
 614              if ($context->contextlevel != CONTEXT_COURSECAT and $context->contextlevel != CONTEXT_SYSTEM) {
 615                  throw new invalid_parameter_exception('Invalid context');
 616              }
 617              self::validate_context($context);
 618              if (!has_any_capability(array('moodle/cohort:manage', 'moodle/cohort:view'), $context)) {
 619                  throw new required_capability_exception($context, 'moodle/cohort:view', 'nopermissions', '');
 620              }
 621  
 622              $cohortmembers = $DB->get_records_sql("SELECT u.id FROM {user} u, {cohort_members} cm
 623                  WHERE u.id = cm.userid AND cm.cohortid = ?
 624                  ORDER BY lastname ASC, firstname ASC", array($cohort->id));
 625              $members[] = array('cohortid' => $cohortid, 'userids' => array_keys($cohortmembers));
 626          }
 627          return $members;
 628      }
 629  
 630      /**
 631       * Returns description of method result value
 632       *
 633       * @return external_description
 634       * @since Moodle 2.5
 635       */
 636      public static function get_cohort_members_returns() {
 637          return new external_multiple_structure(
 638              new external_single_structure(
 639                  array(
 640                      'cohortid' => new external_value(PARAM_INT, 'cohort record id'),
 641                      'userids' => new external_multiple_structure(new external_value(PARAM_INT, 'user id')),
 642                  )
 643              )
 644          );
 645      }
 646  }