[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 API.
  19   *
  20   * @package    core_competency
  21   * @copyright  2016 Frédéric Massart - FMCorz.net
  22   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23   */
  24  
  25  namespace core_competency;
  26  defined('MOODLE_INTERNAL') || die();
  27  
  28  require_once("$CFG->libdir/externallib.php");
  29  require_once("$CFG->libdir/grade/grade_scale.php");
  30  
  31  use context;
  32  use context_system;
  33  use context_course;
  34  use context_helper;
  35  use context_user;
  36  use coding_exception;
  37  use external_api;
  38  use external_function_parameters;
  39  use external_value;
  40  use external_format_value;
  41  use external_single_structure;
  42  use external_multiple_structure;
  43  use invalid_parameter_exception;
  44  use required_capability_exception;
  45  use grade_scale;
  46  
  47  use core_competency\external\competency_exporter;
  48  use core_competency\external\competency_framework_exporter;
  49  use core_competency\external\course_competency_exporter;
  50  use core_competency\external\course_competency_settings_exporter;
  51  use core_competency\external\evidence_exporter;
  52  use core_competency\external\plan_exporter;
  53  use core_competency\external\template_exporter;
  54  use core_competency\external\user_competency_exporter;
  55  use core_competency\external\user_competency_plan_exporter;
  56  use core_competency\external\user_evidence_competency_exporter;
  57  use core_competency\external\user_evidence_exporter;
  58  use core_competency\external\user_summary_exporter;
  59  
  60  /**
  61   * External API class.
  62   *
  63   * @package    core_competency
  64   * @copyright  2016 Frédéric Massart - FMCorz.net
  65   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  66   */
  67  class external extends external_api {
  68  
  69      /**
  70       * Returns a prepared structure to use a context parameters.
  71       * @return external_single_structure
  72       */
  73      protected static function get_context_parameters() {
  74          $id = new external_value(
  75              PARAM_INT,
  76              'Context ID. Either use this value, or level and instanceid.',
  77              VALUE_DEFAULT,
  78              0
  79          );
  80          $level = new external_value(
  81              PARAM_ALPHA,
  82              'Context level. To be used with instanceid.',
  83              VALUE_DEFAULT,
  84              ''
  85          );
  86          $instanceid = new external_value(
  87              PARAM_INT,
  88              'Context instance ID. To be used with level',
  89              VALUE_DEFAULT,
  90              0
  91          );
  92          return new external_single_structure(array(
  93              'contextid' => $id,
  94              'contextlevel' => $level,
  95              'instanceid' => $instanceid,
  96          ));
  97      }
  98  
  99      /**
 100       * Returns description of create_competency_framework() parameters.
 101       *
 102       * @return \external_function_parameters
 103       */
 104      public static function create_competency_framework_parameters() {
 105          $structure = competency_framework_exporter::get_create_structure();
 106          $params = array('competencyframework' => $structure);
 107          return new external_function_parameters($params);
 108      }
 109  
 110      /**
 111       * Create a new competency framework
 112       *
 113       * @param array $competencyframework A single param with all the fields for a competency framework.
 114       * @return \stdClass The new record
 115       */
 116      public static function create_competency_framework($competencyframework) {
 117          global $PAGE;
 118  
 119          $params = self::validate_parameters(self::create_competency_framework_parameters(), array(
 120              'competencyframework' => $competencyframework
 121          ));
 122          $params = $params['competencyframework'];
 123  
 124          $context = self::get_context_from_params($params);
 125          self::validate_context($context);
 126          $output = $PAGE->get_renderer('core');
 127  
 128          unset($params['contextlevel']);
 129          unset($params['instanceid']);
 130          $params['contextid'] = $context->id;
 131  
 132          $params = (object) $params;
 133          $result = api::create_framework($params);
 134          $exporter = new competency_framework_exporter($result);
 135          $record = $exporter->export($output);
 136          return $record;
 137      }
 138  
 139      /**
 140       * Returns description of create_competency_framework() result value.
 141       *
 142       * @return \external_description
 143       */
 144      public static function create_competency_framework_returns() {
 145          return competency_framework_exporter::get_read_structure();
 146      }
 147  
 148      /**
 149       * Returns description of read_competency_framework() parameters.
 150       *
 151       * @return \external_function_parameters
 152       */
 153      public static function read_competency_framework_parameters() {
 154          $id = new external_value(
 155              PARAM_INT,
 156              'Data base record id for the framework',
 157              VALUE_REQUIRED
 158          );
 159  
 160          $params = array(
 161              'id' => $id,
 162          );
 163          return new external_function_parameters($params);
 164      }
 165  
 166      /**
 167       * Read a competency framework by id.
 168       *
 169       * @param int $id The id of the framework.
 170       * @return \stdClass
 171       */
 172      public static function read_competency_framework($id) {
 173          global $PAGE;
 174  
 175          $params = self::validate_parameters(self::read_competency_framework_parameters(), array(
 176              'id' => $id,
 177          ));
 178  
 179          $framework = api::read_framework($params['id']);
 180          self::validate_context($framework->get_context());
 181          $output = $PAGE->get_renderer('core');
 182          $exporter = new competency_framework_exporter($framework);
 183          $record = $exporter->export($output);
 184          return $record;
 185      }
 186  
 187      /**
 188       * Returns description of read_competency_framework() result value.
 189       *
 190       * @return \external_description
 191       */
 192      public static function read_competency_framework_returns() {
 193          return competency_framework_exporter::get_read_structure();
 194      }
 195  
 196      /**
 197       * Returns description of competency_viewed() parameters.
 198       *
 199       * @return \external_function_parameters
 200       */
 201      public static function competency_viewed_parameters() {
 202          $id = new external_value(
 203              PARAM_INT,
 204              'The competency id',
 205              VALUE_REQUIRED
 206          );
 207          $params = array(
 208              'id' => $id
 209          );
 210          return new external_function_parameters($params);
 211      }
 212  
 213      /**
 214       * Log event competency viewed.
 215       *
 216       * @param int $id The competency ID.
 217       * @return boolean
 218       */
 219      public static function competency_viewed($id) {
 220          $params = self::validate_parameters(self::competency_viewed_parameters(), array(
 221              'id' => $id
 222          ));
 223          return api::competency_viewed($params['id']);
 224      }
 225  
 226      /**
 227       * Returns description of competency_viewed() result value.
 228       *
 229       * @return \external_description
 230       */
 231      public static function competency_viewed_returns() {
 232          return new external_value(PARAM_BOOL, 'True if the event competency viewed was logged');
 233      }
 234  
 235      /**
 236       * Returns description of duplicate_competency_framework() parameters.
 237       *
 238       * @return \external_function_parameters
 239       */
 240      public static function duplicate_competency_framework_parameters() {
 241          $id = new external_value(
 242              PARAM_INT,
 243              'Data base record id for the framework',
 244              VALUE_REQUIRED
 245          );
 246  
 247          $params = array(
 248              'id' => $id,
 249          );
 250          return new external_function_parameters($params);
 251      }
 252  
 253      /**
 254       * Duplicate a competency framework
 255       *
 256       * @param int $id The competency framework id
 257       * @return boolean
 258       */
 259      public static function duplicate_competency_framework($id) {
 260          global $PAGE;
 261          $params = self::validate_parameters(self::duplicate_competency_framework_parameters(), array(
 262              'id' => $id,
 263          ));
 264  
 265          $framework = api::read_framework($params['id']);
 266          self::validate_context($framework->get_context());
 267  
 268          $output = $PAGE->get_renderer('core');
 269          $framework = api::duplicate_framework($params['id']);
 270          $exporter = new competency_framework_exporter($framework);
 271          $record = $exporter->export($output);
 272          return $record;
 273      }
 274  
 275      /**
 276       * Returns description of duplicate_competency_framework() result value.
 277       *
 278       * @return \external_description
 279       */
 280      public static function duplicate_competency_framework_returns() {
 281          return competency_framework_exporter::get_read_structure();
 282      }
 283  
 284      /**
 285       * Returns description of delete_competency_framework() parameters.
 286       *
 287       * @return \external_function_parameters
 288       */
 289      public static function delete_competency_framework_parameters() {
 290          $id = new external_value(
 291              PARAM_INT,
 292              'Data base record id for the framework',
 293              VALUE_REQUIRED
 294          );
 295  
 296          $params = array(
 297              'id' => $id,
 298          );
 299          return new external_function_parameters($params);
 300      }
 301  
 302      /**
 303       * Delete a competency framework
 304       *
 305       * @param int $id The competency framework id
 306       * @return boolean
 307       */
 308      public static function delete_competency_framework($id) {
 309          $params = self::validate_parameters(self::delete_competency_framework_parameters(), array(
 310              'id' => $id,
 311          ));
 312  
 313          $framework = api::read_framework($params['id']);
 314          self::validate_context($framework->get_context());
 315  
 316          return api::delete_framework($params['id']);
 317      }
 318  
 319      /**
 320       * Returns description of delete_competency_framework() result value.
 321       *
 322       * @return \external_description
 323       */
 324      public static function delete_competency_framework_returns() {
 325          return new external_value(PARAM_BOOL, 'True if the delete was successful');
 326      }
 327  
 328      /**
 329       * Returns description of update_competency_framework() parameters.
 330       *
 331       * @return \external_function_parameters
 332       */
 333      public static function update_competency_framework_parameters() {
 334          $structure = competency_framework_exporter::get_update_structure();
 335          $params = array('competencyframework' => $structure);
 336          return new external_function_parameters($params);
 337      }
 338  
 339      /**
 340       * Update an existing competency framework
 341       *
 342       * @param array $competencyframework An array with all the fields for a competency framework.
 343       * @return boolean
 344       */
 345      public static function update_competency_framework($competencyframework) {
 346  
 347          $params = self::validate_parameters(self::update_competency_framework_parameters(), array(
 348              'competencyframework' => $competencyframework
 349          ));
 350          $params = $params['competencyframework'];
 351  
 352          $framework = api::read_framework($params['id']);
 353          self::validate_context($framework->get_context());
 354  
 355          $params = (object) $params;
 356  
 357          return api::update_framework($params);
 358      }
 359  
 360      /**
 361       * Returns description of update_competency_framework() result value.
 362       *
 363       * @return \external_description
 364       */
 365      public static function update_competency_framework_returns() {
 366          return new external_value(PARAM_BOOL, 'True if the update was successful');
 367      }
 368  
 369      /**
 370       * Returns description of list_competency_frameworks() parameters.
 371       *
 372       * @return \external_function_parameters
 373       */
 374      public static function list_competency_frameworks_parameters() {
 375          $sort = new external_value(
 376              PARAM_ALPHANUMEXT,
 377              'Column to sort by.',
 378              VALUE_DEFAULT,
 379              'shortname'
 380          );
 381          $order = new external_value(
 382              PARAM_ALPHA,
 383              'Sort direction. Should be either ASC or DESC',
 384              VALUE_DEFAULT,
 385              ''
 386          );
 387          $skip = new external_value(
 388              PARAM_INT,
 389              'Skip this number of records before returning results',
 390              VALUE_DEFAULT,
 391              0
 392          );
 393          $limit = new external_value(
 394              PARAM_INT,
 395              'Return this number of records at most.',
 396              VALUE_DEFAULT,
 397              0
 398          );
 399          $includes = new external_value(
 400              PARAM_ALPHA,
 401              'What other contextes to fetch the frameworks from. (children, parents, self)',
 402              VALUE_DEFAULT,
 403              'children'
 404          );
 405          $onlyvisible = new external_value(
 406              PARAM_BOOL,
 407              'Only visible frameworks will be returned if visible true',
 408              VALUE_DEFAULT,
 409              false
 410          );
 411          $query = new external_value(
 412              PARAM_RAW,
 413              'A query string to filter the results',
 414              VALUE_DEFAULT,
 415              ''
 416          );
 417  
 418          $params = array(
 419              'sort' => $sort,
 420              'order' => $order,
 421              'skip' => $skip,
 422              'limit' => $limit,
 423              'context' => self::get_context_parameters(),
 424              'includes' => $includes,
 425              'onlyvisible' => $onlyvisible,
 426              'query' => $query,
 427          );
 428          return new external_function_parameters($params);
 429      }
 430  
 431      /**
 432       * List the existing competency frameworks
 433       *
 434       * @param int $sort
 435       * @param string $order
 436       * @param string $skip
 437       * @param int $limit
 438       * @param array $context
 439       * @param bool $includes
 440       * @param bool $onlyvisible
 441       * @param string $query
 442       *
 443       * @return array
 444       * @throws \required_capability_exception
 445       * @throws invalid_parameter_exception
 446       */
 447      public static function list_competency_frameworks($sort, $order, $skip, $limit, $context, $includes, $onlyvisible,
 448                                                        $query = '') {
 449          global $PAGE;
 450  
 451          $params = self::validate_parameters(self::list_competency_frameworks_parameters(), array(
 452              'sort' => $sort,
 453              'order' => $order,
 454              'skip' => $skip,
 455              'limit' => $limit,
 456              'context' => $context,
 457              'includes' => $includes,
 458              'onlyvisible' => $onlyvisible,
 459              'query' => $query,
 460          ));
 461  
 462          $context = self::get_context_from_params($params['context']);
 463          self::validate_context($context);
 464          $output = $PAGE->get_renderer('core');
 465  
 466          if ($params['order'] !== '' && $params['order'] !== 'ASC' && $params['order'] !== 'DESC') {
 467              throw new invalid_parameter_exception('Invalid order param. Must be ASC, DESC or empty.');
 468          }
 469  
 470          $results = api::list_frameworks($params['sort'],
 471                                         $params['order'],
 472                                         $params['skip'],
 473                                         $params['limit'],
 474                                         $context,
 475                                         $params['includes'],
 476                                         $params['onlyvisible'],
 477                                         $params['query']);
 478          $records = array();
 479          foreach ($results as $result) {
 480              $exporter = new competency_framework_exporter($result);
 481              $record = $exporter->export($output);
 482              array_push($records, $record);
 483          }
 484          return $records;
 485      }
 486  
 487      /**
 488       * Returns description of list_competency_frameworks() result value.
 489       *
 490       * @return \external_description
 491       */
 492      public static function list_competency_frameworks_returns() {
 493          return new external_multiple_structure(competency_framework_exporter::get_read_structure());
 494      }
 495  
 496      /**
 497       * Returns description of count_competency_frameworks() parameters.
 498       *
 499       * @return \external_function_parameters
 500       */
 501      public static function count_competency_frameworks_parameters() {
 502          $includes = new external_value(
 503              PARAM_ALPHA,
 504              'What other contextes to fetch the frameworks from. (children, parents, self)',
 505              VALUE_DEFAULT,
 506              'children'
 507          );
 508  
 509          $params = array(
 510              'context' => self::get_context_parameters(),
 511              'includes' => $includes
 512          );
 513          return new external_function_parameters($params);
 514      }
 515  
 516      /**
 517       * Count the existing competency frameworks
 518       *
 519       * @param array $context
 520       * @param string $includes
 521       * @return int
 522       */
 523      public static function count_competency_frameworks($context, $includes) {
 524          $params = self::validate_parameters(self::count_competency_frameworks_parameters(), array(
 525              'context' => $context,
 526              'includes' => $includes
 527          ));
 528  
 529          $context = self::get_context_from_params($params['context']);
 530          self::validate_context($context);
 531  
 532          return api::count_frameworks($context, $params['includes']);
 533      }
 534  
 535      /**
 536       * Returns description of count_competency_frameworks() result value.
 537       *
 538       * @return \external_description
 539       */
 540      public static function count_competency_frameworks_returns() {
 541          return new external_value(PARAM_INT, 'The number of competency frameworks found.');
 542      }
 543  
 544      /**
 545       * Returns description of competency_framework_viewed() parameters.
 546       *
 547       * @return \external_function_parameters
 548       */
 549      public static function competency_framework_viewed_parameters() {
 550          $id = new external_value(
 551              PARAM_INT,
 552              'The competency framework id',
 553              VALUE_REQUIRED
 554          );
 555  
 556          $params = array(
 557              'id' => $id
 558          );
 559          return new external_function_parameters($params);
 560      }
 561  
 562      /**
 563       * Log event competency framework viewed.
 564       *
 565       * @param int $id The competency framework ID.
 566       * @return boolean
 567       */
 568      public static function competency_framework_viewed($id) {
 569          $params = self::validate_parameters(self::competency_framework_viewed_parameters(), array(
 570              'id' => $id
 571          ));
 572          return api::competency_framework_viewed($params['id']);
 573  
 574      }
 575  
 576      /**
 577       * Returns description of competency_framework_viewed() result value.
 578       *
 579       * @return \external_description
 580       */
 581      public static function competency_framework_viewed_returns() {
 582          return new external_value(PARAM_BOOL, 'True if the event competency framework was logged');
 583      }
 584  
 585      /**
 586       * Returns description of create_competency() parameters.
 587       *
 588       * @return \external_function_parameters
 589       */
 590      public static function create_competency_parameters() {
 591          $structure = competency_exporter::get_create_structure();
 592          $params = array('competency' => $structure);
 593          return new external_function_parameters($params);
 594      }
 595  
 596      /**
 597       * Create a new competency
 598       *
 599       * @param array $competency All the fields for a competency record (including id)
 600       * @return array the competency
 601       */
 602      public static function create_competency($competency) {
 603          global $PAGE;
 604  
 605          $params = self::validate_parameters(self::create_competency_parameters(), array(
 606              'competency' => $competency
 607          ));
 608  
 609          $params = $params['competency'];
 610          $framework = api::read_framework($params['competencyframeworkid']);
 611          $context = $framework->get_context();
 612          self::validate_context($context);
 613          $output = $PAGE->get_renderer('core');
 614  
 615          $params = (object) $params;
 616          $result = api::create_competency($params);
 617          $exporter = new competency_exporter($result, array('context' => $context));
 618          $record = $exporter->export($output);
 619          return $record;
 620      }
 621  
 622      /**
 623       * Returns description of create_competency() result value.
 624       *
 625       * @return \external_description
 626       */
 627      public static function create_competency_returns() {
 628          return competency_exporter::get_read_structure();
 629      }
 630  
 631      /**
 632       * Returns description of read_competency() parameters.
 633       *
 634       * @return \external_function_parameters
 635       */
 636      public static function read_competency_parameters() {
 637          $id = new external_value(
 638              PARAM_INT,
 639              'Data base record id for the competency',
 640              VALUE_REQUIRED
 641          );
 642  
 643          $params = array(
 644              'id' => $id,
 645          );
 646          return new external_function_parameters($params);
 647      }
 648  
 649      /**
 650       * Read a competency by id.
 651       *
 652       * @param int $id The id of the competency
 653       * @return \stdClass
 654       */
 655      public static function read_competency($id) {
 656          global $PAGE;
 657  
 658          $params = self::validate_parameters(self::read_competency_parameters(), array(
 659              'id' => $id,
 660          ));
 661  
 662          $competency = api::read_competency($params['id']);
 663          $context = $competency->get_context();
 664          self::validate_context($context);
 665          $output = $PAGE->get_renderer('core');
 666          $exporter = new competency_exporter($competency, array('context' => $context));
 667          $record = $exporter->export($output);
 668          return $record;
 669      }
 670  
 671      /**
 672       * Returns description of read_competency() result value.
 673       *
 674       * @return \external_description
 675       */
 676      public static function read_competency_returns() {
 677          return competency_exporter::get_read_structure();
 678      }
 679  
 680      /**
 681       * Returns description of delete_competency() parameters.
 682       *
 683       * @return \external_function_parameters
 684       */
 685      public static function delete_competency_parameters() {
 686          $id = new external_value(
 687              PARAM_INT,
 688              'Data base record id for the competency',
 689              VALUE_REQUIRED
 690          );
 691  
 692          $params = array(
 693              'id' => $id,
 694          );
 695          return new external_function_parameters($params);
 696      }
 697  
 698      /**
 699       * Delete a competency
 700       *
 701       * @param int $id The competency id
 702       * @return boolean
 703       */
 704      public static function delete_competency($id) {
 705          $params = self::validate_parameters(self::delete_competency_parameters(), array(
 706              'id' => $id,
 707          ));
 708  
 709          $competency = api::read_competency($params['id']);
 710          $context = $competency->get_context();
 711          self::validate_context($context);
 712  
 713          return api::delete_competency($params['id']);
 714      }
 715  
 716      /**
 717       * Returns description of delete_competency() result value.
 718       *
 719       * @return \external_description
 720       */
 721      public static function delete_competency_returns() {
 722          return new external_value(PARAM_BOOL, 'True if the delete was successful');
 723      }
 724  
 725      /**
 726       * Returns description of update_competency() parameters.
 727       *
 728       * @return \external_function_parameters
 729       */
 730      public static function update_competency_parameters() {
 731          $structure = competency_exporter::get_update_structure();
 732          $params = array('competency' => $structure);
 733          return new external_function_parameters($params);
 734      }
 735  
 736      /**
 737       * Update an existing competency
 738       *
 739       * @param array $competency The array of competency fields (id is required).
 740       * @return boolean
 741       */
 742      public static function update_competency($competency) {
 743          $params = self::validate_parameters(self::update_competency_parameters(), array(
 744              'competency' => $competency
 745          ));
 746          $params = $params['competency'];
 747  
 748          $competency = api::read_competency($params['id']);
 749          self::validate_context($competency->get_context());
 750  
 751          $params = (object) $params;
 752  
 753          return api::update_competency($params);
 754      }
 755  
 756      /**
 757       * Returns description of update_competency_framework() result value.
 758       *
 759       * @return \external_description
 760       */
 761      public static function update_competency_returns() {
 762          return new external_value(PARAM_BOOL, 'True if the update was successful');
 763      }
 764  
 765      /**
 766       * Returns description of list_competencies() parameters.
 767       *
 768       * @return \external_function_parameters
 769       */
 770      public static function list_competencies_parameters() {
 771          $filters = new external_multiple_structure(new external_single_structure(
 772              array(
 773                  'column' => new external_value(PARAM_ALPHANUMEXT, 'Column name to filter by'),
 774                  'value' => new external_value(PARAM_TEXT, 'Value to filter by. Must be exact match')
 775              )
 776          ));
 777          $sort = new external_value(
 778              PARAM_ALPHANUMEXT,
 779              'Column to sort by.',
 780              VALUE_DEFAULT,
 781              ''
 782          );
 783          $order = new external_value(
 784              PARAM_ALPHA,
 785              'Sort direction. Should be either ASC or DESC',
 786              VALUE_DEFAULT,
 787              ''
 788          );
 789          $skip = new external_value(
 790              PARAM_INT,
 791              'Skip this number of records before returning results',
 792              VALUE_DEFAULT,
 793              0
 794          );
 795          $limit = new external_value(
 796              PARAM_INT,
 797              'Return this number of records at most.',
 798              VALUE_DEFAULT,
 799              0
 800          );
 801  
 802          $params = array(
 803              'filters' => $filters,
 804              'sort' => $sort,
 805              'order' => $order,
 806              'skip' => $skip,
 807              'limit' => $limit
 808          );
 809          return new external_function_parameters($params);
 810      }
 811  
 812      /**
 813       * List the existing competency.
 814       *
 815       * @param string $filters
 816       * @param int $sort
 817       * @param string $order
 818       * @param string $skip
 819       * @param int $limit
 820       *
 821       * @return array
 822       * @throws \required_capability_exception
 823       * @throws invalid_parameter_exception
 824       */
 825      public static function list_competencies($filters, $sort, $order, $skip, $limit) {
 826          global $PAGE;
 827  
 828          $params = self::validate_parameters(self::list_competencies_parameters(), array(
 829              'filters' => $filters,
 830              'sort' => $sort,
 831              'order' => $order,
 832              'skip' => $skip,
 833              'limit' => $limit
 834          ));
 835  
 836          if ($params['order'] !== '' && $params['order'] !== 'ASC' && $params['order'] !== 'DESC') {
 837              throw new invalid_parameter_exception('Invalid order param. Must be ASC, DESC or empty.');
 838          }
 839  
 840          $safefilters = array();
 841          $validcolumns = array('id', 'shortname', 'description', 'sortorder', 'idnumber',
 842              'parentid', 'competencyframeworkid');
 843          foreach ($params['filters'] as $filter) {
 844              if (!in_array($filter->column, $validcolumns)) {
 845                  throw new invalid_parameter_exception('Filter column was invalid');
 846              }
 847              $safefilters[$filter->column] = $filter->value;
 848          }
 849  
 850          $context = null;
 851          if (isset($safefilters['competencyframeworkid'])) {
 852              $framework = api::read_framework($safefilters['competencyframeworkid']);
 853              $context = $framework->get_context();
 854          } else {
 855              $context = context_system::instance();
 856          }
 857  
 858          self::validate_context($context);
 859          $output = $PAGE->get_renderer('core');
 860  
 861          $results = api::list_competencies(
 862              $safefilters,
 863              $params['sort'],
 864              $params['order'],
 865              $params['skip'],
 866              $params['limit']
 867          );
 868  
 869          $records = array();
 870          foreach ($results as $result) {
 871              $exporter = new competency_exporter($result, array('context' => $context));
 872              $record = $exporter->export($output);
 873              array_push($records, $record);
 874          }
 875          return $records;
 876      }
 877  
 878      /**
 879       * Returns description of list_competencies() result value.
 880       *
 881       * @return \external_description
 882       */
 883      public static function list_competencies_returns() {
 884          return new external_multiple_structure(competency_exporter::get_read_structure());
 885      }
 886  
 887      /**
 888       * Returns description of search_competencies() parameters.
 889       *
 890       * @return \external_function_parameters
 891       */
 892      public static function search_competencies_parameters() {
 893          $searchtext = new external_value(
 894              PARAM_RAW,
 895              'Text to search for',
 896              VALUE_REQUIRED
 897          );
 898          $frameworkid = new external_value(
 899              PARAM_INT,
 900              'Competency framework id',
 901              VALUE_REQUIRED
 902          );
 903  
 904          $params = array(
 905              'searchtext' => $searchtext,
 906              'competencyframeworkid' => $frameworkid
 907          );
 908          return new external_function_parameters($params);
 909      }
 910  
 911      /**
 912       * List the existing competency frameworks
 913       *
 914       * @param string $searchtext Text to search.
 915       * @param int $competencyframeworkid Framework id.
 916       *
 917       * @return array
 918       */
 919      public static function search_competencies($searchtext, $competencyframeworkid) {
 920          global $PAGE;
 921  
 922          $params = self::validate_parameters(self::search_competencies_parameters(), array(
 923              'searchtext' => $searchtext,
 924              'competencyframeworkid' => $competencyframeworkid
 925          ));
 926  
 927          $framework = api::read_framework($params['competencyframeworkid']);
 928          $context = $framework->get_context();
 929          self::validate_context($context);
 930          $output = $PAGE->get_renderer('core');
 931  
 932          $results = api::search_competencies($params['searchtext'], $params['competencyframeworkid']);
 933          $records = array();
 934          foreach ($results as $result) {
 935              $exporter = new competency_exporter($result, array('context' => $context));
 936              $record = $exporter->export($output);
 937  
 938              array_push($records, $record);
 939          }
 940  
 941          return $records;
 942      }
 943  
 944      /**
 945       * Returns description of search_competencies() result value.
 946       *
 947       * @return \external_description
 948       */
 949      public static function search_competencies_returns() {
 950          return new external_multiple_structure(competency_exporter::get_read_structure());
 951      }
 952  
 953      /**
 954       * Returns description of count_competencies() parameters.
 955       *
 956       * @return \external_function_parameters
 957       */
 958      public static function count_competencies_parameters() {
 959          $filters = new external_multiple_structure(new external_single_structure(
 960              array(
 961                  'column' => new external_value(PARAM_ALPHANUMEXT, 'Column name to filter by'),
 962                  'value' => new external_value(PARAM_TEXT, 'Value to filter by. Must be exact match')
 963              )
 964          ));
 965  
 966          $params = array(
 967              'filters' => $filters,
 968          );
 969          return new external_function_parameters($params);
 970      }
 971  
 972      /**
 973       * Count the existing competency frameworks.
 974       *
 975       * @param string $filters Filters to use.
 976       * @return boolean
 977       */
 978      public static function count_competencies($filters) {
 979          $params = self::validate_parameters(self::count_competencies_parameters(), array(
 980              'filters' => $filters
 981          ));
 982  
 983          $safefilters = array();
 984          $validcolumns = array('id', 'shortname', 'description', 'sortorder', 'idnumber', 'parentid', 'competencyframeworkid');
 985          foreach ($params['filters'] as $filter) {
 986              if (!in_array($filter['column'], $validcolumns)) {
 987                  throw new invalid_parameter_exception('Filter column was invalid');
 988              }
 989              $safefilters[$filter['column']] = $filter['value'];
 990          }
 991  
 992          $context = null;
 993          if (isset($safefilters['competencyframeworkid'])) {
 994              $framework = api::read_framework($safefilters['competencyframeworkid']);
 995              $context = $framework->get_context();
 996          } else {
 997              $context = context_system::instance();
 998          }
 999  
1000          self::validate_context($context);
1001  
1002          return api::count_competencies($safefilters);
1003      }
1004  
1005      /**
1006       * Returns description of count_competencies() result value.
1007       *
1008       * @return \external_description
1009       */
1010      public static function count_competencies_returns() {
1011          return new external_value(PARAM_INT, 'The number of competencies found.');
1012      }
1013  
1014      /**
1015       * Returns description of set_parent_competency() parameters.
1016       *
1017       * @return \external_function_parameters
1018       */
1019      public static function set_parent_competency_parameters() {
1020          $competencyid = new external_value(
1021              PARAM_INT,
1022              'The competency id',
1023              VALUE_REQUIRED
1024          );
1025          $parentid = new external_value(
1026              PARAM_INT,
1027              'The new competency parent id',
1028              VALUE_REQUIRED
1029          );
1030          $params = array(
1031              'competencyid' => $competencyid,
1032              'parentid' => $parentid
1033          );
1034          return new external_function_parameters($params);
1035      }
1036  
1037      /**
1038       * Move the competency to a new parent.
1039       *
1040       * @param int $competencyid Competency id.
1041       * @param int $parentid Parent id.
1042       *
1043       * @return bool
1044       */
1045      public static function set_parent_competency($competencyid, $parentid) {
1046          $params = self::validate_parameters(self::set_parent_competency_parameters(), array(
1047              'competencyid' => $competencyid,
1048              'parentid' => $parentid
1049          ));
1050  
1051          $competency = api::read_competency($params['competencyid']);
1052          self::validate_context($competency->get_context());
1053  
1054          return api::set_parent_competency($params['competencyid'], $params['parentid']);
1055      }
1056  
1057      /**
1058       * Returns description of set_parent_competency() result value.
1059       *
1060       * @return \external_description
1061       */
1062      public static function set_parent_competency_returns() {
1063          return new external_value(PARAM_BOOL, 'True if the update was successful');
1064      }
1065  
1066      /**
1067       * Returns description of move_up_competency() parameters.
1068       *
1069       * @return \external_function_parameters
1070       */
1071      public static function move_up_competency_parameters() {
1072          $competencyid = new external_value(
1073              PARAM_INT,
1074              'The competency id',
1075              VALUE_REQUIRED
1076          );
1077          $params = array(
1078              'id' => $competencyid,
1079          );
1080          return new external_function_parameters($params);
1081      }
1082  
1083      /**
1084       * Change the sort order of a competency.
1085       *
1086       * @param int $competencyid Competency id.
1087       * @return boolean
1088       */
1089      public static function move_up_competency($competencyid) {
1090          $params = self::validate_parameters(self::move_up_competency_parameters(), array(
1091              'id' => $competencyid,
1092          ));
1093  
1094          $competency = api::read_competency($params['id']);
1095          self::validate_context($competency->get_context());
1096  
1097          return api::move_up_competency($params['id']);
1098      }
1099  
1100      /**
1101       * Returns description of move_up_competency() result value.
1102       *
1103       * @return \external_description
1104       */
1105      public static function move_up_competency_returns() {
1106          return new external_value(PARAM_BOOL, 'True if the update was successful');
1107      }
1108  
1109      /**
1110       * Returns description of move_down_competency() parameters.
1111       *
1112       * @return \external_function_parameters
1113       */
1114      public static function move_down_competency_parameters() {
1115          $competencyid = new external_value(
1116              PARAM_INT,
1117              'The competency id',
1118              VALUE_REQUIRED
1119          );
1120          $params = array(
1121              'id' => $competencyid,
1122          );
1123          return new external_function_parameters($params);
1124      }
1125  
1126      /**
1127       * Change the sort order of a competency.
1128       *
1129       * @param int $competencyid Competency id.
1130       * @return boolean
1131       */
1132      public static function move_down_competency($competencyid) {
1133          $params = self::validate_parameters(self::move_down_competency_parameters(), array(
1134              'id' => $competencyid,
1135          ));
1136  
1137          $competency = api::read_competency($params['id']);
1138          self::validate_context($competency->get_context());
1139  
1140          return api::move_down_competency($params['id']);
1141      }
1142  
1143      /**
1144       * Returns description of move_down_competency() result value.
1145       *
1146       * @return \external_description
1147       */
1148      public static function move_down_competency_returns() {
1149          return new external_value(PARAM_BOOL, 'True if the update was successful');
1150      }
1151  
1152      /**
1153       * Returns description of count_courses_using_competency() parameters.
1154       *
1155       * @return \external_function_parameters
1156       */
1157      public static function count_courses_using_competency_parameters() {
1158          $competencyid = new external_value(
1159              PARAM_INT,
1160              'The competency id',
1161              VALUE_REQUIRED
1162          );
1163          $params = array(
1164              'id' => $competencyid,
1165          );
1166          return new external_function_parameters($params);
1167      }
1168  
1169      /**
1170       * Count the courses (visible to this user) that use this competency.
1171       *
1172       * @param int $competencyid Competency id.
1173       * @return int
1174       */
1175      public static function count_courses_using_competency($competencyid) {
1176          $params = self::validate_parameters(self::count_courses_using_competency_parameters(), array(
1177              'id' => $competencyid,
1178          ));
1179  
1180          $competency = api::read_competency($params['id']);
1181          self::validate_context($competency->get_context());
1182  
1183          return api::count_courses_using_competency($params['id']);
1184      }
1185  
1186      /**
1187       * Returns description of count_courses_using_competency() result value.
1188       *
1189       * @return \external_description
1190       */
1191      public static function count_courses_using_competency_returns() {
1192          return new external_value(PARAM_INT, 'The number of courses using this competency');
1193      }
1194  
1195      /**
1196       * Returns description of count_competencies_in_course() parameters.
1197       *
1198       * @return \external_function_parameters
1199       */
1200      public static function count_competencies_in_course_parameters() {
1201          $courseid = new external_value(
1202              PARAM_INT,
1203              'The course id',
1204              VALUE_REQUIRED
1205          );
1206          $params = array(
1207              'id' => $courseid,
1208          );
1209          return new external_function_parameters($params);
1210      }
1211  
1212      /**
1213       * Count the competencies (visible to this user) in this course.
1214       *
1215       * @param int $courseid The course id to check.
1216       * @return int
1217       */
1218      public static function count_competencies_in_course($courseid) {
1219          $params = self::validate_parameters(self::count_competencies_in_course_parameters(), array(
1220              'id' => $courseid,
1221          ));
1222  
1223          self::validate_context(context_course::instance($params['id']));
1224  
1225          return api::count_competencies_in_course($params['id']);
1226      }
1227  
1228      /**
1229       * Returns description of count_competencies_in_course() result value.
1230       *
1231       * @return \external_description
1232       */
1233      public static function count_competencies_in_course_returns() {
1234          return new external_value(PARAM_INT, 'The number of competencies in this course.');
1235      }
1236  
1237      /**
1238       * Returns description of list_course_module_competencies() parameters.
1239       *
1240       * @return \external_function_parameters
1241       */
1242      public static function list_course_module_competencies_parameters() {
1243          $cmid = new external_value(
1244              PARAM_INT,
1245              'The course module id',
1246              VALUE_REQUIRED
1247          );
1248          $params = array(
1249              'cmid' => $cmid
1250          );
1251          return new external_function_parameters($params);
1252      }
1253  
1254      /**
1255       * List the course modules using this competency (visible to this user) in this course.
1256       *
1257       * @param int $cmid The course module id to check.
1258       * @return array
1259       */
1260      public static function list_course_module_competencies($cmid) {
1261          global $PAGE;
1262  
1263          $params = self::validate_parameters(self::list_course_module_competencies_parameters(), array(
1264              'cmid' => $cmid
1265          ));
1266  
1267          $context = context_module::instance($params['cmid']);
1268          self::validate_context($context);
1269  
1270          $output = $PAGE->get_renderer('core');
1271  
1272          $apiresult = api::list_course_module_competencies($params['cmid']);
1273          $result = array();
1274  
1275          foreach ($apiresult as $cmrecord) {
1276              $one = new \stdClass();
1277              $exporter = new competency_exporter($cmrecord['competency']);
1278              $one->competency = $exporter->export($output);
1279              $exporter = new course_module_competency_exporter($cmrecord['coursemodulecompetency']);
1280              $one->coursemodulecompetency = $exporter->export($output);
1281  
1282              $result[] = (array) $one;
1283          }
1284  
1285          return $result;
1286      }
1287  
1288      /**
1289       * Returns description of list_course_module_competencies() result value.
1290       *
1291       * @return \external_description
1292       */
1293      public static function list_course_module_competencies_returns() {
1294          return new external_multiple_structure(
1295              new external_single_structure(array(
1296                  'competency' => competency_exporter::get_read_structure(),
1297                  'coursemodulecompetency' => course_module_competency_exporter::get_read_structure()
1298              ))
1299          );
1300      }
1301  
1302      /**
1303       * Returns description of list_course_competencies() parameters.
1304       *
1305       * @return \external_function_parameters
1306       */
1307      public static function list_course_competencies_parameters() {
1308          $courseid = new external_value(
1309              PARAM_INT,
1310              'The course id',
1311              VALUE_REQUIRED
1312          );
1313          $params = array(
1314              'id' => $courseid,
1315          );
1316          return new external_function_parameters($params);
1317      }
1318  
1319      /**
1320       * List the competencies (visible to this user) in this course.
1321       *
1322       * @param int $courseid The course id to check.
1323       * @return array
1324       */
1325      public static function list_course_competencies($courseid) {
1326          global $PAGE;
1327  
1328          $params = self::validate_parameters(self::list_course_competencies_parameters(), array(
1329              'id' => $courseid,
1330          ));
1331  
1332          $coursecontext = context_course::instance($params['id']);
1333          self::validate_context($coursecontext);
1334  
1335          $output = $PAGE->get_renderer('core');
1336  
1337          $competencies = api::list_course_competencies($params['id']);
1338          $result = array();
1339  
1340          $contextcache = array();
1341          foreach ($competencies as $competency) {
1342              if (!isset($contextcache[$competency['competency']->get_competencyframeworkid()])) {
1343                  $contextcache[$competency['competency']->get_competencyframeworkid()] = $competency['competency']->get_context();
1344              }
1345              $context = $contextcache[$competency['competency']->get_competencyframeworkid()];
1346              $exporter = new competency_exporter($competency['competency'], array('context' => $context));
1347              $competencyrecord = $exporter->export($output);
1348              $exporter = new course_competency_exporter($competency['coursecompetency'], array('context' => $context));
1349              $coursecompetencyrecord = $exporter->export($output);
1350  
1351              $result[] = array(
1352                  'competency' => $competencyrecord,
1353                  'coursecompetency' => $coursecompetencyrecord
1354              );
1355          }
1356  
1357          return $result;
1358      }
1359  
1360      /**
1361       * Returns description of list_course_competencies() result value.
1362       *
1363       * @return \external_description
1364       */
1365      public static function list_course_competencies_returns() {
1366          return new external_multiple_structure(
1367              new external_single_structure(array(
1368                  'competency' => competency_exporter::get_read_structure(),
1369                  'coursecompetency' => course_competency_exporter::get_read_structure()
1370              ))
1371          );
1372      }
1373  
1374      /**
1375       * Returns description of add_competency_to_course() parameters.
1376       *
1377       * @return \external_function_parameters
1378       */
1379      public static function add_competency_to_course_parameters() {
1380          $courseid = new external_value(
1381              PARAM_INT,
1382              'The course id',
1383              VALUE_REQUIRED
1384          );
1385          $competencyid = new external_value(
1386              PARAM_INT,
1387              'The competency id',
1388              VALUE_REQUIRED
1389          );
1390          $params = array(
1391              'courseid' => $courseid,
1392              'competencyid' => $competencyid,
1393          );
1394          return new external_function_parameters($params);
1395      }
1396  
1397      /**
1398       * Count the competencies (visible to this user) in this course.
1399       *
1400       * @param int $courseid The course id to check.
1401       * @param int $competencyid Competency id.
1402       * @return int
1403       */
1404      public static function add_competency_to_course($courseid, $competencyid) {
1405          $params = self::validate_parameters(self::add_competency_to_course_parameters(), array(
1406              'courseid' => $courseid,
1407              'competencyid' => $competencyid,
1408          ));
1409          self::validate_context(context_course::instance($params['courseid']));
1410          return api::add_competency_to_course($params['courseid'], $params['competencyid']);
1411      }
1412  
1413      /**
1414       * Returns description of add_competency_to_course() result value.
1415       *
1416       * @return \external_description
1417       */
1418      public static function add_competency_to_course_returns() {
1419          return new external_value(PARAM_BOOL, 'True if successful.');
1420      }
1421  
1422      /**
1423       * Returns description of remove_competency_from_course() parameters.
1424       *
1425       * @return \external_function_parameters
1426       */
1427      public static function remove_competency_from_course_parameters() {
1428          $courseid = new external_value(
1429              PARAM_INT,
1430              'The course id',
1431              VALUE_REQUIRED
1432          );
1433          $competencyid = new external_value(
1434              PARAM_INT,
1435              'The competency id',
1436              VALUE_REQUIRED
1437          );
1438          $params = array(
1439              'courseid' => $courseid,
1440              'competencyid' => $competencyid,
1441          );
1442          return new external_function_parameters($params);
1443      }
1444  
1445      /**
1446       * Count the competencies (visible to this user) in this course.
1447       *
1448       * @param int $courseid The course id to check.
1449       * @param int $competencyid Competency id.
1450       * @return int
1451       */
1452      public static function remove_competency_from_course($courseid, $competencyid) {
1453          $params = self::validate_parameters(self::remove_competency_from_course_parameters(), array(
1454              'courseid' => $courseid,
1455              'competencyid' => $competencyid,
1456          ));
1457          self::validate_context(context_course::instance($params['courseid']));
1458          return api::remove_competency_from_course($params['courseid'], $params['competencyid']);
1459      }
1460  
1461      /**
1462       * Returns description of remove_competency_from_course() result value.
1463       *
1464       * @return \external_description
1465       */
1466      public static function remove_competency_from_course_returns() {
1467          return new external_value(PARAM_BOOL, 'True if successful.');
1468      }
1469  
1470      /**
1471       * Returns description of reorder_course_competency() parameters.
1472       *
1473       * @return \external_function_parameters
1474       */
1475      public static function reorder_course_competency_parameters() {
1476          $courseid = new external_value(
1477              PARAM_INT,
1478              'The course id',
1479              VALUE_REQUIRED
1480          );
1481          $competencyidfrom = new external_value(
1482              PARAM_INT,
1483              'The competency id we are moving',
1484              VALUE_REQUIRED
1485          );
1486          $competencyidto = new external_value(
1487              PARAM_INT,
1488              'The competency id we are moving to',
1489              VALUE_REQUIRED
1490          );
1491          $params = array(
1492              'courseid' => $courseid,
1493              'competencyidfrom' => $competencyidfrom,
1494              'competencyidto' => $competencyidto,
1495          );
1496          return new external_function_parameters($params);
1497      }
1498  
1499      /**
1500       * Change the order of course competencies.
1501       *
1502       * @param int $courseid The course id
1503       * @param int $competencyidfrom The competency to move.
1504       * @param int $competencyidto The competency to move to.
1505       * @return bool
1506       */
1507      public static function reorder_course_competency($courseid, $competencyidfrom, $competencyidto) {
1508          $params = self::validate_parameters(self::reorder_course_competency_parameters(), array(
1509              'courseid' => $courseid,
1510              'competencyidfrom' => $competencyidfrom,
1511              'competencyidto' => $competencyidto,
1512          ));
1513          self::validate_context(context_course::instance($params['courseid']));
1514          return api::reorder_course_competency($params['courseid'], $params['competencyidfrom'], $params['competencyidto']);
1515      }
1516  
1517      /**
1518       * Returns description of reorder_course_competency() result value.
1519       *
1520       * @return \external_description
1521       */
1522      public static function reorder_course_competency_returns() {
1523          return new external_value(PARAM_BOOL, 'True if successful.');
1524      }
1525  
1526      /**
1527       * Returns description of reorder_template_competency() parameters.
1528       *
1529       * @return \external_function_parameters
1530       */
1531      public static function reorder_template_competency_parameters() {
1532          $templateid = new external_value(
1533              PARAM_INT,
1534              'The template id',
1535              VALUE_REQUIRED
1536          );
1537          $competencyidfrom = new external_value(
1538              PARAM_INT,
1539              'The competency id we are moving',
1540              VALUE_REQUIRED
1541          );
1542          $competencyidto = new external_value(
1543              PARAM_INT,
1544              'The competency id we are moving to',
1545              VALUE_REQUIRED
1546          );
1547          $params = array(
1548              'templateid' => $templateid,
1549              'competencyidfrom' => $competencyidfrom,
1550              'competencyidto' => $competencyidto,
1551          );
1552          return new external_function_parameters($params);
1553      }
1554  
1555      /**
1556       * Change the order of template competencies.
1557       *
1558       * @param int $templateid The template id
1559       * @param int $competencyidfrom The competency to move.
1560       * @param int $competencyidto The competency to move to.
1561       * @return bool
1562       */
1563      public static function reorder_template_competency($templateid, $competencyidfrom, $competencyidto) {
1564          $params = self::validate_parameters(self::reorder_template_competency_parameters(), array(
1565              'templateid' => $templateid,
1566              'competencyidfrom' => $competencyidfrom,
1567              'competencyidto' => $competencyidto,
1568          ));
1569  
1570          $template = api::read_template($params['templateid']);
1571          self::validate_context($template->get_context());
1572  
1573          return api::reorder_template_competency($params['templateid'], $params['competencyidfrom'], $params['competencyidto']);
1574      }
1575  
1576      /**
1577       * Returns description of reorder_template_competency() result value.
1578       *
1579       * @return \external_description
1580       */
1581      public static function reorder_template_competency_returns() {
1582          return new external_value(PARAM_BOOL, 'True if successful.');
1583      }
1584  
1585      /**
1586       * Returns description of create_template() parameters.
1587       *
1588       * @return \external_function_parameters
1589       */
1590      public static function create_template_parameters() {
1591          $structure = template_exporter::get_create_structure();
1592          $params = array('template' => $structure);
1593          return new external_function_parameters($params);
1594      }
1595  
1596      /**
1597       * Create a new learning plan template
1598       *
1599       * @param array $template The list of fields for the template.
1600       * @return \stdClass Record of new template.
1601       */
1602      public static function create_template($template) {
1603          global $PAGE;
1604  
1605          $params = self::validate_parameters(self::create_template_parameters(), array('template' => $template));
1606          $params = $params['template'];
1607          $context = self::get_context_from_params($params);
1608          self::validate_context($context);
1609          $output = $PAGE->get_renderer('core');
1610  
1611          unset($params['contextlevel']);
1612          unset($params['instanceid']);
1613          $params = (object) $params;
1614          $params->contextid = $context->id;
1615  
1616          $result = api::create_template($params);
1617          $exporter = new template_exporter($result);
1618          $record = $exporter->export($output);
1619          return $record;
1620      }
1621  
1622      /**
1623       * Returns description of create_template() result value.
1624       *
1625       * @return \external_description
1626       */
1627      public static function create_template_returns() {
1628          return template_exporter::get_read_structure();
1629      }
1630  
1631      /**
1632       * Returns description of read_template() parameters.
1633       *
1634       * @return \external_function_parameters
1635       */
1636      public static function read_template_parameters() {
1637          $id = new external_value(
1638              PARAM_INT,
1639              'Data base record id for the template',
1640              VALUE_REQUIRED
1641          );
1642  
1643          $params = array(
1644              'id' => $id,
1645          );
1646          return new external_function_parameters($params);
1647      }
1648  
1649      /**
1650       * Read a learning plan template by id.
1651       *
1652       * @param int $id The id of the template.
1653       * @return \stdClass
1654       */
1655      public static function read_template($id) {
1656          global $PAGE;
1657  
1658          $params = self::validate_parameters(self::read_template_parameters(), array('id' => $id));
1659          $template = api::read_template($params['id']);
1660          self::validate_context($template->get_context());
1661          $output = $PAGE->get_renderer('core');
1662  
1663          $exporter = new template_exporter($template);
1664          $record = $exporter->export($output);
1665          return $record;
1666      }
1667  
1668      /**
1669       * Returns description of read_template() result value.
1670       *
1671       * @return \external_description
1672       */
1673      public static function read_template_returns() {
1674          return template_exporter::get_read_structure();
1675      }
1676  
1677      /**
1678       * Returns description of delete_template() parameters.
1679       *
1680       * @return \external_function_parameters
1681       */
1682      public static function delete_template_parameters() {
1683          $id = new external_value(
1684              PARAM_INT,
1685              'Data base record id for the template',
1686              VALUE_REQUIRED
1687          );
1688  
1689          $deleteplans = new external_value(
1690              PARAM_BOOL,
1691              'Boolean to indicate if plans must be deleted',
1692              VALUE_REQUIRED
1693          );
1694  
1695          $params = array(
1696              'id' => $id,
1697              'deleteplans' => $deleteplans
1698          );
1699          return new external_function_parameters($params);
1700      }
1701  
1702      /**
1703       * Delete a learning plan template
1704       *
1705       * @param int $id The learning plan template id
1706       * @param boolean $deleteplans True to delete the plans associated to template or false to unlink them
1707       * @return boolean
1708       */
1709      public static function delete_template($id, $deleteplans = true) {
1710          $params = self::validate_parameters(self::delete_template_parameters(), array(
1711              'id' => $id,
1712              'deleteplans' => $deleteplans,
1713          ));
1714  
1715          $template = api::read_template($params['id']);
1716          self::validate_context($template->get_context());
1717  
1718          return api::delete_template($params['id'], $params['deleteplans']);
1719      }
1720  
1721      /**
1722       * Returns description of delete_template() result value.
1723       *
1724       * @return \external_description
1725       */
1726      public static function delete_template_returns() {
1727          return new external_value(PARAM_BOOL, 'True if the delete was successful');
1728      }
1729  
1730      /**
1731       * Returns description of update_template() parameters.
1732       *
1733       * @return \external_function_parameters
1734       */
1735      public static function update_template_parameters() {
1736          $structure = template_exporter::get_update_structure();
1737          $params = array('template' => $structure);
1738          return new external_function_parameters($params);
1739      }
1740  
1741      /**
1742       * Update an existing learning plan template
1743       *
1744       * @param array $template The list of fields for the template.
1745       * @return boolean
1746       */
1747      public static function update_template($template) {
1748  
1749          $params = self::validate_parameters(self::update_template_parameters(), array('template' => $template));
1750          $params = $params['template'];
1751          $template = api::read_template($params['id']);
1752          self::validate_context($template->get_context());
1753  
1754          $params = (object) $params;
1755  
1756          return api::update_template($params);
1757      }
1758  
1759      /**
1760       * Returns description of update_template() result value.
1761       *
1762       * @return \external_description
1763       */
1764      public static function update_template_returns() {
1765          return new external_value(PARAM_BOOL, 'True if the update was successful');
1766      }
1767  
1768      /**
1769       * Returns description of duplicate_template() parameters.
1770       *
1771       * @return \external_function_parameters
1772       */
1773      public static function duplicate_template_parameters() {
1774          $templateid = new external_value(
1775              PARAM_INT,
1776              'The template id',
1777              VALUE_REQUIRED
1778          );
1779  
1780          $params = array(
1781              'id' => $templateid
1782          );
1783          return new external_function_parameters($params);
1784      }
1785  
1786      /**
1787       * Duplicate a learning plan template.
1788       *
1789       * @param int $id the id of the learning plan template to duplicate
1790       * @return boolean Record of new template.
1791       */
1792      public static function duplicate_template($id) {
1793          global $PAGE;
1794  
1795          $params = self::validate_parameters(self::duplicate_template_parameters(), array('id' => $id));
1796  
1797          $template = api::read_template($params['id']);
1798          self::validate_context($template->get_context());
1799          $output = $PAGE->get_renderer('core');
1800  
1801          $result = api::duplicate_template($params['id']);
1802          $exporter = new template_exporter($result);
1803          return $exporter->export($output);
1804      }
1805  
1806      /**
1807       * Returns description of duplicate_template() result value.
1808       *
1809       * @return \external_description
1810       */
1811      public static function duplicate_template_returns() {
1812          return template_exporter::get_read_structure();
1813      }
1814  
1815      /**
1816       * Returns description of list_templates() parameters.
1817       *
1818       * @return \external_function_parameters
1819       */
1820      public static function list_templates_parameters() {
1821          $sort = new external_value(
1822              PARAM_ALPHANUMEXT,
1823              'Column to sort by.',
1824              VALUE_DEFAULT,
1825              ''
1826          );
1827          $order = new external_value(
1828              PARAM_ALPHA,
1829              'Sort direction. Should be either ASC or DESC',
1830              VALUE_DEFAULT,
1831              ''
1832          );
1833          $skip = new external_value(
1834              PARAM_INT,
1835              'Skip this number of records before returning results',
1836              VALUE_DEFAULT,
1837              0
1838          );
1839          $limit = new external_value(
1840              PARAM_INT,
1841              'Return this number of records at most.',
1842              VALUE_DEFAULT,
1843              0
1844          );
1845          $includes = new external_value(
1846              PARAM_ALPHA,
1847              'What other contexts to fetch the templates from. (children, parents, self)',
1848              VALUE_DEFAULT,
1849              'children'
1850          );
1851          $onlyvisible = new external_value(
1852              PARAM_BOOL,
1853              'If should list only visible templates',
1854              VALUE_DEFAULT,
1855              false
1856          );
1857  
1858          $params = array(
1859              'sort' => $sort,
1860              'order' => $order,
1861              'skip' => $skip,
1862              'limit' => $limit,
1863              'context' => self::get_context_parameters(),
1864              'includes' => $includes,
1865              'onlyvisible' => $onlyvisible
1866          );
1867          return new external_function_parameters($params);
1868      }
1869  
1870      /**
1871       * List the existing learning plan templates
1872       *
1873       * @param string $sort Field to sort by.
1874       * @param string $order Sort order.
1875       * @param int $skip Limitstart.
1876       * @param int $limit Number of rows to return.
1877       * @param array $context
1878       * @param bool $includes
1879       * @param bool $onlyvisible
1880       *
1881       * @return array
1882       */
1883      public static function list_templates($sort, $order, $skip, $limit, $context, $includes, $onlyvisible) {
1884          global $PAGE;
1885  
1886          $params = self::validate_parameters(self::list_templates_parameters(), array(
1887              'sort' => $sort,
1888              'order' => $order,
1889              'skip' => $skip,
1890              'limit' => $limit,
1891              'context' => $context,
1892              'includes' => $includes,
1893              'onlyvisible' => $onlyvisible
1894          ));
1895  
1896          $context = self::get_context_from_params($params['context']);
1897          self::validate_context($context);
1898          $output = $PAGE->get_renderer('core');
1899  
1900          if ($params['order'] !== '' && $params['order'] !== 'ASC' && $params['order'] !== 'DESC') {
1901              throw new invalid_parameter_exception('Invalid order param. Must be ASC, DESC or empty.');
1902          }
1903  
1904          $results = api::list_templates($params['sort'],
1905                                         $params['order'],
1906                                         $params['skip'],
1907                                         $params['limit'],
1908                                         $context,
1909                                         $params['includes'],
1910                                         $params['onlyvisible']);
1911          $records = array();
1912          foreach ($results as $result) {
1913              $exporter = new template_exporter($result);
1914              $record = $exporter->export($output);
1915              array_push($records, $record);
1916          }
1917          return $records;
1918      }
1919  
1920      /**
1921       * Returns description of list_templates() result value.
1922       *
1923       * @return \external_description
1924       */
1925      public static function list_templates_returns() {
1926          return new external_multiple_structure(template_exporter::get_read_structure());
1927      }
1928  
1929      /**
1930       * Returns description of count_templates() parameters.
1931       *
1932       * @return \external_function_parameters
1933       */
1934      public static function count_templates_parameters() {
1935          $includes = new external_value(
1936              PARAM_ALPHA,
1937              'What other contextes to fetch the frameworks from. (children, parents, self)',
1938              VALUE_DEFAULT,
1939              'children'
1940          );
1941  
1942          $params = array(
1943              'context' => self::get_context_parameters(),
1944              'includes' => $includes
1945          );
1946          return new external_function_parameters($params);
1947      }
1948  
1949      /**
1950       * Count the existing learning plan templates
1951       *
1952       * @param array $context
1953       * @param string $includes
1954       * @return int
1955       */
1956      public static function count_templates($context, $includes) {
1957          $params = self::validate_parameters(self::count_templates_parameters(), array(
1958              'context' => $context,
1959              'includes' => $includes
1960          ));
1961          $context = self::get_context_from_params($params['context']);
1962          self::validate_context($context);
1963  
1964          return api::count_templates($context, $includes);
1965      }
1966  
1967      /**
1968       * Returns description of count_templates() result value.
1969       *
1970       * @return \external_description
1971       */
1972      public static function count_templates_returns() {
1973          return new external_value(PARAM_INT, 'The number of learning plan templates found.');
1974      }
1975  
1976      /**
1977       * Returns description of count_templates_using_competency() parameters.
1978       *
1979       * @return \external_function_parameters
1980       */
1981      public static function count_templates_using_competency_parameters() {
1982          $competencyid = new external_value(
1983              PARAM_INT,
1984              'The competency id',
1985              VALUE_REQUIRED
1986          );
1987          $params = array(
1988              'id' => $competencyid,
1989          );
1990          return new external_function_parameters($params);
1991      }
1992  
1993      /**
1994       * Count the learning plan templates (visible to this user) that use this competency.
1995       *
1996       * @param int $competencyid Competency id.
1997       * @return int
1998       */
1999      public static function count_templates_using_competency($competencyid) {
2000          $params = self::validate_parameters(self::count_templates_using_competency_parameters(), array(
2001              'id' => $competencyid,
2002          ));
2003  
2004          $competency = api::read_competency($params['id']);
2005          self::validate_context($competency->get_context());
2006  
2007          return api::count_templates_using_competency($params['id']);
2008      }
2009  
2010      /**
2011       * Returns description of count_templates_using_competency() result value.
2012       *
2013       * @return \external_description
2014       */
2015      public static function count_templates_using_competency_returns() {
2016          return new external_value(PARAM_INT, 'The number of learning plan templates using this competency');
2017      }
2018  
2019      /**
2020       * Returns description of list_templates_using_competency() parameters.
2021       *
2022       * @return \external_function_parameters
2023       */
2024      public static function list_templates_using_competency_parameters() {
2025          $competencyid = new external_value(
2026              PARAM_INT,
2027              'The competency id',
2028              VALUE_REQUIRED
2029          );
2030          $params = array(
2031              'id' => $competencyid,
2032          );
2033          return new external_function_parameters($params);
2034      }
2035  
2036      /**
2037       * List the learning plan templates (visible to this user) that use this competency.
2038       *
2039       * @param int $competencyid Competency id.
2040       * @return array
2041       */
2042      public static function list_templates_using_competency($competencyid) {
2043          global $PAGE;
2044  
2045          $params = self::validate_parameters(self::list_templates_using_competency_parameters(), array(
2046              'id' => $competencyid,
2047          ));
2048  
2049          $competency = api::read_competency($params['id']);
2050          self::validate_context($competency->get_context());
2051          $output = $PAGE->get_renderer('core');
2052  
2053          $templates = api::list_templates_using_competency($params['id']);
2054          $records = array();
2055  
2056          foreach ($templates as $template) {
2057              $exporter = new template_exporter($template);
2058              $record = $exporter->export($output);
2059              $records[] = $record;
2060          }
2061  
2062          return $records;
2063      }
2064  
2065      /**
2066       * Returns description of list_templates_using_competency() result value.
2067       *
2068       * @return \external_description
2069       */
2070      public static function list_templates_using_competency_returns() {
2071          return new external_multiple_structure(template_exporter::get_read_structure());
2072      }
2073  
2074      /**
2075       * Returns description of count_competencies_in_template() parameters.
2076       *
2077       * @return \external_function_parameters
2078       */
2079      public static function count_competencies_in_template_parameters() {
2080          $templateid = new external_value(
2081              PARAM_INT,
2082              'The template id',
2083              VALUE_REQUIRED
2084          );
2085          $params = array(
2086              'id' => $templateid,
2087          );
2088          return new external_function_parameters($params);
2089      }
2090  
2091      /**
2092       * Count the competencies (visible to this user) in this learning plan template.
2093       *
2094       * @param int $templateid The template id to check
2095       * @return int
2096       */
2097      public static function count_competencies_in_template($templateid) {
2098          $params = self::validate_parameters(self::count_competencies_in_template_parameters(), array(
2099              'id' => $templateid,
2100          ));
2101          $template = api::read_template($params['id']);
2102          self::validate_context($template->get_context());
2103  
2104          return api::count_competencies_in_template($params['id']);
2105      }
2106  
2107      /**
2108       * Returns description of count_competencies_in_template() result value.
2109       *
2110       * @return \external_description
2111       */
2112      public static function count_competencies_in_template_returns() {
2113          return new external_value(PARAM_INT, 'The number of competencies in this learning plan template.');
2114      }
2115  
2116      /**
2117       * Returns description of list_competencies_in_template() parameters.
2118       *
2119       * @return \external_function_parameters
2120       */
2121      public static function list_competencies_in_template_parameters() {
2122          $templateid = new external_value(
2123              PARAM_INT,
2124              'The template id',
2125              VALUE_REQUIRED
2126          );
2127          $params = array(
2128              'id' => $templateid,
2129          );
2130          return new external_function_parameters($params);
2131      }
2132  
2133      /**
2134       * List the competencies (visible to this user) in this learning plan template.
2135       *
2136       * @param int $templateid Template id.
2137       * @return array
2138       */
2139      public static function list_competencies_in_template($templateid) {
2140          global $PAGE;
2141  
2142          $params = self::validate_parameters(self::list_competencies_in_template_parameters(), array(
2143              'id' => $templateid,
2144          ));
2145  
2146          $template = api::read_template($params['id']);
2147          self::validate_context($template->get_context());
2148          $output = $PAGE->get_renderer('core');
2149  
2150          $competencies = api::list_competencies_in_template($params['id']);
2151          $results = array();
2152          $contextcache = array();
2153  
2154          foreach ($competencies as $competency) {
2155              if (!isset($contextcache[$competency->get_competencyframeworkid()])) {
2156                  $contextcache[$competency->get_competencyframeworkid()] = $competency->get_context();
2157              }
2158              $context = $contextcache[$competency->get_competencyframeworkid()];
2159              $exporter = new competency_exporter($competency, array('context' => $context));
2160              $record = $exporter->export($output);
2161              array_push($results, $record);
2162          }
2163          return $results;
2164      }
2165  
2166      /**
2167       * Returns description of list_competencies_in_template() result value.
2168       *
2169       * @return \external_description
2170       */
2171      public static function list_competencies_in_template_returns() {
2172          return new external_multiple_structure(competency_exporter::get_read_structure());
2173      }
2174  
2175      /**
2176       * Returns description of add_competency_to_template() parameters.
2177       *
2178       * @return \external_function_parameters
2179       */
2180      public static function add_competency_to_template_parameters() {
2181          $templateid = new external_value(
2182              PARAM_INT,
2183              'The template id',
2184              VALUE_REQUIRED
2185          );
2186          $competencyid = new external_value(
2187              PARAM_INT,
2188              'The competency id',
2189              VALUE_REQUIRED
2190          );
2191          $params = array(
2192              'templateid' => $templateid,
2193              'competencyid' => $competencyid,
2194          );
2195          return new external_function_parameters($params);
2196      }
2197  
2198      /**
2199       * Count the competencies (visible to this user) in this template.
2200       *
2201       * @param int $templateid Template id.
2202       * @param int $competencyid Competency id.
2203       * @return int
2204       */
2205      public static function add_competency_to_template($templateid, $competencyid) {
2206          global $PAGE;
2207          $params = self::validate_parameters(self::add_competency_to_template_parameters(), array(
2208              'templateid' => $templateid,
2209              'competencyid' => $competencyid,
2210          ));
2211  
2212          $template = api::read_template($params['templateid']);
2213          self::validate_context($template->get_context());
2214  
2215          return api::add_competency_to_template($params['templateid'], $params['competencyid']);
2216      }
2217  
2218      /**
2219       * Returns description of add_competency_to_template() result value.
2220       *
2221       * @return \external_description
2222       */
2223      public static function add_competency_to_template_returns() {
2224          return new external_value(PARAM_BOOL, 'True if successful.');
2225      }
2226  
2227      /**
2228       * Returns description of add_competency_to_plan() parameters.
2229       *
2230       * @return \external_function_parameters
2231       */
2232      public static function add_competency_to_plan_parameters() {
2233          $planid = new external_value(
2234              PARAM_INT,
2235              'The plan id',
2236              VALUE_REQUIRED
2237          );
2238          $competencyid = new external_value(
2239              PARAM_INT,
2240              'The competency id',
2241              VALUE_REQUIRED
2242          );
2243          $params = array(
2244              'planid' => $planid,
2245              'competencyid' => $competencyid,
2246          );
2247          return new external_function_parameters($params);
2248      }
2249  
2250      /**
2251       * add competency to a learning plan.
2252       *
2253       * @param int $planid Plan id.
2254       * @param int $competencyid Competency id.
2255       * @return int
2256       */
2257      public static function add_competency_to_plan($planid, $competencyid) {
2258          $params = self::validate_parameters(self::add_competency_to_plan_parameters(), array(
2259              'planid' => $planid,
2260              'competencyid' => $competencyid,
2261          ));
2262  
2263          $plan = api::read_plan($params['planid']);
2264          self::validate_context($plan->get_context());
2265  
2266          return api::add_competency_to_plan($params['planid'], $params['competencyid']);
2267      }
2268  
2269      /**
2270       * Returns description of add_competency_to_plan() result value.
2271       *
2272       * @return \external_description
2273       */
2274      public static function add_competency_to_plan_returns() {
2275          return new external_value(PARAM_BOOL, 'True if successful.');
2276      }
2277  
2278      /**
2279       * Returns description of remove_competency_from_plan() parameters.
2280       *
2281       * @return \external_function_parameters
2282       */
2283      public static function remove_competency_from_plan_parameters() {
2284          $planid = new external_value(
2285              PARAM_INT,
2286              'The plan id',
2287              VALUE_REQUIRED
2288          );
2289          $competencyid = new external_value(
2290              PARAM_INT,
2291              'The competency id',
2292              VALUE_REQUIRED
2293          );
2294          $params = array(
2295              'planid' => $planid,
2296              'competencyid' => $competencyid,
2297          );
2298          return new external_function_parameters($params);
2299      }
2300  
2301      /**
2302       * Remove a competency from plan.
2303       *
2304       * @param int $planid Plan id.
2305       * @param int $competencyid Competency id.
2306       * @return int
2307       */
2308      public static function remove_competency_from_plan($planid, $competencyid) {
2309          $params = self::validate_parameters(self::remove_competency_from_plan_parameters(), array(
2310              'planid' => $planid,
2311              'competencyid' => $competencyid,
2312          ));
2313          $plan = api::read_plan($params['planid']);
2314          self::validate_context($plan->get_context());
2315  
2316          return api::remove_competency_from_plan($params['planid'], $params['competencyid']);
2317      }
2318  
2319      /**
2320       * Returns description of remove_competency_from_plan() result value.
2321       *
2322       * @return \external_description
2323       */
2324      public static function remove_competency_from_plan_returns() {
2325          return new external_value(PARAM_BOOL, 'True if successful.');
2326      }
2327  
2328      /**
2329       * Returns description of remove_competency_from_template() parameters.
2330       *
2331       * @return \external_function_parameters
2332       */
2333      public static function remove_competency_from_template_parameters() {
2334          $templateid = new external_value(
2335              PARAM_INT,
2336              'The template id',
2337              VALUE_REQUIRED
2338          );
2339          $competencyid = new external_value(
2340              PARAM_INT,
2341              'The competency id',
2342              VALUE_REQUIRED
2343          );
2344          $params = array(
2345              'templateid' => $templateid,
2346              'competencyid' => $competencyid,
2347          );
2348          return new external_function_parameters($params);
2349      }
2350  
2351      /**
2352       * Returns description of reorder_plan_competency() parameters.
2353       *
2354       * @return \external_function_parameters
2355       */
2356      public static function reorder_plan_competency_parameters() {
2357          $planid = new external_value(
2358              PARAM_INT,
2359              'The plan id',
2360              VALUE_REQUIRED
2361          );
2362          $competencyidfrom = new external_value(
2363              PARAM_INT,
2364              'The competency id we are moving',
2365              VALUE_REQUIRED
2366          );
2367          $competencyidto = new external_value(
2368              PARAM_INT,
2369              'The competency id we are moving to',
2370              VALUE_REQUIRED
2371          );
2372          $params = array(
2373              'planid' => $planid,
2374              'competencyidfrom' => $competencyidfrom,
2375              'competencyidto' => $competencyidto,
2376          );
2377          return new external_function_parameters($params);
2378      }
2379  
2380      /**
2381       * Change the order of plan competencies.
2382       *
2383       * @param int $planid The plan id
2384       * @param int $competencyidfrom The competency to move.
2385       * @param int $competencyidto The competency to move to.
2386       * @return bool
2387       */
2388      public static function reorder_plan_competency($planid, $competencyidfrom, $competencyidto) {
2389          $params = self::validate_parameters(self::reorder_plan_competency_parameters(), array(
2390              'planid' => $planid,
2391              'competencyidfrom' => $competencyidfrom,
2392              'competencyidto' => $competencyidto,
2393          ));
2394  
2395          $plan = api::read_plan($params['planid']);
2396          self::validate_context($plan->get_context());
2397  
2398          return api::reorder_plan_competency($params['planid'], $params['competencyidfrom'], $params['competencyidto']);
2399      }
2400  
2401      /**
2402       * Returns description of reorder_plan_competency() result value.
2403       *
2404       * @return \external_description
2405       */
2406      public static function reorder_plan_competency_returns() {
2407          return new external_value(PARAM_BOOL, 'True if successful.');
2408      }
2409  
2410      /**
2411       * Returns description of external function parameters.
2412       *
2413       * @return \external_function_parameters
2414       */
2415      public static function user_competency_cancel_review_request_parameters() {
2416          return new external_function_parameters(array(
2417              'userid' => new external_value(PARAM_INT, 'The user ID'),
2418              'competencyid' => new external_value(PARAM_INT, 'The competency ID'),
2419          ));
2420      }
2421  
2422      /**
2423       * External function user_competency_cancel_review_request.
2424       *
2425       * @param int $userid The user ID.
2426       * @param int $competencyid The competency ID.
2427       * @return boolean
2428       */
2429      public static function user_competency_cancel_review_request($userid, $competencyid) {
2430          $params = self::validate_parameters(self::user_competency_cancel_review_request_parameters(), array(
2431              'userid' => $userid,
2432              'competencyid' => $competencyid
2433          ));
2434  
2435          $context = context_user::instance($params['userid']);
2436          self::validate_context($context);
2437  
2438          return api::user_competency_cancel_review_request($userid, $competencyid);
2439      }
2440  
2441      /**
2442       * Returns description of external function result value.
2443       *
2444       * @return \external_function_parameters
2445       */
2446      public static function user_competency_cancel_review_request_returns() {
2447          return new external_value(PARAM_BOOL, 'The success');
2448      }
2449  
2450      /**
2451       * Returns description of external function parameters.
2452       *
2453       * @return \external_function_parameters
2454       */
2455      public static function user_competency_request_review_parameters() {
2456          return new external_function_parameters(array(
2457              'userid' => new external_value(PARAM_INT, 'The user ID'),
2458              'competencyid' => new external_value(PARAM_INT, 'The competency ID'),
2459          ));
2460      }
2461  
2462      /**
2463       * External function user_competency_request_review.
2464       *
2465       * @param int $userid The user ID.
2466       * @param int $competencyid The competency ID.
2467       * @return boolean
2468       */
2469      public static function user_competency_request_review($userid, $competencyid) {
2470          $params = self::validate_parameters(self::user_competency_request_review_parameters(), array(
2471              'userid' => $userid,
2472              'competencyid' => $competencyid,
2473          ));
2474  
2475          $context = context_user::instance($params['userid']);
2476          self::validate_context($context);
2477  
2478          return api::user_competency_request_review($userid, $competencyid);
2479      }
2480  
2481      /**
2482       * Returns description of external function result value.
2483       *
2484       * @return \external_function_parameters
2485       */
2486      public static function user_competency_request_review_returns() {
2487          return new external_value(PARAM_BOOL, 'The success');
2488      }
2489  
2490      /**
2491       * Returns description of external function parameters.
2492       *
2493       * @return \external_function_parameters
2494       */
2495      public static function user_competency_start_review_parameters() {
2496          return new external_function_parameters(array(
2497              'userid' => new external_value(PARAM_INT, 'The user ID'),
2498              'competencyid' => new external_value(PARAM_INT, 'The competency ID'),
2499          ));
2500      }
2501  
2502      /**
2503       * External function user_competency_start_review.
2504       *
2505       * @param int $userid The user ID.
2506       * @param int $competencyid The competency ID.
2507       * @return boolean
2508       */
2509      public static function user_competency_start_review($userid, $competencyid) {
2510          $params = self::validate_parameters(self::user_competency_start_review_parameters(), array(
2511              'userid' => $userid,
2512              'competencyid' => $competencyid
2513          ));
2514  
2515          $context = context_user::instance($params['userid']);
2516          self::validate_context($context);
2517  
2518          return api::user_competency_start_review($userid, $competencyid);
2519      }
2520  
2521      /**
2522       * Returns description of external function result value.
2523       *
2524       * @return \external_function_parameters
2525       */
2526      public static function user_competency_start_review_returns() {
2527          return new external_value(PARAM_BOOL, 'The success');
2528      }
2529  
2530      /**
2531       * Returns description of external function parameters.
2532       *
2533       * @return \external_function_parameters
2534       */
2535      public static function user_competency_stop_review_parameters() {
2536          return new external_function_parameters(array(
2537              'userid' => new external_value(PARAM_INT, 'The user ID'),
2538              'competencyid' => new external_value(PARAM_INT, 'The competency ID'),
2539          ));
2540      }
2541  
2542      /**
2543       * External function user_competency_stop_review.
2544       *
2545       * @param int $userid The user ID.
2546       * @param int $competencyid The competency ID.
2547       * @return boolean
2548       */
2549      public static function user_competency_stop_review($userid, $competencyid) {
2550          $params = self::validate_parameters(self::user_competency_stop_review_parameters(), array(
2551              'userid' => $userid,
2552              'competencyid' => $competencyid
2553          ));
2554  
2555          $context = context_user::instance($params['userid']);
2556          self::validate_context($context);
2557  
2558          return api::user_competency_stop_review($userid, $competencyid);
2559      }
2560  
2561      /**
2562       * Returns description of external function result value.
2563       *
2564       * @return \external_function_parameters
2565       */
2566      public static function user_competency_stop_review_returns() {
2567          return new external_value(PARAM_BOOL, 'The success');
2568      }
2569  
2570      /**
2571       * Returns description of template_has_related_data() parameters.
2572       *
2573       * @return \external_function_parameters
2574       */
2575      public static function template_has_related_data_parameters() {
2576          $templateid = new external_value(
2577              PARAM_INT,
2578              'The template id',
2579              VALUE_REQUIRED
2580          );
2581          $params = array(
2582              'id' => $templateid,
2583          );
2584          return new external_function_parameters($params);
2585      }
2586  
2587      /**
2588       * Check if template has related data.
2589       *
2590       * @param int $templateid Template id.
2591       * @return boolean
2592       */
2593      public static function template_has_related_data($templateid) {
2594          $params = self::validate_parameters(self::template_has_related_data_parameters(), array(
2595              'id' => $templateid,
2596          ));
2597  
2598          $template = api::read_template($params['id']);
2599          self::validate_context($template->get_context());
2600  
2601          return api::template_has_related_data($params['id']);
2602      }
2603  
2604      /**
2605       * Returns description of template_has_related_data() result value.
2606       *
2607       * @return \external_description
2608       */
2609      public static function template_has_related_data_returns() {
2610          return new external_value(PARAM_BOOL, 'True if the template has related data');
2611      }
2612  
2613      /**
2614       * Count the competencies (visible to this user) in this learning plan template.
2615       *
2616       * @param int $templateid Template id.
2617       * @param int $competencyid Competency id.
2618       * @return int
2619       */
2620      public static function remove_competency_from_template($templateid, $competencyid) {
2621          $params = self::validate_parameters(self::remove_competency_from_template_parameters(), array(
2622              'templateid' => $templateid,
2623              'competencyid' => $competencyid,
2624          ));
2625          $template = api::read_template($params['templateid']);
2626          self::validate_context($template->get_context());
2627  
2628          return api::remove_competency_from_template($params['templateid'], $params['competencyid']);
2629      }
2630  
2631      /**
2632       * Returns description of remove_competency_from_template() result value.
2633       *
2634       * @return \external_description
2635       */
2636      public static function remove_competency_from_template_returns() {
2637          return new external_value(PARAM_BOOL, 'True if successful.');
2638      }
2639  
2640      /**
2641       * Returns description of create_plan() parameters.
2642       *
2643       * @return \external_function_parameters
2644       */
2645      public static function create_plan_parameters() {
2646          $structure = plan_exporter::get_create_structure();
2647          $params = array('plan' => $structure);
2648          return new external_function_parameters($params);
2649      }
2650  
2651      /**
2652       * Create a new learning plan.
2653       *
2654       * @param array $plan List of fields for the plan.
2655       * @return array New plan record.
2656       */
2657      public static function create_plan($plan) {
2658          global $PAGE;
2659  
2660          $params = self::validate_parameters(self::create_plan_parameters(), array('plan' => $plan));
2661          $params = $params['plan'];
2662  
2663          $context = context_user::instance($params['userid']);
2664          self::validate_context($context);
2665          $output = $PAGE->get_renderer('core');
2666  
2667          $params = (object) $params;
2668  
2669          $result = api::create_plan($params);
2670          $exporter = new plan_exporter($result, array('template' => null));
2671          return $exporter->export($output);
2672      }
2673  
2674      /**
2675       * Returns description of create_plan() result value.
2676       *
2677       * @return \external_description
2678       */
2679      public static function create_plan_returns() {
2680          return plan_exporter::get_read_structure();
2681      }
2682  
2683      /**
2684       * Returns description of update_plan() parameters.
2685       *
2686       * @return \external_function_parameters
2687       */
2688      public static function update_plan_parameters() {
2689          $structure = plan_exporter::get_update_structure();
2690          $params = array('plan' => $structure);
2691          return new external_function_parameters($params);
2692      }
2693  
2694      /**
2695       * Updates a new learning plan.
2696       *
2697       * @param array $plan Fields for the plan (id is required)
2698       * @return mixed
2699       */
2700      public static function update_plan($plan) {
2701          global $PAGE;
2702  
2703          $params = self::validate_parameters(self::update_plan_parameters(), array('plan' => $plan));
2704  
2705          $params = $params['plan'];
2706  
2707          $plan = api::read_plan($params['id']);
2708          self::validate_context($plan->get_context());
2709          $output = $PAGE->get_renderer('core');
2710  
2711          $params = (object) $params;
2712          $result = api::update_plan($params);
2713          $exporter = plan_exporter($result);
2714          $record = $exporter->export($output);
2715          return external_api::clean_returnvalue(self::update_plan_returns(), $record);
2716      }
2717  
2718      /**
2719       * Returns description of update_plan() result value.
2720       *
2721       * @return \external_description
2722       */
2723      public static function update_plan_returns() {
2724          return plan_exporter::get_read_structure();
2725      }
2726  
2727      /**
2728       * Returns description of complete_plan() parameters.
2729       *
2730       * @return \external_function_parameters
2731       */
2732      public static function complete_plan_parameters() {
2733          $planid = new external_value(
2734              PARAM_INT,
2735              'The plan id',
2736              VALUE_REQUIRED
2737          );
2738          $params = array('planid' => $planid);
2739          return new external_function_parameters($params);
2740      }
2741  
2742      /**
2743       * Complete Learning plan.
2744       *
2745       * @param int $planid plan id (id is required)
2746       * @return boolean
2747       */
2748      public static function complete_plan($planid) {
2749          $params = self::validate_parameters(self::complete_plan_parameters(), array(
2750              'planid' => $planid
2751          ));
2752  
2753          return api::complete_plan($params['planid']);
2754      }
2755  
2756      /**
2757       * Returns description of complete_plan() result value.
2758       *
2759       * @return \external_description
2760       */
2761      public static function complete_plan_returns() {
2762          return new external_value(PARAM_BOOL, 'True if completing learning plan was successful');
2763      }
2764  
2765      /**
2766       * Returns description of reopen_plan() parameters.
2767       *
2768       * @return \external_function_parameters
2769       */
2770      public static function reopen_plan_parameters() {
2771          $planid = new external_value(
2772              PARAM_INT,
2773              'The plan id',
2774              VALUE_REQUIRED
2775          );
2776          $params = array('planid' => $planid);
2777          return new external_function_parameters($params);
2778      }
2779  
2780      /**
2781       * Reopen Learning plan.
2782       *
2783       * @param int $planid plan id (id is required)
2784       * @return boolean
2785       */
2786      public static function reopen_plan($planid) {
2787          $params = self::validate_parameters(self::reopen_plan_parameters(), array(
2788              'planid' => $planid
2789          ));
2790  
2791          return api::reopen_plan($params['planid']);
2792      }
2793  
2794      /**
2795       * Returns description of reopen_plan() result value.
2796       *
2797       * @return \external_description
2798       */
2799      public static function reopen_plan_returns() {
2800          return new external_value(PARAM_BOOL, 'True if reopening learning plan was successful');
2801      }
2802  
2803      /**
2804       * Returns description of read_plan() parameters.
2805       *
2806       * @return \external_function_parameters
2807       */
2808      public static function read_plan_parameters() {
2809          $id = new external_value(
2810              PARAM_INT,
2811              'Data base record id for the plan',
2812              VALUE_REQUIRED
2813          );
2814          return new external_function_parameters(array('id' => $id));
2815      }
2816  
2817      /**
2818       * Read a plan by id.
2819       *
2820       * @param int $id The id of the plan.
2821       * @return \stdClass
2822       */
2823      public static function read_plan($id) {
2824          global $PAGE;
2825  
2826          $params = self::validate_parameters(self::read_plan_parameters(), array(
2827              'id' => $id,
2828          ));
2829  
2830          $plan = api::read_plan($params['id']);
2831          self::validate_context($plan->get_context());
2832          $output = $PAGE->get_renderer('core');
2833  
2834          $exporter = new plan_exporter($plan, array('template' => $plan->get_template()));
2835          $record = $exporter->export($output);
2836          return external_api::clean_returnvalue(self::read_plan_returns(), $record);
2837      }
2838  
2839      /**
2840       * Returns description of read_plan() result value.
2841       *
2842       * @return \external_description
2843       */
2844      public static function read_plan_returns() {
2845          return plan_exporter::get_read_structure();
2846      }
2847  
2848      /**
2849       * Returns description of delete_plan() parameters.
2850       *
2851       * @return \external_function_parameters
2852       */
2853      public static function delete_plan_parameters() {
2854          $id = new external_value(
2855              PARAM_INT,
2856              'Data base record id for the learning plan',
2857              VALUE_REQUIRED
2858          );
2859  
2860          $params = array(
2861              'id' => $id,
2862          );
2863          return new external_function_parameters($params);
2864      }
2865  
2866      /**
2867       * Delete a plan.
2868       *
2869       * @param int $id The plan id
2870       * @return boolean
2871       */
2872      public static function delete_plan($id) {
2873          $params = self::validate_parameters(self::delete_plan_parameters(), array(
2874              'id' => $id,
2875          ));
2876  
2877          $plan = api::read_plan($params['id']);
2878          self::validate_context($plan->get_context());
2879  
2880          return external_api::clean_returnvalue(self::delete_plan_returns(), api::delete_plan($params['id']));
2881      }
2882  
2883      /**
2884       * Returns description of delete_plan() result value.
2885       *
2886       * @return \external_description
2887       */
2888      public static function delete_plan_returns() {
2889          return new external_value(PARAM_BOOL, 'True if the delete was successful');
2890      }
2891  
2892      /**
2893       * Returns description of external function parameters.
2894       *
2895       * @return \external_function_parameters
2896       */
2897      public static function plan_cancel_review_request_parameters() {
2898          return new external_function_parameters(array(
2899              'id' => new external_value(PARAM_INT, 'The plan ID'),
2900          ));
2901      }
2902  
2903      /**
2904       * External function plan_cancel_review_request.
2905       *
2906       * @param int $id The plan ID.
2907       * @return boolean
2908       */
2909      public static function plan_cancel_review_request($id) {
2910          $params = self::validate_parameters(self::plan_cancel_review_request_parameters(), array(
2911              'id' => $id
2912          ));
2913  
2914          $plan = api::read_plan($id);
2915          self::validate_context($plan->get_context());
2916  
2917          return api::plan_cancel_review_request($plan);
2918      }
2919  
2920      /**
2921       * Returns description of external function result value.
2922       *
2923       * @return \external_function_parameters
2924       */
2925      public static function plan_cancel_review_request_returns() {
2926          return new external_value(PARAM_BOOL, 'The success');
2927      }
2928  
2929      /**
2930       * Returns description of external function parameters.
2931       *
2932       * @return \external_function_parameters
2933       */
2934      public static function plan_request_review_parameters() {
2935          return new external_function_parameters(array(
2936              'id' => new external_value(PARAM_INT, 'The plan ID'),
2937          ));
2938      }
2939  
2940      /**
2941       * External function plan_request_review.
2942       *
2943       * @param int $id The plan ID.
2944       * @return boolean
2945       */
2946      public static function plan_request_review($id) {
2947          $params = self::validate_parameters(self::plan_request_review_parameters(), array(
2948              'id' => $id
2949          ));
2950  
2951          $plan = api::read_plan($id);
2952          self::validate_context($plan->get_context());
2953  
2954          return api::plan_request_review($plan);
2955      }
2956  
2957      /**
2958       * Returns description of external function result value.
2959       *
2960       * @return \external_function_parameters
2961       */
2962      public static function plan_request_review_returns() {
2963          return new external_value(PARAM_BOOL, 'The success');
2964      }
2965  
2966      /**
2967       * Returns description of external function parameters.
2968       *
2969       * @return \external_function_parameters
2970       */
2971      public static function plan_start_review_parameters() {
2972          return new external_function_parameters(array(
2973              'id' => new external_value(PARAM_INT, 'The plan ID'),
2974          ));
2975      }
2976  
2977      /**
2978       * External function plan_start_review.
2979       *
2980       * @param int $id The plan ID.
2981       * @return boolean
2982       */
2983      public static function plan_start_review($id) {
2984          $params = self::validate_parameters(self::plan_start_review_parameters(), array(
2985              'id' => $id
2986          ));
2987  
2988          $plan = api::read_plan($id);
2989          self::validate_context($plan->get_context());
2990  
2991          return api::plan_start_review($plan);
2992      }
2993  
2994      /**
2995       * Returns description of external function result value.
2996       *
2997       * @return \external_function_parameters
2998       */
2999      public static function plan_start_review_returns() {
3000          return new external_value(PARAM_BOOL, 'The success');
3001      }
3002  
3003      /**
3004       * Returns description of external function parameters.
3005       *
3006       * @return \external_function_parameters
3007       */
3008      public static function plan_stop_review_parameters() {
3009          return new external_function_parameters(array(
3010              'id' => new external_value(PARAM_INT, 'The plan ID'),
3011          ));
3012      }
3013  
3014      /**
3015       * External function plan_stop_review.
3016       *
3017       * @param int $id The plan ID.
3018       * @return boolean
3019       */
3020      public static function plan_stop_review($id) {
3021          $params = self::validate_parameters(self::plan_stop_review_parameters(), array(
3022              'id' => $id
3023          ));
3024  
3025          $plan = api::read_plan($id);
3026          self::validate_context($plan->get_context());
3027  
3028          return api::plan_stop_review($plan);
3029      }
3030  
3031      /**
3032       * Returns description of external function result value.
3033       *
3034       * @return \external_function_parameters
3035       */
3036      public static function plan_stop_review_returns() {
3037          return new external_value(PARAM_BOOL, 'The success');
3038      }
3039  
3040      /**
3041       * Returns description of external function parameters.
3042       *
3043       * @return \external_function_parameters
3044       */
3045      public static function approve_plan_parameters() {
3046          return new external_function_parameters(array(
3047              'id' => new external_value(PARAM_INT, 'The plan ID'),
3048          ));
3049      }
3050  
3051      /**
3052       * External function approve_plan.
3053       *
3054       * @param int $id The plan ID.
3055       * @return boolean
3056       */
3057      public static function approve_plan($id) {
3058          $params = self::validate_parameters(self::approve_plan_parameters(), array(
3059              'id' => $id,
3060          ));
3061  
3062          $plan = api::read_plan($id);
3063          self::validate_context($plan->get_context());
3064  
3065          return api::approve_plan($plan);
3066      }
3067  
3068      /**
3069       * Returns description of external function result value.
3070       *
3071       * @return \external_function_parameters
3072       */
3073      public static function approve_plan_returns() {
3074          return new external_value(PARAM_BOOL, 'The success');
3075      }
3076  
3077      /**
3078       * Returns description of external function parameters.
3079       *
3080       * @return \external_function_parameters
3081       */
3082      public static function unapprove_plan_parameters() {
3083          return new external_function_parameters(array(
3084              'id' => new external_value(PARAM_INT, 'The plan ID'),
3085          ));
3086      }
3087  
3088      /**
3089       * External function unapprove_plan.
3090       *
3091       * @param int $id The plan ID.
3092       * @return boolean
3093       */
3094      public static function unapprove_plan($id) {
3095          $params = self::validate_parameters(self::unapprove_plan_parameters(), array(
3096              'id' => $id,
3097          ));
3098  
3099          $plan = api::read_plan($id);
3100          self::validate_context($plan->get_context());
3101  
3102          return api::unapprove_plan($plan);
3103      }
3104  
3105      /**
3106       * Returns description of external function result value.
3107       *
3108       * @return \external_function_parameters
3109       */
3110      public static function unapprove_plan_returns() {
3111          return new external_value(PARAM_BOOL, 'The success');
3112      }
3113  
3114      /**
3115       * External function parameters structure.
3116       *
3117       * @return \external_description
3118       */
3119      public static function list_plan_competencies_parameters() {
3120          return new external_function_parameters(array(
3121              'id' => new external_value(PARAM_INT, 'The plan ID.')
3122          ));
3123      }
3124  
3125      /**
3126       * List plan competencies.
3127       * @param  int $id The plan ID.
3128       * @return array
3129       */
3130      public static function list_plan_competencies($id) {
3131          global $PAGE;
3132  
3133          $params = self::validate_parameters(self::list_plan_competencies_parameters(), array('id' => $id));
3134          $id = $params['id'];
3135          $plan = api::read_plan($id);
3136          $usercontext = $plan->get_context();
3137          self::validate_context($usercontext);
3138          $output = $PAGE->get_renderer('core');
3139  
3140          $result = api::list_plan_competencies($plan);
3141  
3142          if ($plan->get_status() == plan::STATUS_COMPLETE) {
3143              $ucproperty = 'usercompetencyplan';
3144          } else {
3145              $ucproperty = 'usercompetency';
3146          }
3147  
3148          $contextcache = array();
3149          $scalecache = array();
3150  
3151          foreach ($result as $key => $r) {
3152              if (!isset($scalecache[$r->competency->get_competencyframeworkid()])) {
3153                  $scalecache[$r->competency->get_competencyframeworkid()] = $r->competency->get_framework()->get_scale();
3154              }
3155              $scale = $scalecache[$r->competency->get_competencyframeworkid()];
3156  
3157              if (!isset($contextcache[$r->competency->get_competencyframeworkid()])) {
3158                  $contextcache[$r->competency->get_competencyframeworkid()] = $r->competency->get_context();
3159              }
3160              $context = $contextcache[$r->competency->get_competencyframeworkid()];
3161  
3162              $exporter = new competency_exporter($r->competency, array('context' => $context));
3163              $r->competency = $exporter->export($output);
3164  
3165              if ($r->usercompetency) {
3166                  $exporter = new user_competency_exporter($r->usercompetency, array('scale' => $scale));
3167                  $r->usercompetency = $exporter->export($output);
3168                  unset($r->usercompetencyplan);
3169              } else {
3170                  $exporter = new user_competency_plan_exporter($r->usercompetencyplan, array('scale' => $scale));
3171                  $r->usercompetencyplan = $exporter->export($output);
3172                  unset($r->usercompetency);
3173              }
3174          }
3175          return $result;
3176      }
3177  
3178      /**
3179       * External function return structure.
3180       *
3181       * @return \external_description
3182       */
3183      public static function list_plan_competencies_returns() {
3184          $uc = user_competency_exporter::get_read_structure();
3185          $ucp = user_competency_plan_exporter::get_read_structure();
3186  
3187          $uc->required = VALUE_OPTIONAL;
3188          $ucp->required = VALUE_OPTIONAL;
3189  
3190          return new external_multiple_structure(
3191              new external_single_structure(array(
3192                  'competency' => competency_exporter::get_read_structure(),
3193                  'usercompetency' => $uc,
3194                  'usercompetencyplan' => $ucp
3195              ))
3196          );
3197      }
3198  
3199      /**
3200       * Returns description of external function parameters.
3201       *
3202       * @return \external_function_parameters
3203       */
3204      public static function list_user_plans_parameters() {
3205          return new external_function_parameters(array(
3206              'userid' => new external_value(PARAM_INT, 'The user ID'),
3207          ));
3208      }
3209  
3210      /**
3211       * External function list_user_plans.
3212       *
3213       * @param int $userid The user ID.
3214       * @return boolean
3215       */
3216      public static function list_user_plans($userid) {
3217          global $PAGE;
3218          $params = self::validate_parameters(self::list_user_plans_parameters(), array(
3219              'userid' => $userid
3220          ));
3221  
3222          $context = context_user::instance($params['userid']);
3223          self::validate_context($context);
3224          $output = $PAGE->get_renderer('core');
3225  
3226          $response = array();
3227          $plans = api::list_user_plans($params['userid']);
3228          foreach ($plans as $plan) {
3229              $exporter = new plan_exporter($plan, array('template' => $plan->get_template()));
3230              $response[] = $exporter->export($output);
3231          }
3232  
3233          return $response;
3234      }
3235  
3236      /**
3237       * Returns description of external function result value.
3238       *
3239       * @return \external_function_parameters
3240       */
3241      public static function list_user_plans_returns() {
3242          return new external_multiple_structure(
3243              plan_exporter::get_read_structure()
3244          );
3245      }
3246  
3247      /**
3248       * Returns description of external function parameters.
3249       *
3250       * @return \external_description
3251       */
3252      public static function read_user_evidence_parameters() {
3253          return new external_function_parameters(array(
3254              'id' => new external_value(PARAM_INT, 'The user evidence ID.'),
3255          ));
3256      }
3257  
3258      /**
3259       * Delete a user evidence.
3260       *
3261       * @param int $id The evidence id
3262       * @return boolean
3263       */
3264      public static function read_user_evidence($id) {
3265          global $PAGE;
3266          $params = self::validate_parameters(self::read_user_evidence_parameters(), array('id' => $id));
3267  
3268          $userevidence = api::read_user_evidence($params['id']);
3269          $context = $userevidence->get_context();
3270          self::validate_context($context);
3271          $output = $PAGE->get_renderer('core');
3272  
3273          $exporter = new user_evidence_exporter($userevidence, array('context' => $context,
3274              'competencies' => $userevidence->get_competencies()));
3275          return $exporter->export($output);
3276      }
3277  
3278      /**
3279       * Returns description of external function result value.
3280       *
3281       * @return \external_description
3282       */
3283      public static function read_user_evidence_returns() {
3284          return user_evidence_exporter::get_read_structure();
3285      }
3286  
3287      /**
3288       * Returns description of external function parameters.
3289       *
3290       * @return \external_function_parameters
3291       */
3292      public static function delete_user_evidence_parameters() {
3293          return new external_function_parameters(array(
3294              'id' => new external_value(PARAM_INT, 'The user evidence ID.'),
3295          ));
3296      }
3297  
3298      /**
3299       * Delete a user evidence.
3300       *
3301       * @param int $id The evidence id
3302       * @return boolean
3303       */
3304      public static function delete_user_evidence($id) {
3305          $params = self::validate_parameters(self::delete_user_evidence_parameters(), array('id' => $id));
3306  
3307          $userevidence = api::read_user_evidence($params['id']);
3308          self::validate_context($userevidence->get_context());
3309  
3310          return api::delete_user_evidence($userevidence->get_id());
3311      }
3312  
3313      /**
3314       * Returns description of external function result value.
3315       *
3316       * @return \external_description
3317       */
3318      public static function delete_user_evidence_returns() {
3319          return new external_value(PARAM_BOOL, 'True if the delete was successful');
3320      }
3321  
3322      /**
3323       * Returns description of external function parameters.
3324       *
3325       * @return \external_function_parameters
3326       */
3327      public static function create_user_evidence_competency_parameters() {
3328          return new external_function_parameters(array(
3329              'userevidenceid' => new external_value(PARAM_INT, 'The user evidence ID.'),
3330              'competencyid' => new external_value(PARAM_INT, 'The competency ID.'),
3331          ));
3332      }
3333  
3334      /**
3335       * Delete a user evidence competency relationship.
3336       *
3337       * @param int $userevidenceid The user evidence id.
3338       * @param int $competencyid The competency id.
3339       * @return boolean
3340       */
3341      public static function create_user_evidence_competency($userevidenceid, $competencyid) {
3342          global $PAGE;
3343          $params = self::validate_parameters(self::create_user_evidence_competency_parameters(), array(
3344              'userevidenceid' => $userevidenceid,
3345              'competencyid' => $competencyid,
3346          ));
3347  
3348          $userevidence = api::read_user_evidence($params['userevidenceid']);
3349          self::validate_context($userevidence->get_context());
3350  
3351          $relation = api::create_user_evidence_competency($userevidence, $competencyid);
3352          $exporter = new user_evidence_competency_exporter($relation);
3353          return $exporter->export($PAGE->get_renderer('core'));
3354      }
3355  
3356      /**
3357       * Returns description of external function result value.
3358       *
3359       * @return \external_description
3360       */
3361      public static function create_user_evidence_competency_returns() {
3362          return user_evidence_competency_exporter::get_read_structure();
3363      }
3364  
3365      /**
3366       * Returns description of external function parameters.
3367       *
3368       * @return \external_function_parameters
3369       */
3370      public static function delete_user_evidence_competency_parameters() {
3371          return new external_function_parameters(array(
3372              'userevidenceid' => new external_value(PARAM_INT, 'The user evidence ID.'),
3373              'competencyid' => new external_value(PARAM_INT, 'The competency ID.'),
3374          ));
3375      }
3376  
3377      /**
3378       * Delete a user evidence competency relationship.
3379       *
3380       * @param int $userevidenceid The user evidence id.
3381       * @param int $competencyid The competency id.
3382       * @return boolean
3383       */
3384      public static function delete_user_evidence_competency($userevidenceid, $competencyid) {
3385          $params = self::validate_parameters(self::delete_user_evidence_competency_parameters(), array(
3386              'userevidenceid' => $userevidenceid,
3387              'competencyid' => $competencyid,
3388          ));
3389  
3390          $userevidence = api::read_user_evidence($params['userevidenceid']);
3391          self::validate_context($userevidence->get_context());
3392  
3393          return api::delete_user_evidence_competency($userevidence, $params['competencyid']);
3394      }
3395  
3396      /**
3397       * Returns description of external function result value.
3398       *
3399       * @return \external_description
3400       */
3401      public static function delete_user_evidence_competency_returns() {
3402          return new external_value(PARAM_BOOL, 'True if the delete was successful');
3403      }
3404  
3405      /**
3406       * Returns description of external function parameters.
3407       *
3408       * @return \external_function_parameters
3409       */
3410      public static function request_review_of_user_evidence_linked_competencies_parameters() {
3411          return new external_function_parameters(array(
3412              'id' => new external_value(PARAM_INT, 'The user evidence ID.')
3413          ));
3414      }
3415  
3416      /**
3417       * Send user evidence competencies to review.
3418       *
3419       * @param int $id The user evidence id.
3420       * @return boolean
3421       */
3422      public static function request_review_of_user_evidence_linked_competencies($id) {
3423          $params = self::validate_parameters(self::request_review_of_user_evidence_linked_competencies_parameters(), array(
3424              'id' => $id
3425          ));
3426  
3427          $userevidence = api::read_user_evidence($id);
3428          self::validate_context($userevidence->get_context());
3429  
3430          return api::request_review_of_user_evidence_linked_competencies($id);
3431      }
3432  
3433      /**
3434       * Returns description of external function result value.
3435       *
3436       * @return \external_description
3437       */
3438      public static function request_review_of_user_evidence_linked_competencies_returns() {
3439          return new external_value(PARAM_BOOL, 'True if all competencies were send to review');
3440      }
3441  
3442  
3443      /**
3444       * Returns the description of the get_scale_values() parameters.
3445       *
3446       * @return external_function_parameters.
3447       */
3448      public static function get_scale_values_parameters() {
3449          $scaleid = new external_value(
3450              PARAM_INT,
3451              'The scale id',
3452              VALUE_REQUIRED
3453          );
3454          $params = array('scaleid' => $scaleid);
3455          return new external_function_parameters($params);
3456      }
3457  
3458      /**
3459       * Get the values associated with a scale.
3460       *
3461       * @param int $scaleid Scale ID
3462       * @return array Values for a scale.
3463       */
3464      public static function get_scale_values($scaleid) {
3465          global $DB;
3466          $params = self::validate_parameters(self::get_scale_values_parameters(),
3467              array(
3468                  'scaleid' => $scaleid,
3469              )
3470          );
3471          $context = context_system::instance();
3472          self::validate_context($context);
3473          // The following section is not learning plan specific and so has not been moved to the api.
3474          // Retrieve the scale value from the database.
3475          $scale = grade_scale::fetch(array('id' => $scaleid));
3476          $scalevalues = $scale->load_items();
3477          foreach ($scalevalues as $key => $value) {
3478              // Add a key (make the first value 1).
3479              $scalevalues[$key] = array(
3480                      'id' => $key + 1,
3481                      'name' => external_format_string($value, $context->id)
3482                  );
3483          }
3484          return $scalevalues;
3485      }
3486  
3487      /**
3488       * Returns description of get_scale_values() result value.
3489       *
3490       * @return external_multiple_structure
3491       */
3492      public static function get_scale_values_returns() {
3493          return new external_multiple_structure(
3494              new external_single_structure(array(
3495                  'id' => new external_value(PARAM_INT, 'Scale value ID'),
3496                  'name' => new external_value(PARAM_RAW, 'Scale value name')
3497              ))
3498          );
3499      }
3500  
3501  
3502      /**
3503       * Returns the description of the add_related_competency_parameters() parameters.
3504       *
3505       * @return external_function_parameters.
3506       */
3507      public static function add_related_competency_parameters() {
3508          $competencyid = new external_value(
3509              PARAM_INT,
3510              'The competency id',
3511              VALUE_REQUIRED
3512          );
3513          $relatedcompetencyid = new external_value(
3514              PARAM_INT,
3515              'The related competency id',
3516              VALUE_REQUIRED
3517          );
3518          $params = array(
3519              'competencyid' => $competencyid,
3520              'relatedcompetencyid' => $relatedcompetencyid
3521          );
3522          return new external_function_parameters($params);
3523      }
3524  
3525      /**
3526       * Adds a related competency.
3527       *
3528       * @param int $competencyid
3529       * @param int $relatedcompetencyid
3530       * @return bool
3531       */
3532      public static function add_related_competency($competencyid, $relatedcompetencyid) {
3533          $params = self::validate_parameters(self::add_related_competency_parameters(), array(
3534              'competencyid' => $competencyid,
3535              'relatedcompetencyid' => $relatedcompetencyid
3536          ));
3537          $competency = api::read_competency($params['competencyid']);
3538          self::validate_context($competency->get_context());
3539  
3540          return api::add_related_competency($params['competencyid'], $params['relatedcompetencyid']);
3541      }
3542  
3543      /**
3544       * Returns description of add_related_competency_returns() result value.
3545       *
3546       * @return external_description
3547       */
3548      public static function add_related_competency_returns() {
3549          return new external_value(PARAM_BOOL, 'True if successful.');
3550      }
3551  
3552      /**
3553       * Returns the description of the remove_related_competency_parameters() parameters.
3554       *
3555       * @return external_function_parameters.
3556       */
3557      public static function remove_related_competency_parameters() {
3558          $competencyid = new external_value(
3559              PARAM_INT,
3560              'The competency id',
3561              VALUE_REQUIRED
3562          );
3563          $relatedcompetencyid = new external_value(
3564              PARAM_INT,
3565              'The related competency id',
3566              VALUE_REQUIRED
3567          );
3568          $params = array(
3569              'competencyid' => $competencyid,
3570              'relatedcompetencyid' => $relatedcompetencyid
3571          );
3572          return new external_function_parameters($params);
3573      }
3574  
3575      /**
3576       * Removes a related competency.
3577       *
3578       * @param int $competencyid
3579       * @param int $relatedcompetencyid
3580       * @return bool
3581       */
3582      public static function remove_related_competency($competencyid, $relatedcompetencyid) {
3583          $params = self::validate_parameters(self::remove_related_competency_parameters(), array(
3584              'competencyid' => $competencyid,
3585              'relatedcompetencyid' => $relatedcompetencyid
3586          ));
3587          $competency = api::read_competency($params['competencyid']);
3588          self::validate_context($competency->get_context());
3589  
3590          return api::remove_related_competency($params['competencyid'], $params['relatedcompetencyid']);
3591      }
3592  
3593      /**
3594       * Returns description of remove_related_competency_returns() result value.
3595       *
3596       * @return external_description
3597       */
3598      public static function remove_related_competency_returns() {
3599          return new external_value(PARAM_BOOL, 'True if successful.');
3600      }
3601  
3602      /**
3603       * Returns description of update_ruleoutcome_course_competency() parameters.
3604       *
3605       * @return \external_function_parameters
3606       */
3607      public static function set_course_competency_ruleoutcome_parameters() {
3608          $coursecompetencyid = new external_value(
3609              PARAM_INT,
3610              'Data base record id for the course competency',
3611              VALUE_REQUIRED
3612          );
3613  
3614          $ruleoutcome = new external_value(
3615              PARAM_INT,
3616              'Ruleoutcome value',
3617              VALUE_REQUIRED
3618          );
3619  
3620          $params = array(
3621              'coursecompetencyid' => $coursecompetencyid,
3622              'ruleoutcome' => $ruleoutcome,
3623          );
3624          return new external_function_parameters($params);
3625      }
3626  
3627      /**
3628       * Change the ruleoutcome of a course competency.
3629       *
3630       * @param int $coursecompetencyid The course competency id
3631       * @param int $ruleoutcome The ruleoutcome value
3632       * @return bool
3633       */
3634      public static function set_course_competency_ruleoutcome($coursecompetencyid, $ruleoutcome) {
3635          $params = self::validate_parameters(self::set_course_competency_ruleoutcome_parameters(), array(
3636              'coursecompetencyid' => $coursecompetencyid,
3637              'ruleoutcome' => $ruleoutcome,
3638          ));
3639  
3640          $coursecompetency = new course_competency($params['coursecompetencyid']);
3641          self::validate_context(context_course::instance($coursecompetency->get_courseid()));
3642  
3643          return api::set_course_competency_ruleoutcome($coursecompetency, $params['ruleoutcome']);
3644      }
3645  
3646      /**
3647       * Returns description of update_ruleoutcome_course_competency() result value.
3648       *
3649       * @return \external_value
3650       */
3651      public static function set_course_competency_ruleoutcome_returns() {
3652          return new external_value(PARAM_BOOL, 'True if the update was successful');
3653      }
3654  
3655  
3656      /**
3657       * Returns description of external function parameters.
3658       *
3659       * @return \external_function_parameters
3660       */
3661      public static function grade_competency_parameters() {
3662          $userid = new external_value(
3663              PARAM_INT,
3664              'User ID',
3665              VALUE_REQUIRED
3666          );
3667          $competencyid = new external_value(
3668              PARAM_INT,
3669              'Competency ID',
3670              VALUE_REQUIRED
3671          );
3672          $grade = new external_value(
3673              PARAM_INT,
3674              'New grade',
3675              VALUE_REQUIRED
3676          );
3677          $note = new external_value(
3678              PARAM_NOTAGS,
3679              'A note to attach to the evidence',
3680              VALUE_DEFAULT
3681          );
3682  
3683          $params = array(
3684              'userid' => $userid,
3685              'competencyid' => $competencyid,
3686              'grade' => $grade,
3687              'note' => $note,
3688          );
3689          return new external_function_parameters($params);
3690      }
3691  
3692      /**
3693       * Grade a competency.
3694       *
3695       * @param int $userid The user ID.
3696       * @param int $competencyid The competency id
3697       * @param int $grade The new grade value
3698       * @param string $note A note to attach to the evidence
3699       * @return bool
3700       */
3701      public static function grade_competency($userid, $competencyid, $grade, $note = null) {
3702          global $USER, $PAGE;
3703          $params = self::validate_parameters(self::grade_competency_parameters(), array(
3704              'userid' => $userid,
3705              'competencyid' => $competencyid,
3706              'grade' => $grade,
3707              'note' => $note
3708          ));
3709  
3710          $uc = api::get_user_competency($params['userid'], $params['competencyid']);
3711          self::validate_context($uc->get_context());
3712  
3713          $output = $PAGE->get_renderer('core');
3714          $evidence = api::grade_competency(
3715                  $uc->get_userid(),
3716                  $uc->get_competencyid(),
3717                  $params['grade'],
3718                  $params['note']
3719          );
3720  
3721          $scale = $uc->get_competency()->get_scale();
3722          $exporter = new evidence_exporter($evidence, [
3723              'actionuser' => $USER,
3724              'scale' => $scale,
3725              'usercompetency' => $uc,
3726              'usercompetencyplan' => null,
3727          ]);
3728          return $exporter->export($output);
3729      }
3730  
3731      /**
3732       * Returns description of external function result value.
3733       *
3734       * @return \external_value
3735       */
3736      public static function grade_competency_returns() {
3737          return evidence_exporter::get_read_structure();
3738      }
3739  
3740      /**
3741       * Returns description of grade_competency_in_plan() parameters.
3742       *
3743       * @return \external_function_parameters
3744       */
3745      public static function grade_competency_in_plan_parameters() {
3746          $planid = new external_value(
3747              PARAM_INT,
3748              'Plan id',
3749              VALUE_REQUIRED
3750          );
3751          $competencyid = new external_value(
3752              PARAM_INT,
3753              'Competency id',
3754              VALUE_REQUIRED
3755          );
3756          $grade = new external_value(
3757              PARAM_INT,
3758              'New grade',
3759              VALUE_REQUIRED
3760          );
3761          $note = new external_value(
3762              PARAM_NOTAGS,
3763              'A note to attach to the evidence',
3764              VALUE_DEFAULT
3765          );
3766  
3767          $params = array(
3768              'planid' => $planid,
3769              'competencyid' => $competencyid,
3770              'grade' => $grade,
3771              'note' => $note
3772          );
3773          return new external_function_parameters($params);
3774      }
3775  
3776      /**
3777       * Grade a competency in a plan.
3778       *
3779       * @param int $planid The plan id
3780       * @param int $competencyid The competency id
3781       * @param int $grade The new grade value
3782       * @param string $note A note to add to the evidence
3783       * @return bool
3784       */
3785      public static function grade_competency_in_plan($planid, $competencyid, $grade, $note = null) {
3786          global $USER, $PAGE;
3787  
3788          $params = self::validate_parameters(self::grade_competency_in_plan_parameters(), array(
3789              'planid' => $planid,
3790              'competencyid' => $competencyid,
3791              'grade' => $grade,
3792              'note' => $note
3793          ));
3794  
3795          $plan = new plan($params['planid']);
3796          $context = $plan->get_context();
3797          self::validate_context($context);
3798          $output = $PAGE->get_renderer('core');
3799  
3800          $evidence = api::grade_competency_in_plan(
3801                  $plan->get_id(),
3802                  $params['competencyid'],
3803                  $params['grade'],
3804                  $params['note']
3805          );
3806          $competency = api::read_competency($params['competencyid']);
3807          $scale = $competency->get_scale();
3808          $exporter = new evidence_exporter($evidence, [
3809              'actionuser' => $USER,
3810              'scale' => $scale,
3811              'usercompetency' => null,
3812              'usercompetencyplan' => null,
3813          ]);
3814          return $exporter->export($output);
3815      }
3816  
3817      /**
3818       * Returns description of grade_competency_in_plan() result value.
3819       *
3820       * @return \external_value
3821       */
3822      public static function grade_competency_in_plan_returns() {
3823          return evidence_exporter::get_read_structure();
3824      }
3825  
3826      /**
3827       * Returns description of user_competency_viewed() parameters.
3828       *
3829       * @return \external_function_parameters
3830       */
3831      public static function user_competency_viewed_parameters() {
3832          $usercompetencyid = new external_value(
3833              PARAM_INT,
3834              'The user competency id',
3835              VALUE_REQUIRED
3836          );
3837          $params = array(
3838              'usercompetencyid' => $usercompetencyid
3839          );
3840          return new external_function_parameters($params);
3841      }
3842  
3843      /**
3844       * Log user competency viewed event.
3845       *
3846       * @param int $usercompetencyid The user competency ID.
3847       * @return boolean
3848       */
3849      public static function user_competency_viewed($usercompetencyid) {
3850          $params = self::validate_parameters(self::user_competency_viewed_parameters(), array(
3851              'usercompetencyid' => $usercompetencyid
3852          ));
3853  
3854          $uc = api::get_user_competency_by_id($params['usercompetencyid']);
3855          $result = api::user_competency_viewed($uc);
3856  
3857          return $result;
3858      }
3859  
3860      /**
3861       * Returns description of user_competency_viewed() result value.
3862       *
3863       * @return \external_description
3864       */
3865      public static function user_competency_viewed_returns() {
3866          return new external_value(PARAM_BOOL, 'True if the event user competency viewed was logged');
3867      }
3868  
3869      /**
3870       * Returns description of user_competency_viewed_in_plan() parameters.
3871       *
3872       * @return \external_function_parameters
3873       */
3874      public static function user_competency_viewed_in_plan_parameters() {
3875          $competencyid = new external_value(
3876              PARAM_INT,
3877              'The competency id',
3878              VALUE_REQUIRED
3879          );
3880          $userid = new external_value(
3881              PARAM_INT,
3882              'The user id',
3883              VALUE_REQUIRED
3884          );
3885          $planid = new external_value(
3886              PARAM_INT,
3887              'The plan id',
3888              VALUE_REQUIRED
3889          );
3890          $params = array(
3891              'competencyid' => $competencyid,
3892              'userid' => $userid,
3893              'planid' => $planid
3894          );
3895          return new external_function_parameters($params);
3896      }
3897  
3898      /**
3899       * Log user competency viewed in plan event.
3900       *
3901       * @param int $competencyid The competency ID.
3902       * @param int $userid The user ID.
3903       * @param int $planid The plan ID.
3904       * @return boolean
3905       */
3906      public static function user_competency_viewed_in_plan($competencyid, $userid, $planid) {
3907          $params = self::validate_parameters(self::user_competency_viewed_in_plan_parameters(), array(
3908              'competencyid' => $competencyid,
3909              'userid' => $userid,
3910              'planid' => $planid
3911          ));
3912          $pl = api::get_plan_competency($params['planid'], $params['competencyid']);
3913          $result = api::user_competency_viewed_in_plan($pl->usercompetency, $params['planid']);
3914  
3915          return $result;
3916      }
3917  
3918      /**
3919       * Returns description of user_competency_viewed_in_plan() result value.
3920       *
3921       * @return \external_description
3922       */
3923      public static function user_competency_viewed_in_plan_returns() {
3924          return new external_value(PARAM_BOOL, 'True if the event user competency viewed in plan was logged');
3925      }
3926  
3927      /**
3928       * Returns description of user_competency_viewed_in_course() parameters.
3929       *
3930       * @return \external_function_parameters
3931       */
3932      public static function user_competency_viewed_in_course_parameters() {
3933          $competencyid = new external_value(
3934              PARAM_INT,
3935              'The competency id',
3936              VALUE_REQUIRED
3937          );
3938          $userid = new external_value(
3939              PARAM_INT,
3940              'The user id',
3941              VALUE_REQUIRED
3942          );
3943          $courseid = new external_value(
3944              PARAM_INT,
3945              'The course id',
3946              VALUE_REQUIRED
3947          );
3948          $params = array(
3949              'competencyid' => $competencyid,
3950              'userid' => $userid,
3951              'courseid' => $courseid
3952          );
3953          return new external_function_parameters($params);
3954      }
3955  
3956      /**
3957       * Log user competency viewed in course event.
3958       *
3959       * @param int $competencyid The competency ID.
3960       * @param int $userid The user ID.
3961       * @param int $courseid The course ID.
3962       * @return boolean
3963       */
3964      public static function user_competency_viewed_in_course($competencyid, $userid, $courseid) {
3965          $params = self::validate_parameters(self::user_competency_viewed_in_course_parameters(), array(
3966              'competencyid' => $competencyid,
3967              'userid' => $userid,
3968              'courseid' => $courseid
3969          ));
3970          $ucc = api::get_user_competency_in_course($params['courseid'], $params['userid'], $params['competencyid']);
3971          $result = api::user_competency_viewed_in_course($ucc);
3972  
3973          return $result;
3974      }
3975  
3976      /**
3977       * Returns description of user_competency_viewed_in_course() result value.
3978       *
3979       * @return \external_description
3980       */
3981      public static function user_competency_viewed_in_course_returns() {
3982          return new external_value(PARAM_BOOL, 'True if the event user competency viewed in course was logged');
3983      }
3984  
3985      /**
3986       * Returns description of user_competency_plan_viewed() parameters.
3987       *
3988       * @return \external_function_parameters
3989       */
3990      public static function user_competency_plan_viewed_parameters() {
3991          $competencyid = new external_value(
3992              PARAM_INT,
3993              'The competency id',
3994              VALUE_REQUIRED
3995          );
3996          $userid = new external_value(
3997              PARAM_INT,
3998              'The user id',
3999              VALUE_REQUIRED
4000          );
4001          $planid = new external_value(
4002              PARAM_INT,
4003              'The plan id',
4004              VALUE_REQUIRED
4005          );
4006          $params = array(
4007              'competencyid' => $competencyid,
4008              'userid' => $userid,
4009              'planid' => $planid
4010          );
4011          return new external_function_parameters($params);
4012      }
4013  
4014      /**
4015       * Log user competency plan viewed event.
4016       *
4017       * @param int $competencyid The competency ID.
4018       * @param int $userid The user ID.
4019       * @param int $planid The plan ID.
4020       * @return boolean
4021       */
4022      public static function user_competency_plan_viewed($competencyid, $userid, $planid) {
4023          $params = self::validate_parameters(self::user_competency_viewed_in_plan_parameters(), array(
4024              'competencyid' => $competencyid,
4025              'userid' => $userid,
4026              'planid' => $planid
4027          ));
4028          $pl = api::get_plan_competency($params['planid'], $params['competencyid']);
4029          $result = api::user_competency_plan_viewed($pl->usercompetencyplan);
4030  
4031          return $result;
4032      }
4033  
4034      /**
4035       * Returns description of user_competency_plan_viewed() result value.
4036       *
4037       * @return \external_description
4038       */
4039      public static function user_competency_plan_viewed_returns() {
4040          return new external_value(PARAM_BOOL, 'True if the event user competency plan viewed was logged');
4041      }
4042  
4043      /**
4044       * Returns description of grade_competency_in_course() parameters.
4045       *
4046       * @return \external_function_parameters
4047       */
4048      public static function grade_competency_in_course_parameters() {
4049          $courseid = new external_value(
4050              PARAM_INT,
4051              'Course id',
4052              VALUE_REQUIRED
4053          );
4054          $userid = new external_value(
4055              PARAM_INT,
4056              'User id',
4057              VALUE_REQUIRED
4058          );
4059          $competencyid = new external_value(
4060              PARAM_INT,
4061              'Competency id',
4062              VALUE_REQUIRED
4063          );
4064          $grade = new external_value(
4065              PARAM_INT,
4066              'New grade',
4067              VALUE_REQUIRED
4068          );
4069          $note = new external_value(
4070              PARAM_NOTAGS,
4071              'A note to attach to the evidence',
4072              VALUE_DEFAULT
4073          );
4074  
4075          $params = array(
4076              'courseid' => $courseid,
4077              'userid' => $userid,
4078              'competencyid' => $competencyid,
4079              'grade' => $grade,
4080              'note' => $note,
4081          );
4082          return new external_function_parameters($params);
4083      }
4084  
4085      /**
4086       * Grade a competency in a course.
4087       *
4088       * @param int $courseid The course id
4089       * @param int $userid The user id
4090       * @param int $competencyid The competency id
4091       * @param int $grade The new grade value
4092       * @param string $note A note to add to the evidence
4093       * @return bool
4094       */
4095      public static function grade_competency_in_course($courseid, $userid, $competencyid, $grade, $note = null) {
4096          global $USER, $PAGE, $DB;
4097  
4098          $params = self::validate_parameters(self::grade_competency_in_course_parameters(), array(
4099              'courseid' => $courseid,
4100              'userid' => $userid,
4101              'competencyid' => $competencyid,
4102              'grade' => $grade,
4103              'note' => $note
4104          ));
4105  
4106          $course = $DB->get_record('course', array('id' => $params['courseid']));
4107          $context = context_course::instance($course->id);
4108          self::validate_context($context);
4109          $output = $PAGE->get_renderer('core');
4110  
4111          $evidence = api::grade_competency_in_course(
4112                  $params['courseid'],
4113                  $params['userid'],
4114                  $params['competencyid'],
4115                  $params['grade'],
4116                  $params['note']
4117          );
4118          $competency = api::read_competency($params['competencyid']);
4119          $scale = $competency->get_scale();
4120          $exporter = new evidence_exporter($evidence, array(
4121              'actionuser' => $USER,
4122              'scale' => $scale,
4123              'usercompetency' => null,
4124              'usercompetencyplan' => null,
4125          ));
4126          return $exporter->export($output);
4127      }
4128  
4129      /**
4130       * Returns description of grade_competency_in_course() result value.
4131       *
4132       * @return \external_value
4133       */
4134      public static function grade_competency_in_course_returns() {
4135          return evidence_exporter::get_read_structure();
4136      }
4137  
4138      /**
4139       * Returns description of unlink_plan_from_template_() parameters.
4140       *
4141       * @return \external_function_parameters
4142       */
4143      public static function unlink_plan_from_template_parameters() {
4144          $planid = new external_value(
4145              PARAM_INT,
4146              'Data base record id for the plan',
4147              VALUE_REQUIRED
4148          );
4149  
4150          $params = array(
4151              'planid' => $planid,
4152          );
4153          return new external_function_parameters($params);
4154      }
4155  
4156      /**
4157       * Unlink the plan from the template.
4158       *
4159       * @param int $planid The plan id
4160       * @return bool
4161       */
4162      public static function unlink_plan_from_template($planid) {
4163          $params = self::validate_parameters(self::unlink_plan_from_template_parameters(), array(
4164              'planid' => $planid,
4165          ));
4166  
4167          $plan = new plan($params['planid']);
4168          self::validate_context($plan->get_context());
4169  
4170          return api::unlink_plan_from_template($plan);
4171      }
4172  
4173      /**
4174       * Returns description of unlink_plan_from_template_() result value.
4175       *
4176       * @return \external_value
4177       */
4178      public static function unlink_plan_from_template_returns() {
4179          return new external_value(PARAM_BOOL, 'True if the unlink was successful');
4180      }
4181  
4182      /**
4183       * Returns description of template_viewed() parameters.
4184       *
4185       * @return \external_function_parameters
4186       */
4187      public static function template_viewed_parameters() {
4188          $id = new external_value(
4189              PARAM_INT,
4190              'Data base record id for the template',
4191              VALUE_REQUIRED
4192          );
4193  
4194          $params = array(
4195              'id' => $id,
4196          );
4197          return new external_function_parameters($params);
4198      }
4199  
4200      /**
4201       * Log the template viewed event.
4202       *
4203       * @param int $id the template id
4204       * @return array of warnings and status result
4205       * @throws moodle_exception
4206       */
4207      public static function template_viewed($id) {
4208          $params = self::validate_parameters(self::view_book_parameters(), array(
4209              'id' => $id
4210          ));
4211  
4212          $template = api::read_template($params['id']);
4213          self::validate_context($template->get_context());
4214  
4215          return api::template_viewed($params['id']);
4216      }
4217  
4218      /**
4219       * Returns description of template_viewed() result value.
4220       *
4221       * @return \external_value
4222       */
4223      public static function template_viewed_returns() {
4224          return new external_value(PARAM_BOOL, 'True if the log of the view was successful');
4225      }
4226  
4227      /**
4228       * Returns description of update_course_competency_settings() parameters.
4229       *
4230       * @return \external_function_parameters
4231       */
4232      public static function update_course_competency_settings_parameters() {
4233          $courseid = new external_value(
4234              PARAM_INT,
4235              'Course id for the course to update',
4236              VALUE_REQUIRED
4237          );
4238          $pushratingstouserplans = new external_value(
4239              PARAM_BOOL,
4240              'New value of the setting',
4241              VALUE_REQUIRED
4242          );
4243          $settings = new external_single_structure(array(
4244              'pushratingstouserplans' => $pushratingstouserplans
4245          ));
4246          $params = array(
4247              'courseid' => $courseid,
4248              'settings' => $settings,
4249          );
4250          return new external_function_parameters($params);
4251      }
4252  
4253      /**
4254       * Update the course competency settings
4255       *
4256       * @param int $courseid the course id
4257       * @param stdClass $settings The list of settings (currently only pushratingstouserplans).
4258       * @throws moodle_exception
4259       */
4260      public static function update_course_competency_settings($courseid, $settings) {
4261          $params = self::validate_parameters(self::update_course_competency_settings_parameters(), array(
4262              'courseid' => $courseid,
4263              'settings' => $settings
4264          ));
4265  
4266          $context = context_course::instance($params['courseid']);
4267          self::validate_context($context);
4268          $result = api::update_course_competency_settings($params['courseid'], $params['settings']);
4269  
4270          return $result;
4271      }
4272  
4273      /**
4274       * Returns description of update_course_competency_settings() result value.
4275       *
4276       * @return \external_value
4277       */
4278      public static function update_course_competency_settings_returns() {
4279          return new external_value(PARAM_BOOL, 'True if the update was successful.');
4280      }
4281  
4282      /**
4283       * Returns description of external function parameters.
4284       *
4285       * @return \external_function_parameters
4286       */
4287      public static function delete_evidence_parameters() {
4288          return new external_function_parameters(array(
4289              'id' => new external_value(PARAM_INT, 'The evidence ID'),
4290          ));
4291      }
4292  
4293      /**
4294       * External function delete_evidence.
4295       *
4296       * @param int $id The evidence ID.
4297       * @return boolean
4298       */
4299      public static function delete_evidence($id) {
4300          $params = self::validate_parameters(self::delete_evidence_parameters(), array(
4301              'id' => $id
4302          ));
4303  
4304          $evidence = api::read_evidence($params['id']);
4305          $uc = api::get_user_competency_by_id($evidence->get_usercompetencyid());
4306          self::validate_context($uc->get_context());
4307  
4308          return api::delete_evidence($evidence);
4309      }
4310  
4311      /**
4312       * Returns description of external function result value.
4313       *
4314       * @return \external_function_parameters
4315       */
4316      public static function delete_evidence_returns() {
4317          return new external_value(PARAM_BOOL, 'The success');
4318      }
4319  
4320  }