mod/lti/locallib.php

   1 <?php
   2 // This file is part of Moodle - http://moodle.org/
   3 //
   4 // Moodle is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, either version 3 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // Moodle is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16 //
  17 // This file is part of BasicLTI4Moodle
  18 //
  19 // BasicLTI4Moodle is an IMS BasicLTI (Basic Learning Tools for Interoperability)
  20 // consumer for Moodle 1.9 and Moodle 2.0. BasicLTI is a IMS Standard that allows web
  21 // based learning tools to be easily integrated in LMS as native ones. The IMS BasicLTI
  22 // specification is part of the IMS standard Common Cartridge 1.1 Sakai and other main LMS
  23 // are already supporting or going to support BasicLTI. This project Implements the consumer
  24 // for Moodle. Moodle is a Free Open source Learning Management System by Martin Dougiamas.
  25 // BasicLTI4Moodle is a project iniciated and leaded by Ludo(Marc Alier) and Jordi Piguillem
  26 // at the GESSI research group at UPC.
  27 // SimpleLTI consumer for Moodle is an implementation of the early specification of LTI
  28 // by Charles Severance (Dr Chuck) htp://dr-chuck.com , developed by Jordi Piguillem in a
  29 // Google Summer of Code 2008 project co-mentored by Charles Severance and Marc Alier.
  30 //
  31 // BasicLTI4Moodle is copyright 2009 by Marc Alier Forment, Jordi Piguillem and Nikolas Galanis
  32 // of the Universitat Politecnica de Catalunya http://www.upc.edu
  33 // Contact info: Marc Alier Forment granludo @ gmail.com or marc.alier @ upc.edu.
  34
  35 /**
  36  * This file contains the library of functions and constants for the lti module
  37  *
  38  * @package mod_lti
  39  * @copyright  2009 Marc Alier, Jordi Piguillem, Nikolas Galanis
  40  *  marc.alier@upc.edu
  41  * @copyright  2009 Universitat Politecnica de Catalunya http://www.upc.edu
  42  * @author     Marc Alier
  43  * @author     Jordi Piguillem
  44  * @author     Nikolas Galanis
  45  * @author     Chris Scribner
  46  * @copyright  2015 Vital Source Technologies http://vitalsource.com
  47  * @author     Stephen Vickers
  48  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  49  */
  50
  51 defined('MOODLE_INTERNAL') || die;
  52
  53 // TODO: Switch to core oauthlib once implemented - MDL-30149.
  54 use moodle\mod\lti as lti;
  55
  56 require_once($CFG->dirroot.'/mod/lti/OAuth.php');
  57 require_once($CFG->libdir.'/weblib.php');
  58 require_once($CFG->dirroot . '/course/modlib.php');
  59 require_once($CFG->dirroot . '/mod/lti/TrivialStore.php');
  60
  61 define('LTI_URL_DOMAIN_REGEX', '/(?:https?:\/\/)?(?:www\.)?([^\/]+)(?:\/|$)/i');
  62
  63 define('LTI_LAUNCH_CONTAINER_DEFAULT', 1);
  64 define('LTI_LAUNCH_CONTAINER_EMBED', 2);
  65 define('LTI_LAUNCH_CONTAINER_EMBED_NO_BLOCKS', 3);
  66 define('LTI_LAUNCH_CONTAINER_WINDOW', 4);
  67 define('LTI_LAUNCH_CONTAINER_REPLACE_MOODLE_WINDOW', 5);
  68
  69 define('LTI_TOOL_STATE_ANY', 0);
  70 define('LTI_TOOL_STATE_CONFIGURED', 1);
  71 define('LTI_TOOL_STATE_PENDING', 2);
  72 define('LTI_TOOL_STATE_REJECTED', 3);
  73 define('LTI_TOOL_PROXY_TAB', 4);
  74
  75 define('LTI_TOOL_PROXY_STATE_CONFIGURED', 1);
  76 define('LTI_TOOL_PROXY_STATE_PENDING', 2);
  77 define('LTI_TOOL_PROXY_STATE_ACCEPTED', 3);
  78 define('LTI_TOOL_PROXY_STATE_REJECTED', 4);
  79
  80 define('LTI_SETTING_NEVER', 0);
  81 define('LTI_SETTING_ALWAYS', 1);
  82 define('LTI_SETTING_DELEGATE', 2);
  83
  84 define('LTI_COURSEVISIBLE_NO', 0);
  85 define('LTI_COURSEVISIBLE_PRECONFIGURED', 1);
  86 define('LTI_COURSEVISIBLE_ACTIVITYCHOOSER', 2);
  87
  88 define('LTI_VERSION_1', 'LTI-1p0');
  89 define('LTI_VERSION_2', 'LTI-2p0');
  90
  91 /**
  92  * Return the launch data required for opening the external tool.
  93  *
  94  * @param  stdClass $instance the external tool activity settings
  95  * @return array the endpoint URL and parameters (including the signature)
  96  * @since  Moodle 3.0
  97  */
  98 function lti_get_launch_data($instance) {
  99     global $PAGE, $CFG;
 100
 101     if (empty($instance->typeid)) {
 102         $tool = lti_get_tool_by_url_match($instance->toolurl, $instance->course);
 103         if ($tool) {
 104             $typeid = $tool->id;
 105         } else {
 106             $typeid = null;
 107         }
 108     } else {
 109         $typeid = $instance->typeid;
 110         $tool = lti_get_type($typeid);
 111     }
 112
 113     if ($typeid) {
 114         $typeconfig = lti_get_type_config($typeid);
 115     } else {
 116         // There is no admin configuration for this tool. Use configuration in the lti instance record plus some defaults.
 117         $typeconfig = (array)$instance;
 118
 119         $typeconfig['sendname'] = $instance->instructorchoicesendname;
 120         $typeconfig['sendemailaddr'] = $instance->instructorchoicesendemailaddr;
 121         $typeconfig['customparameters'] = $instance->instructorcustomparameters;
 122         $typeconfig['acceptgrades'] = $instance->instructorchoiceacceptgrades;
 123         $typeconfig['allowroster'] = $instance->instructorchoiceallowroster;
 124         $typeconfig['forcessl'] = '0';
 125     }
 126
 127     // Default the organizationid if not specified.
 128     if (empty($typeconfig['organizationid'])) {
 129         $urlparts = parse_url($CFG->wwwroot);
 130
 131         $typeconfig['organizationid'] = $urlparts['host'];
 132     }
 133
 134     if (isset($tool->toolproxyid)) {
 135         $toolproxy = lti_get_tool_proxy($tool->toolproxyid);
 136         $key = $toolproxy->guid;
 137         $secret = $toolproxy->secret;
 138     } else {
 139         $toolproxy = null;
 140         if (!empty($instance->resourcekey)) {
 141             $key = $instance->resourcekey;
 142         } else if (!empty($typeconfig['resourcekey'])) {
 143             $key = $typeconfig['resourcekey'];
 144         } else {
 145             $key = '';
 146         }
 147         if (!empty($instance->password)) {
 148             $secret = $instance->password;
 149         } else if (!empty($typeconfig['password'])) {
 150             $secret = $typeconfig['password'];
 151         } else {
 152             $secret = '';
 153         }
 154     }
 155
 156     $endpoint = !empty($instance->toolurl) ? $instance->toolurl : $typeconfig['toolurl'];
 157     $endpoint = trim($endpoint);
 158
 159     // If the current request is using SSL and a secure tool URL is specified, use it.
 160     if (lti_request_is_using_ssl() && !empty($instance->securetoolurl)) {
 161         $endpoint = trim($instance->securetoolurl);
 162     }
 163
 164     // If SSL is forced, use the secure tool url if specified. Otherwise, make sure https is on the normal launch URL.
 165     if (isset($typeconfig['forcessl']) && ($typeconfig['forcessl'] == '1')) {
 166         if (!empty($instance->securetoolurl)) {
 167             $endpoint = trim($instance->securetoolurl);
 168         }
 169
 170         $endpoint = lti_ensure_url_is_https($endpoint);
 171     } else {
 172         if (!strstr($endpoint, '://')) {
 173             $endpoint = 'http://' . $endpoint;
 174         }
 175     }
 176
 177     $orgid = $typeconfig['organizationid'];
 178
 179     $course = $PAGE->course;
 180     $islti2 = isset($tool->toolproxyid);
 181     $allparams = lti_build_request($instance, $typeconfig, $course, $typeid, $islti2);
 182     if ($islti2) {
 183         $requestparams = lti_build_request_lti2($tool, $allparams);
 184     } else {
 185         $requestparams = $allparams;
 186     }
 187     $requestparams = array_merge($requestparams, lti_build_standard_request($instance, $orgid, $islti2));
 188     $customstr = '';
 189     if (isset($typeconfig['customparameters'])) {
 190         $customstr = $typeconfig['customparameters'];
 191     }
 192     $requestparams = array_merge($requestparams, lti_build_custom_parameters($toolproxy, $tool, $instance, $allparams, $customstr,
 193         $instance->instructorcustomparameters, $islti2));
 194
 195     $launchcontainer = lti_get_launch_container($instance, $typeconfig);
 196     $returnurlparams = array('course' => $course->id,
 197                              'launch_container' => $launchcontainer,
 198                              'instanceid' => $instance->id,
 199                              'sesskey' => sesskey());
 200
 201     // Add the return URL. We send the launch container along to help us avoid frames-within-frames when the user returns.
 202     $url = new \moodle_url('/mod/lti/return.php', $returnurlparams);
 203     $returnurl = $url->out(false);
 204
 205     if (isset($typeconfig['forcessl']) && ($typeconfig['forcessl'] == '1')) {
 206         $returnurl = lti_ensure_url_is_https($returnurl);
 207     }
 208
 209     $target = '';
 210     switch($launchcontainer) {
 211         case LTI_LAUNCH_CONTAINER_EMBED:
 212         case LTI_LAUNCH_CONTAINER_EMBED_NO_BLOCKS:
 213             $target = 'iframe';
 214             break;
 215         case LTI_LAUNCH_CONTAINER_REPLACE_MOODLE_WINDOW:
 216             $target = 'frame';
 217             break;
 218         case LTI_LAUNCH_CONTAINER_WINDOW:
 219             $target = 'window';
 220             break;
 221     }
 222     if (!empty($target)) {
 223         $requestparams['launch_presentation_document_target'] = $target;
 224     }
 225
 226     $requestparams['launch_presentation_return_url'] = $returnurl;
 227
 228     // Allow request params to be updated by sub-plugins.
 229     $plugins = core_component::get_plugin_list('ltisource');
 230     foreach (array_keys($plugins) as $plugin) {
 231         $pluginparams = component_callback('ltisource_'.$plugin, 'before_launch',
 232             array($instance, $endpoint, $requestparams), array());
 233
 234         if (!empty($pluginparams) && is_array($pluginparams)) {
 235             $requestparams = array_merge($requestparams, $pluginparams);
 236         }
 237     }
 238
 239     if (!empty($key) && !empty($secret)) {
 240         $parms = lti_sign_parameters($requestparams, $endpoint, "POST", $key, $secret);
 241
 242         $endpointurl = new \moodle_url($endpoint);
 243         $endpointparams = $endpointurl->params();
 244
 245         // Strip querystring params in endpoint url from $parms to avoid duplication.
 246         if (!empty($endpointparams) && !empty($parms)) {
 247             foreach (array_keys($endpointparams) as $paramname) {
 248                 if (isset($parms[$paramname])) {
 249                     unset($parms[$paramname]);
 250                 }
 251             }
 252         }
 253
 254     } else {
 255         // If no key and secret, do the launch unsigned.
 256         $returnurlparams['unsigned'] = '1';
 257         $parms = $requestparams;
 258     }
 259
 260     return array($endpoint, $parms);
 261 }
 262
 263 /**
 264  * Launch an external tool activity.
 265  *
 266  * @param  stdClass $instance the external tool activity settings
 267  * @return string The HTML code containing the javascript code for the launch
 268  */
 269 function lti_launch_tool($instance) {
 270
 271     list($endpoint, $parms) = lti_get_launch_data($instance);
 272     $debuglaunch = ( $instance->debuglaunch == 1 );
 273
 274     $content = lti_post_launch_html($parms, $endpoint, $debuglaunch);
 275
 276     echo $content;
 277 }
 278
 279 /**
 280  * Prepares an LTI registration request message
 281  *
 282  * $param object $instance       Tool Proxy instance object
 283  */
 284 function lti_register($toolproxy) {
 285     $endpoint = $toolproxy->regurl;
 286
 287     // Change the status to pending.
 288     $toolproxy->state = LTI_TOOL_PROXY_STATE_PENDING;
 289     lti_update_tool_proxy($toolproxy);
 290
 291     $requestparams = lti_build_registration_request($toolproxy);
 292
 293     $content = lti_post_launch_html($requestparams, $endpoint, false);
 294
 295     echo $content;
 296 }
 297
 298
 299 /**
 300  * Gets the parameters for the regirstration request
 301  *
 302  * @param object $toolproxy Tool Proxy instance object
 303  * @return array Registration request parameters
 304  */
 305 function lti_build_registration_request($toolproxy) {
 306     $key = $toolproxy->guid;
 307     $secret = $toolproxy->secret;
 308
 309     $requestparams = array();
 310     $requestparams['lti_message_type'] = 'ToolProxyRegistrationRequest';
 311     $requestparams['lti_version'] = 'LTI-2p0';
 312     $requestparams['reg_key'] = $key;
 313     $requestparams['reg_password'] = $secret;
 314     $requestparams['reg_url'] = $toolproxy->regurl;
 315
 316     // Add the profile URL.
 317     $profileservice = lti_get_service_by_name('profile');
 318     $profileservice->set_tool_proxy($toolproxy);
 319     $requestparams['tc_profile_url'] = $profileservice->parse_value('$ToolConsumerProfile.url');
 320
 321     // Add the return URL.
 322     $returnurlparams = array('id' => $toolproxy->id, 'sesskey' => sesskey());
 323     $url = new \moodle_url('/mod/lti/externalregistrationreturn.php', $returnurlparams);
 324     $returnurl = $url->out(false);
 325
 326     $requestparams['launch_presentation_return_url'] = $returnurl;
 327
 328     return $requestparams;
 329 }
 330
 331 /**
 332  * Build source ID
 333  *
 334  * @param int $instanceid
 335  * @param int $userid
 336  * @param string $servicesalt
 337  * @param null|int $typeid
 338  * @param null|int $launchid
 339  * @return stdClass
 340  */
 341 function lti_build_sourcedid($instanceid, $userid, $servicesalt, $typeid = null, $launchid = null) {
 342     $data = new \stdClass();
 343
 344     $data->instanceid = $instanceid;
 345     $data->userid = $userid;
 346     $data->typeid = $typeid;
 347     if (!empty($launchid)) {
 348         $data->launchid = $launchid;
 349     } else {
 350         $data->launchid = mt_rand();
 351     }
 352
 353     $json = json_encode($data);
 354
 355     $hash = hash('sha256', $json . $servicesalt, false);
 356
 357     $container = new \stdClass();
 358     $container->data = $data;
 359     $container->hash = $hash;
 360
 361     return $container;
 362 }
 363
 364 /**
 365  * This function builds the request that must be sent to the tool producer
 366  *
 367  * @param object    $instance       Basic LTI instance object
 368  * @param array     $typeconfig     Basic LTI tool configuration
 369  * @param object    $course         Course object
 370  * @param int|null  $typeid         Basic LTI tool ID
 371  * @param boolean   $islti2         True if an LTI 2 tool is being launched
 372  *
 373  * @return array                    Request details
 374  */
 375 function lti_build_request($instance, $typeconfig, $course, $typeid = null, $islti2 = false) {
 376     global $USER, $CFG;
 377
 378     if (empty($instance->cmid)) {
 379         $instance->cmid = 0;
 380     }
 381
 382     $role = lti_get_ims_role($USER, $instance->cmid, $instance->course, $islti2);
 383
 384     $requestparams = array(
 385         'user_id' => $USER->id,
 386         'lis_person_sourcedid' => $USER->idnumber,
 387         'roles' => $role,
 388         'context_id' => $course->id,
 389         'context_label' => trim(html_to_text($course->shortname, 0)),
 390         'context_title' => trim(html_to_text($course->fullname, 0)),
 391     );
 392     if (!empty($instance->name)) {
 393         $requestparams['resource_link_title'] = trim(html_to_text($instance->name, 0));
 394     }
 395     if (!empty($instance->cmid)) {
 396         $intro = format_module_intro('lti', $instance, $instance->cmid);
 397         $intro = trim(html_to_text($intro, 0, false));
 398
 399         // This may look weird, but this is required for new lines
 400         // so we generate the same OAuth signature as the tool provider.
 401         $intro = str_replace("\n", "\r\n", $intro);
 402         $requestparams['resource_link_description'] = $intro;
 403     }
 404     if (!empty($instance->id)) {
 405         $requestparams['resource_link_id'] = $instance->id;
 406     }
 407     if (!empty($instance->resource_link_id)) {
 408         $requestparams['resource_link_id'] = $instance->resource_link_id;
 409     }
 410     if ($course->format == 'site') {
 411         $requestparams['context_type'] = 'Group';
 412     } else {
 413         $requestparams['context_type'] = 'CourseSection';
 414         $requestparams['lis_course_section_sourcedid'] = $course->idnumber;
 415     }
 416
 417     if (!empty($instance->id) && !empty($instance->servicesalt) && ($islti2 ||
 418             $typeconfig['acceptgrades'] == LTI_SETTING_ALWAYS ||
 419             ($typeconfig['acceptgrades'] == LTI_SETTING_DELEGATE && $instance->instructorchoiceacceptgrades == LTI_SETTING_ALWAYS))
 420     ) {
 421         $placementsecret = $instance->servicesalt;
 422         $sourcedid = json_encode(lti_build_sourcedid($instance->id, $USER->id, $placementsecret, $typeid));
 423         $requestparams['lis_result_sourcedid'] = $sourcedid;
 424
 425         // Add outcome service URL.
 426         $serviceurl = new \moodle_url('/mod/lti/service.php');
 427         $serviceurl = $serviceurl->out();
 428
 429         $forcessl = false;
 430         if (!empty($CFG->mod_lti_forcessl)) {
 431             $forcessl = true;
 432         }
 433
 434         if ((isset($typeconfig['forcessl']) && ($typeconfig['forcessl'] == '1')) or $forcessl) {
 435             $serviceurl = lti_ensure_url_is_https($serviceurl);
 436         }
 437
 438         $requestparams['lis_outcome_service_url'] = $serviceurl;
 439     }
 440
 441     // Send user's name and email data if appropriate.
 442     if ($islti2 || $typeconfig['sendname'] == LTI_SETTING_ALWAYS ||
 443         ($typeconfig['sendname'] == LTI_SETTING_DELEGATE && isset($instance->instructorchoicesendname)
 444             && $instance->instructorchoicesendname == LTI_SETTING_ALWAYS)
 445     ) {
 446         $requestparams['lis_person_name_given'] = $USER->firstname;
 447         $requestparams['lis_person_name_family'] = $USER->lastname;
 448         $requestparams['lis_person_name_full'] = $USER->firstname . ' ' . $USER->lastname;
 449         $requestparams['ext_user_username'] = $USER->username;
 450     }
 451
 452     if ($islti2 || $typeconfig['sendemailaddr'] == LTI_SETTING_ALWAYS ||
 453         ($typeconfig['sendemailaddr'] == LTI_SETTING_DELEGATE && isset($instance->instructorchoicesendemailaddr)
 454             && $instance->instructorchoicesendemailaddr == LTI_SETTING_ALWAYS)
 455     ) {
 456         $requestparams['lis_person_contact_email_primary'] = $USER->email;
 457     }
 458
 459     return $requestparams;
 460 }
 461
 462 /**
 463  * This function builds the request that must be sent to an LTI 2 tool provider
 464  *
 465  * @param object    $tool           Basic LTI tool object
 466  * @param array     $params         Custom launch parameters
 467  *
 468  * @return array                    Request details
 469  */
 470 function lti_build_request_lti2($tool, $params) {
 471
 472     $requestparams = array();
 473
 474     $capabilities = lti_get_capabilities();
 475     $enabledcapabilities = explode("\n", $tool->enabledcapability);
 476     foreach ($enabledcapabilities as $capability) {
 477         if (array_key_exists($capability, $capabilities)) {
 478             $val = $capabilities[$capability];
 479             if ($val && (substr($val, 0, 1) != '$')) {
 480                 if (isset($params[$val])) {
 481                     $requestparams[$capabilities[$capability]] = $params[$capabilities[$capability]];
 482                 }
 483             }
 484         }
 485     }
 486
 487     return $requestparams;
 488
 489 }
 490
 491 /**
 492  * This function builds the standard parameters for an LTI 1 or 2 request that must be sent to the tool producer
 493  *
 494  * @param stdClass  $instance       Basic LTI instance object
 495  * @param string    $orgid          Organisation ID
 496  * @param boolean   $islti2         True if an LTI 2 tool is being launched
 497  * @param string    $messagetype    The request message type. Defaults to basic-lti-launch-request if empty.
 498  *
 499  * @return array                    Request details
 500  */
 501 function lti_build_standard_request($instance, $orgid, $islti2, $messagetype = 'basic-lti-launch-request') {
 502     global $CFG;
 503
 504     $requestparams = array();
 505
 506     if ($instance) {
 507         $requestparams['resource_link_id'] = $instance->id;
 508         if (property_exists($instance, 'resource_link_id') and !empty($instance->resource_link_id)) {
 509             $requestparams['resource_link_id'] = $instance->resource_link_id;
 510         }
 511     }
 512
 513     $requestparams['launch_presentation_locale'] = current_language();
 514
 515     // Make sure we let the tool know what LMS they are being called from.
 516     $requestparams['ext_lms'] = 'moodle-2';
 517     $requestparams['tool_consumer_info_product_family_code'] = 'moodle';
 518     $requestparams['tool_consumer_info_version'] = strval($CFG->version);
 519
 520     // Add oauth_callback to be compliant with the 1.0A spec.
 521     $requestparams['oauth_callback'] = 'about:blank';
 522
 523     if (!$islti2) {
 524         $requestparams['lti_version'] = 'LTI-1p0';
 525     } else {
 526         $requestparams['lti_version'] = 'LTI-2p0';
 527     }
 528     $requestparams['lti_message_type'] = $messagetype;
 529
 530     if ($orgid) {
 531         $requestparams["tool_consumer_instance_guid"] = $orgid;
 532     }
 533     if (!empty($CFG->mod_lti_institution_name)) {
 534         $requestparams['tool_consumer_instance_name'] = trim(html_to_text($CFG->mod_lti_institution_name, 0));
 535     } else {
 536         $requestparams['tool_consumer_instance_name'] = get_site()->shortname;
 537     }
 538     $requestparams['tool_consumer_instance_description'] = trim(html_to_text(get_site()->fullname, 0));
 539
 540     return $requestparams;
 541 }
 542
 543 /**
 544  * This function builds the custom parameters
 545  *
 546  * @param object    $toolproxy      Tool proxy instance object
 547  * @param object    $tool           Tool instance object
 548  * @param object    $instance       Tool placement instance object
 549  * @param array     $params         LTI launch parameters
 550  * @param string    $customstr      Custom parameters defined for tool
 551  * @param string    $instructorcustomstr      Custom parameters defined for this placement
 552  * @param boolean   $islti2         True if an LTI 2 tool is being launched
 553  *
 554  * @return array                    Custom parameters
 555  */
 556 function lti_build_custom_parameters($toolproxy, $tool, $instance, $params, $customstr, $instructorcustomstr, $islti2) {
 557
 558     // Concatenate the custom parameters from the administrator and the instructor
 559     // Instructor parameters are only taken into consideration if the administrator
 560     // has given permission.
 561     $custom = array();
 562     if ($customstr) {
 563         $custom = lti_split_custom_parameters($toolproxy, $tool, $params, $customstr, $islti2);
 564     }
 565     if (!isset($typeconfig['allowinstructorcustom']) || $typeconfig['allowinstructorcustom'] != LTI_SETTING_NEVER) {
 566         if ($instructorcustomstr) {
 567             $custom = array_merge(lti_split_custom_parameters($toolproxy, $tool, $params,
 568                 $instructorcustomstr, $islti2), $custom);
 569         }
 570     }
 571     if ($islti2) {
 572         $custom = array_merge(lti_split_custom_parameters($toolproxy, $tool, $params,
 573             $tool->parameter, true), $custom);
 574         $settings = lti_get_tool_settings($tool->toolproxyid);
 575         $custom = array_merge($custom, lti_get_custom_parameters($toolproxy, $tool, $params, $settings));
 576         if (!empty($instance->course)) {
 577             $settings = lti_get_tool_settings($tool->toolproxyid, $instance->course);
 578             $custom = array_merge($custom, lti_get_custom_parameters($toolproxy, $tool, $params, $settings));
 579             if (!empty($instance->id)) {
 580                 $settings = lti_get_tool_settings($tool->toolproxyid, $instance->course, $instance->id);
 581                 $custom = array_merge($custom, lti_get_custom_parameters($toolproxy, $tool, $params, $settings));
 582             }
 583         }
 584     }
 585
 586     return $custom;
 587 }
 588
 589 /**
 590  * Builds a standard LTI Content-Item selection request.
 591  *
 592  * @param int $id The tool type ID.
 593  * @param stdClass $course The course object.
 594  * @param moodle_url $returnurl The return URL in the tool consumer (TC) that the tool provider (TP)
 595  *                              will use to return the Content-Item message.
 596  * @param string $title The tool's title, if available.
 597  * @param string $text The text to display to represent the content item. This value may be a long description of the content item.
 598  * @param array $mediatypes Array of MIME types types supported by the TC. If empty, the TC will support ltilink by default.
 599  * @param array $presentationtargets Array of ways in which the selected content item(s) can be requested to be opened
 600  *                                   (via the presentationDocumentTarget element for a returned content item).
 601  *                                   If empty, "frame", "iframe", and "window" will be supported by default.
 602  * @param bool $autocreate Indicates whether any content items returned by the TP would be automatically persisted without
 603  * @param bool $multiple Indicates whether the user should be permitted to select more than one item. False by default.
 604  *                         any option for the user to cancel the operation. False by default.
 605  * @param bool $unsigned Indicates whether the TC is willing to accept an unsigned return message, or not.
 606  *                       A signed message should always be required when the content item is being created automatically in the
 607  *                       TC without further interaction from the user. False by default.
 608  * @param bool $canconfirm Flag for can_confirm parameter. False by default.
 609  * @param bool $copyadvice Indicates whether the TC is able and willing to make a local copy of a content item. False by default.
 610  * @return stdClass The object containing the signed request parameters and the URL to the TP's Content-Item selection interface.
 611  * @throws moodle_exception When the LTI tool type does not exist.`
 612  * @throws coding_exception For invalid media type and presentation target parameters.
 613  */
 614 function lti_build_content_item_selection_request($id, $course, moodle_url $returnurl, $title = '', $text = '', $mediatypes = [],
 615                                                   $presentationtargets = [], $autocreate = false, $multiple = false,
 616                                                   $unsigned = false, $canconfirm = false, $copyadvice = false) {
 617     $tool = lti_get_type($id);
 618     // Validate parameters.
 619     if (!$tool) {
 620         throw new moodle_exception('errortooltypenotfound', 'mod_lti');
 621     }
 622     if (!is_array($mediatypes)) {
 623         throw new coding_exception('The list of accepted media types should be in an array');
 624     }
 625     if (!is_array($presentationtargets)) {
 626         throw new coding_exception('The list of accepted presentation targets should be in an array');
 627     }
 628
 629     // Check title. If empty, use the tool's name.
 630     if (empty($title)) {
 631         $title = $tool->name;
 632     }
 633
 634     $typeconfig = lti_get_type_config($id);
 635     $key = '';
 636     $secret = '';
 637     $islti2 = false;
 638     if (isset($tool->toolproxyid)) {
 639         $islti2 = true;
 640         $toolproxy = lti_get_tool_proxy($tool->toolproxyid);
 641         $key = $toolproxy->guid;
 642         $secret = $toolproxy->secret;
 643     } else {
 644         $toolproxy = null;
 645         if (!empty($typeconfig['resourcekey'])) {
 646             $key = $typeconfig['resourcekey'];
 647         }
 648         if (!empty($typeconfig['password'])) {
 649             $secret = $typeconfig['password'];
 650         }
 651     }
 652     $tool->enabledcapability = '';
 653     if (!empty($typeconfig['enabledcapability_ContentItemSelectionRequest'])) {
 654         $tool->enabledcapability = $typeconfig['enabledcapability_ContentItemSelectionRequest'];
 655     }
 656
 657     $tool->parameter = '';
 658     if (!empty($typeconfig['parameter_ContentItemSelectionRequest'])) {
 659         $tool->parameter = $typeconfig['parameter_ContentItemSelectionRequest'];
 660     }
 661
 662     // Set the tool URL.
 663     if (!empty($typeconfig['toolurl_ContentItemSelectionRequest'])) {
 664         $toolurl = new moodle_url($typeconfig['toolurl_ContentItemSelectionRequest']);
 665     } else {
 666         $toolurl = new moodle_url($typeconfig['toolurl']);
 667     }
 668
 669     // Check if SSL is forced.
 670     if (!empty($typeconfig['forcessl'])) {
 671         // Make sure the tool URL is set to https.
 672         if (strtolower($toolurl->get_scheme()) === 'http') {
 673             $toolurl->set_scheme('https');
 674         }
 675         // Make sure the return URL is set to https.
 676         if (strtolower($returnurl->get_scheme()) === 'http') {
 677             $returnurl->set_scheme('https');
 678         }
 679     }
 680     $toolurlout = $toolurl->out(false);
 681
 682     // Get base request parameters.
 683     $instance = new stdClass();
 684     $instance->course = $course->id;
 685     $requestparams = lti_build_request($instance, $typeconfig, $course, $id, $islti2);
 686
 687     // Get LTI2-specific request parameters and merge to the request parameters if applicable.
 688     if ($islti2) {
 689         $lti2params = lti_build_request_lti2($tool, $requestparams);
 690         $requestparams = array_merge($requestparams, $lti2params);
 691     }
 692
 693     // Get standard request parameters and merge to the request parameters.
 694     $orgid = !empty($typeconfig['organizationid']) ? $typeconfig['organizationid'] : '';
 695     $standardparams = lti_build_standard_request(null, $orgid, $islti2, 'ContentItemSelectionRequest');
 696     $requestparams = array_merge($requestparams, $standardparams);
 697
 698     // Get custom request parameters and merge to the request parameters.
 699     $customstr = '';
 700     if (!empty($typeconfig['customparameters'])) {
 701         $customstr = $typeconfig['customparameters'];
 702     }
 703     $customparams = lti_build_custom_parameters($toolproxy, $tool, $instance, $requestparams, $customstr, '', $islti2);
 704     $requestparams = array_merge($requestparams, $customparams);
 705
 706     // Allow request params to be updated by sub-plugins.
 707     $plugins = core_component::get_plugin_list('ltisource');
 708     foreach (array_keys($plugins) as $plugin) {
 709         $pluginparams = component_callback('ltisource_' . $plugin, 'before_launch', [$instance, $toolurlout, $requestparams], []);
 710
 711         if (!empty($pluginparams) && is_array($pluginparams)) {
 712             $requestparams = array_merge($requestparams, $pluginparams);
 713         }
 714     }
 715
 716     // Media types. Set to ltilink by default if empty.
 717     if (empty($mediatypes)) {
 718         $mediatypes = [
 719             'application/vnd.ims.lti.v1.ltilink',
 720         ];
 721     }
 722     $requestparams['accept_media_types'] = implode(',', $mediatypes);
 723
 724     // Presentation targets. Supports frame, iframe, window by default if empty.
 725     if (empty($presentationtargets)) {
 726         $presentationtargets = [
 727             'frame',
 728             'iframe',
 729             'window',
 730         ];
 731     }
 732     $requestparams['accept_presentation_document_targets'] = implode(',', $presentationtargets);
 733
 734     // Other request parameters.
 735     $requestparams['accept_copy_advice'] = $copyadvice === true ? 'true' : 'false';
 736     $requestparams['accept_multiple'] = $multiple === true ? 'true' : 'false';
 737     $requestparams['accept_unsigned'] = $unsigned === true ? 'true' : 'false';
 738     $requestparams['auto_create'] = $autocreate === true ? 'true' : 'false';
 739     $requestparams['can_confirm'] = $canconfirm === true ? 'true' : 'false';
 740     $requestparams['content_item_return_url'] = $returnurl->out(false);
 741     $requestparams['title'] = $title;
 742     $requestparams['text'] = $text;
 743     $signedparams = lti_sign_parameters($requestparams, $toolurlout, 'POST', $key, $secret);
 744     $toolurlparams = $toolurl->params();
 745
 746     // Strip querystring params in endpoint url from $signedparams to avoid duplication.
 747     if (!empty($toolurlparams) && !empty($signedparams)) {
 748         foreach (array_keys($toolurlparams) as $paramname) {
 749             if (isset($signedparams[$paramname])) {
 750                 unset($signedparams[$paramname]);
 751             }
 752         }
 753     }
 754
 755     // Check for params that should not be passed. Unset if they are set.
 756     $unwantedparams = [
 757         'resource_link_id',
 758         'resource_link_title',
 759         'resource_link_description',
 760         'launch_presentation_return_url',
 761         'lis_result_sourcedid',
 762     ];
 763     foreach ($unwantedparams as $param) {
 764         if (isset($signedparams[$param])) {
 765             unset($signedparams[$param]);
 766         }
 767     }
 768
 769     // Prepare result object.
 770     $result = new stdClass();
 771     $result->params = $signedparams;
 772     $result->url = $toolurlout;
 773
 774     return $result;
 775 }
 776
 777 /**
 778  * Processes the tool provider's response to the ContentItemSelectionRequest and builds the configuration data from the
 779  * selected content item. This configuration data can be then used when adding a tool into the course.
 780  *
 781  * @param int $typeid The tool type ID.
 782  * @param string $messagetype The value for the lti_message_type parameter.
 783  * @param string $ltiversion The value for the lti_version parameter.
 784  * @param string $consumerkey The consumer key.
 785  * @param string $contentitemsjson The JSON string for the content_items parameter.
 786  * @return stdClass The array of module information objects.
 787  * @throws moodle_exception
 788  * @throws lti\OAuthException
 789  */
 790 function lti_tool_configuration_from_content_item($typeid, $messagetype, $ltiversion, $consumerkey, $contentitemsjson) {
 791     $tool = lti_get_type($typeid);
 792     // Validate parameters.
 793     if (!$tool) {
 794         throw new moodle_exception('errortooltypenotfound', 'mod_lti');
 795     }
 796     // Check lti_message_type. Show debugging if it's not set to ContentItemSelection.
 797     // No need to throw exceptions for now since lti_message_type does not seem to be used in this processing at the moment.
 798     if ($messagetype !== 'ContentItemSelection') {
 799         debugging("lti_message_type is invalid: {$messagetype}. It should be set to 'ContentItemSelection'.",
 800             DEBUG_DEVELOPER);
 801     }
 802
 803     $typeconfig = lti_get_type_config($typeid);
 804
 805     if (isset($tool->toolproxyid)) {
 806         $islti2 = true;
 807         $toolproxy = lti_get_tool_proxy($tool->toolproxyid);
 808         $key = $toolproxy->guid;
 809         $secret = $toolproxy->secret;
 810     } else {
 811         $islti2 = false;
 812         $toolproxy = null;
 813         if (!empty($typeconfig['resourcekey'])) {
 814             $key = $typeconfig['resourcekey'];
 815         } else {
 816             $key = '';
 817         }
 818         if (!empty($typeconfig['password'])) {
 819             $secret = $typeconfig['password'];
 820         } else {
 821             $secret = '';
 822         }
 823     }
 824
 825     // Check LTI versions from our side and the response's side. Show debugging if they don't match.
 826     // No need to throw exceptions for now since LTI version does not seem to be used in this processing at the moment.
 827     $expectedversion = LTI_VERSION_1;
 828     if ($islti2) {
 829         $expectedversion = LTI_VERSION_2;
 830     }
 831     if ($ltiversion !== $expectedversion) {
 832         debugging("lti_version from response does not match the tool's configuration. Tool: {$expectedversion}," .
 833             " Response: {$ltiversion}", DEBUG_DEVELOPER);
 834     }
 835
 836     if ($consumerkey !== $key) {
 837         throw new moodle_exception('errorincorrectconsumerkey', 'mod_lti');
 838     }
 839
 840     $store = new lti\TrivialOAuthDataStore();
 841     $store->add_consumer($key, $secret);
 842     $server = new lti\OAuthServer($store);
 843     $method = new lti\OAuthSignatureMethod_HMAC_SHA1();
 844     $server->add_signature_method($method);
 845     $request = lti\OAuthRequest::from_request();
 846     try {
 847         $server->verify_request($request);
 848     } catch (lti\OAuthException $e) {
 849         throw new lti\OAuthException("OAuth signature failed: " . $e->getMessage());
 850     }
 851
 852     $items = json_decode($contentitemsjson);
 853     if (empty($items)) {
 854         throw new moodle_exception('errorinvaliddata', 'mod_lti', '', $contentitemsjson);
 855     }
 856     if ($items->{'@context'} !== 'http://purl.imsglobal.org/ctx/lti/v1/ContentItem') {
 857         throw new moodle_exception('errorinvalidmediatype', 'mod_lti', '', $items->{'@context'});
 858     }
 859     if (!isset($items->{'@graph'}) || !is_array($items->{'@graph'}) || (count($items->{'@graph'}) > 1)) {
 860         throw new moodle_exception('errorinvalidresponseformat', 'mod_lti');
 861     }
 862
 863     $config = null;
 864     if (!empty($items->{'@graph'})) {
 865         $item = $items->{'@graph'}[0];
 866
 867         $config = new stdClass();
 868         $config->name = '';
 869         if (isset($item->title)) {
 870             $config->name = $item->title;
 871         }
 872         if (empty($config->name)) {
 873             $config->name = $tool->name;
 874         }
 875         if (isset($item->text)) {
 876             $config->introeditor = [
 877                 'text' => $item->text,
 878                 'format' => FORMAT_PLAIN
 879             ];
 880         }
 881         if (isset($item->icon->{'@id'})) {
 882             $iconurl = new moodle_url($item->icon->{'@id'});
 883             // Assign item's icon URL to secureicon or icon depending on its scheme.
 884             if (strtolower($iconurl->get_scheme()) === 'https') {
 885                 $config->secureicon = $iconurl->out(false);
 886             } else {
 887                 $config->icon = $iconurl->out(false);
 888             }
 889         }
 890         if (isset($item->url)) {
 891             $url = new moodle_url($item->url);
 892             // Assign item URL to securetoolurl or toolurl depending on its scheme.
 893             if (strtolower($url->get_scheme()) === 'https') {
 894                 $config->securetoolurl = $url->out(false);
 895             } else {
 896                 $config->toolurl = $url->out(false);
 897             }
 898             $config->typeid = 0;
 899         } else {
 900             $config->typeid = $typeid;
 901         }
 902         $config->instructorchoicesendname = LTI_SETTING_NEVER;
 903         $config->instructorchoicesendemailaddr = LTI_SETTING_NEVER;
 904         $config->instructorchoiceacceptgrades = LTI_SETTING_NEVER;
 905         $config->launchcontainer = LTI_LAUNCH_CONTAINER_DEFAULT;
 906         if (isset($item->placementAdvice->presentationDocumentTarget)) {
 907             if ($item->placementAdvice->presentationDocumentTarget === 'window') {
 908                 $config->launchcontainer = LTI_LAUNCH_CONTAINER_WINDOW;
 909             } else if ($item->placementAdvice->presentationDocumentTarget === 'frame') {
 910                 $config->launchcontainer = LTI_LAUNCH_CONTAINER_EMBED_NO_BLOCKS;
 911             } else if ($item->placementAdvice->presentationDocumentTarget === 'iframe') {
 912                 $config->launchcontainer = LTI_LAUNCH_CONTAINER_EMBED;
 913             }
 914         }
 915         if (isset($item->custom)) {
 916             $customparameters = [];
 917             foreach ($item->custom as $key => $value) {
 918                 $customparameters[] = "{$key}={$value}";
 919             }
 920             $config->instructorcustomparameters = implode("\n", $customparameters);
 921         }
 922     }
 923     return $config;
 924 }
 925
 926 function lti_get_tool_table($tools, $id) {
 927     global $CFG, $OUTPUT, $USER;
 928     $html = '';
 929
 930     $typename = get_string('typename', 'lti');
 931     $baseurl = get_string('baseurl', 'lti');
 932     $action = get_string('action', 'lti');
 933     $createdon = get_string('createdon', 'lti');
 934
 935     if (!empty($tools)) {
 936         $html .= "
 937         <div id=\"{$id}_tools_container\" style=\"margin-top:.5em;margin-bottom:.5em\">
 938             <table id=\"{$id}_tools\">
 939                 <thead>
 940                     <tr>
 941                         <th>$typename</th>
 942                         <th>$baseurl</th>
 943                         <th>$createdon</th>
 944                         <th>$action</th>
 945                     </tr>
 946                 </thead>
 947         ";
 948
 949         foreach ($tools as $type) {
 950             $date = userdate($type->timecreated, get_string('strftimedatefullshort', 'core_langconfig'));
 951             $accept = get_string('accept', 'lti');
 952             $update = get_string('update', 'lti');
 953             $delete = get_string('delete', 'lti');
 954
 955             if (empty($type->toolproxyid)) {
 956                 $baseurl = new \moodle_url('/mod/lti/typessettings.php', array(
 957                         'action' => 'accept',
 958                         'id' => $type->id,
 959                         'sesskey' => sesskey(),
 960                         'tab' => $id
 961                     ));
 962                 $ref = $type->baseurl;
 963             } else {
 964                 $baseurl = new \moodle_url('/mod/lti/toolssettings.php', array(
 965                         'action' => 'accept',
 966                         'id' => $type->id,
 967                         'sesskey' => sesskey(),
 968                         'tab' => $id
 969                     ));
 970                 $ref = $type->tpname;
 971             }
 972
 973             $accepthtml = $OUTPUT->action_icon($baseurl,
 974                     new \pix_icon('t/check', $accept, '', array('class' => 'iconsmall')), null,
 975                     array('title' => $accept, 'class' => 'editing_accept'));
 976
 977             $deleteaction = 'delete';
 978
 979             if ($type->state == LTI_TOOL_STATE_CONFIGURED) {
 980                 $accepthtml = '';
 981             }
 982
 983             if ($type->state != LTI_TOOL_STATE_REJECTED) {
 984                 $deleteaction = 'reject';
 985                 $delete = get_string('reject', 'lti');
 986             }
 987
 988             $updateurl = clone($baseurl);
 989             $updateurl->param('action', 'update');
 990             $updatehtml = $OUTPUT->action_icon($updateurl,
 991                     new \pix_icon('t/edit', $update, '', array('class' => 'iconsmall')), null,
 992                     array('title' => $update, 'class' => 'editing_update'));
 993
 994             if (($type->state != LTI_TOOL_STATE_REJECTED) || empty($type->toolproxyid)) {
 995                 $deleteurl = clone($baseurl);
 996                 $deleteurl->param('action', $deleteaction);
 997                 $deletehtml = $OUTPUT->action_icon($deleteurl,
 998                         new \pix_icon('t/delete', $delete, '', array('class' => 'iconsmall')), null,
 999                         array('title' => $delete, 'class' => 'editing_delete'));
1000             } else {
1001                 $deletehtml = '';
1002             }
1003             $html .= "
1004             <tr>
1005                 <td>
1006                     {$type->name}
1007                 </td>
1008                 <td>
1009                     {$ref}
1010                 </td>
1011                 <td>
1012                     {$date}
1013                 </td>
1014                 <td align=\"center\">
1015                     {$accepthtml}{$updatehtml}{$deletehtml}
1016                 </td>
1017             </tr>
1018             ";
1019         }
1020         $html .= '</table></div>';
1021     } else {
1022         $html .= get_string('no_' . $id, 'lti');
1023     }
1024
1025     return $html;
1026 }
1027
1028 /**
1029  * This function builds the tab for a category of tool proxies
1030  *
1031  * @param object    $toolproxies    Tool proxy instance objects
1032  * @param string    $id             Category ID
1033  *
1034  * @return string                   HTML for tab
1035  */
1036 function lti_get_tool_proxy_table($toolproxies, $id) {
1037     global $OUTPUT;
1038
1039     if (!empty($toolproxies)) {
1040         $typename = get_string('typename', 'lti');
1041         $url = get_string('registrationurl', 'lti');
1042         $action = get_string('action', 'lti');
1043         $createdon = get_string('createdon', 'lti');
1044
1045         $html = <<< EOD
1046         <div id="{$id}_tool_proxies_container" style="margin-top: 0.5em; margin-bottom: 0.5em">
1047             <table id="{$id}_tool_proxies">
1048                 <thead>
1049                     <tr>
1050                         <th>{$typename}</th>
1051                         <th>{$url}</th>
1052                         <th>{$createdon}</th>
1053                         <th>{$action}</th>
1054                     </tr>
1055                 </thead>
1056 EOD;
1057         foreach ($toolproxies as $toolproxy) {
1058             $date = userdate($toolproxy->timecreated, get_string('strftimedatefullshort', 'core_langconfig'));
1059             $accept = get_string('register', 'lti');
1060             $update = get_string('update', 'lti');
1061             $delete = get_string('delete', 'lti');
1062
1063             $baseurl = new \moodle_url('/mod/lti/registersettings.php', array(
1064                     'action' => 'accept',
1065                     'id' => $toolproxy->id,
1066                     'sesskey' => sesskey(),
1067                     'tab' => $id
1068                 ));
1069
1070             $registerurl = new \moodle_url('/mod/lti/register.php', array(
1071                     'id' => $toolproxy->id,
1072                     'sesskey' => sesskey(),
1073                     'tab' => 'tool_proxy'
1074                 ));
1075
1076             $accepthtml = $OUTPUT->action_icon($registerurl,
1077                     new \pix_icon('t/check', $accept, '', array('class' => 'iconsmall')), null,
1078                     array('title' => $accept, 'class' => 'editing_accept'));
1079
1080             $deleteaction = 'delete';
1081
1082             if ($toolproxy->state != LTI_TOOL_PROXY_STATE_CONFIGURED) {
1083                 $accepthtml = '';
1084             }
1085
1086             if (($toolproxy->state == LTI_TOOL_PROXY_STATE_CONFIGURED) || ($toolproxy->state == LTI_TOOL_PROXY_STATE_PENDING)) {
1087                 $delete = get_string('cancel', 'lti');
1088             }
1089
1090             $updateurl = clone($baseurl);
1091             $updateurl->param('action', 'update');
1092             $updatehtml = $OUTPUT->action_icon($updateurl,
1093                     new \pix_icon('t/edit', $update, '', array('class' => 'iconsmall')), null,
1094                     array('title' => $update, 'class' => 'editing_update'));
1095
1096             $deleteurl = clone($baseurl);
1097             $deleteurl->param('action', $deleteaction);
1098             $deletehtml = $OUTPUT->action_icon($deleteurl,
1099                     new \pix_icon('t/delete', $delete, '', array('class' => 'iconsmall')), null,
1100                     array('title' => $delete, 'class' => 'editing_delete'));
1101             $html .= <<< EOD
1102             <tr>
1103                 <td>
1104                     {$toolproxy->name}
1105                 </td>
1106                 <td>
1107                     {$toolproxy->regurl}
1108                 </td>
1109                 <td>
1110                     {$date}
1111                 </td>
1112                 <td align="center">
1113                     {$accepthtml}{$updatehtml}{$deletehtml}
1114                 </td>
1115             </tr>
1116 EOD;
1117         }
1118         $html .= '</table></div>';
1119     } else {
1120         $html = get_string('no_' . $id, 'lti');
1121     }
1122
1123     return $html;
1124 }
1125
1126 /**
1127  * Extracts the enabled capabilities into an array, including those implicitly declared in a parameter
1128  *
1129  * @param object    $tool           Tool instance object
1130  *
1131  * @return Array of enabled capabilities
1132  */
1133 function lti_get_enabled_capabilities($tool) {
1134     if (!empty($tool->enabledcapability)) {
1135         $enabledcapabilities = explode("\n", $tool->enabledcapability);
1136     } else {
1137         $enabledcapabilities = array();
1138     }
1139     $paramstr = str_replace("\r\n", "\n", $tool->parameter);
1140     $paramstr = str_replace("\n\r", "\n", $paramstr);
1141     $paramstr = str_replace("\r", "\n", $paramstr);
1142     $params = explode("\n", $paramstr);
1143     foreach ($params as $param) {
1144         $pos = strpos($param, '=');
1145         if (($pos === false) || ($pos < 1)) {
1146             continue;
1147         }
1148         $value = trim(core_text::substr($param, $pos + 1, strlen($param)));
1149         if (substr($value, 0, 1) == '$') {
1150             $value = substr($value, 1);
1151             if (!in_array($value, $enabledcapabilities)) {
1152                 $enabledcapabilities[] = $value;
1153             }
1154         }
1155     }
1156     return $enabledcapabilities;
1157 }
1158
1159 /**
1160  * Splits the custom parameters field to the various parameters
1161  *
1162  * @param object    $toolproxy      Tool proxy instance object
1163  * @param object    $tool           Tool instance object
1164  * @param array     $params         LTI launch parameters
1165  * @param string    $customstr      String containing the parameters
1166  * @param boolean   $islti2         True if an LTI 2 tool is being launched
1167  *
1168  * @return Array of custom parameters
1169  */
1170 function lti_split_custom_parameters($toolproxy, $tool, $params, $customstr, $islti2 = false) {
1171     $customstr = str_replace("\r\n", "\n", $customstr);
1172     $customstr = str_replace("\n\r", "\n", $customstr);
1173     $customstr = str_replace("\r", "\n", $customstr);
1174     $lines = explode("\n", $customstr);  // Or should this split on "/[\n;]/"?
1175     $retval = array();
1176     foreach ($lines as $line) {
1177         $pos = strpos($line, '=');
1178         if ( $pos === false || $pos < 1 ) {
1179             continue;
1180         }
1181         $key = trim(core_text::substr($line, 0, $pos));
1182         $val = trim(core_text::substr($line, $pos + 1, strlen($line)));
1183         $val = lti_parse_custom_parameter($toolproxy, $tool, $params, $val, $islti2);
1184         $key2 = lti_map_keyname($key);
1185         $retval['custom_'.$key2] = $val;
1186         if ($islti2 && ($key != $key2)) {
1187             $retval['custom_'.$key] = $val;
1188         }
1189     }
1190     return $retval;
1191 }
1192
1193 /**
1194  * Adds the custom parameters to an array
1195  *
1196  * @param object    $toolproxy      Tool proxy instance object
1197  * @param object    $tool           Tool instance object
1198  * @param array     $params         LTI launch parameters
1199  * @param array     $parameters     Array containing the parameters
1200  *
1201  * @return array    Array of custom parameters
1202  */
1203 function lti_get_custom_parameters($toolproxy, $tool, $params, $parameters) {
1204     $retval = array();
1205     foreach ($parameters as $key => $val) {
1206         $key2 = lti_map_keyname($key);
1207         $val = lti_parse_custom_parameter($toolproxy, $tool, $params, $val, true);
1208         $retval['custom_'.$key2] = $val;
1209         if ($key != $key2) {
1210             $retval['custom_'.$key] = $val;
1211         }
1212     }
1213     return $retval;
1214 }
1215
1216 /**
1217  * Parse a custom parameter to replace any substitution variables
1218  *
1219  * @param object    $toolproxy      Tool proxy instance object
1220  * @param object    $tool           Tool instance object
1221  * @param array     $params         LTI launch parameters
1222  * @param string    $value          Custom parameter value
1223  * @param boolean   $islti2         True if an LTI 2 tool is being launched
1224  *
1225  * @return Parsed value of custom parameter
1226  */
1227 function lti_parse_custom_parameter($toolproxy, $tool, $params, $value, $islti2) {
1228     global $USER, $COURSE;
1229
1230     if ($value) {
1231         if (substr($value, 0, 1) == '\\') {
1232             $value = substr($value, 1);
1233         } else if (substr($value, 0, 1) == '$') {
1234             $value1 = substr($value, 1);
1235             $enabledcapabilities = lti_get_enabled_capabilities($tool);
1236             if (!$islti2 || in_array($value1, $enabledcapabilities)) {
1237                 $capabilities = lti_get_capabilities();
1238                 if (array_key_exists($value1, $capabilities)) {
1239                     $val = $capabilities[$value1];
1240                     if ($val) {
1241                         if (substr($val, 0, 1) != '$') {
1242                             $value = $params[$val];
1243                         } else {
1244                             $valarr = explode('->', substr($val, 1), 2);
1245                             $value = "{${$valarr[0]}->{$valarr[1]}}";
1246                             $value = str_replace('<br />' , ' ', $value);
1247                             $value = str_replace('<br>' , ' ', $value);
1248                             $value = format_string($value);
1249                         }
1250                     }
1251                 } else if ($islti2) {
1252                     $val = $value;
1253                     $services = lti_get_services();
1254                     foreach ($services as $service) {
1255                         $service->set_tool_proxy($toolproxy);
1256                         $value = $service->parse_value($val);
1257                         if ($val != $value) {
1258                             break;
1259                         }
1260                     }
1261                 }
1262             }
1263         }
1264     }
1265     return $value;
1266 }
1267
1268 /**
1269  * Used for building the names of the different custom parameters
1270  *
1271  * @param string $key   Parameter name
1272  *
1273  * @return string       Processed name
1274  */
1275 function lti_map_keyname($key) {
1276     $newkey = "";
1277     $key = core_text::strtolower(trim($key));
1278     foreach (str_split($key) as $ch) {
1279         if ( ($ch >= 'a' && $ch <= 'z') || ($ch >= '0' && $ch <= '9') ) {
1280             $newkey .= $ch;
1281         } else {
1282             $newkey .= '_';
1283         }
1284     }
1285     return $newkey;
1286 }
1287
1288 /**
1289  * Gets the IMS role string for the specified user and LTI course module.
1290  *
1291  * @param mixed    $user      User object or user id
1292  * @param int      $cmid      The course module id of the LTI activity
1293  * @param int      $courseid  The course id of the LTI activity
1294  * @param boolean  $islti2    True if an LTI 2 tool is being launched
1295  *
1296  * @return string A role string suitable for passing with an LTI launch
1297  */
1298 function lti_get_ims_role($user, $cmid, $courseid, $islti2) {
1299     $roles = array();
1300
1301     if (empty($cmid)) {
1302         // If no cmid is passed, check if the user is a teacher in the course
1303         // This allows other modules to programmatically "fake" a launch without
1304         // a real LTI instance.
1305         $context = context_course::instance($courseid);
1306
1307         if (has_capability('moodle/course:manageactivities', $context, $user)) {
1308             array_push($roles, 'Instructor');
1309         } else {
1310             array_push($roles, 'Learner');
1311         }
1312     } else {
1313         $context = context_module::instance($cmid);
1314
1315         if (has_capability('mod/lti:manage', $context)) {
1316             array_push($roles, 'Instructor');
1317         } else {
1318             array_push($roles, 'Learner');
1319         }
1320     }
1321
1322     if (is_siteadmin($user) || has_capability('mod/lti:admin', $context)) {
1323         // Make sure admins do not have the Learner role, then set admin role.
1324         $roles = array_diff($roles, array('Learner'));
1325         if (!$islti2) {
1326             array_push($roles, 'urn:lti:sysrole:ims/lis/Administrator', 'urn:lti:instrole:ims/lis/Administrator');
1327         } else {
1328             array_push($roles, 'http://purl.imsglobal.org/vocab/lis/v2/person#Administrator');
1329         }
1330     }
1331
1332     return join(',', $roles);
1333 }
1334
1335 /**
1336  * Returns configuration details for the tool
1337  *
1338  * @param int $typeid   Basic LTI tool typeid
1339  *
1340  * @return array        Tool Configuration
1341  */
1342 function lti_get_type_config($typeid) {
1343     global $DB;
1344
1345     $query = "SELECT name, value
1346                 FROM {lti_types_config}
1347                WHERE typeid = :typeid1
1348            UNION ALL
1349               SELECT 'toolurl' AS name, baseurl AS value
1350                 FROM {lti_types}
1351                WHERE id = :typeid2
1352            UNION ALL
1353               SELECT 'icon' AS name, icon AS value
1354                 FROM {lti_types}
1355                WHERE id = :typeid3
1356            UNION ALL
1357               SELECT 'secureicon' AS name, secureicon AS value
1358                 FROM {lti_types}
1359                WHERE id = :typeid4";
1360
1361     $typeconfig = array();
1362     $configs = $DB->get_records_sql($query,
1363         array('typeid1' => $typeid, 'typeid2' => $typeid, 'typeid3' => $typeid, 'typeid4' => $typeid));
1364
1365     if (!empty($configs)) {
1366         foreach ($configs as $config) {
1367             $typeconfig[$config->name] = $config->value;
1368         }
1369     }
1370
1371     return $typeconfig;
1372 }
1373
1374 function lti_get_tools_by_url($url, $state, $courseid = null) {
1375     $domain = lti_get_domain_from_url($url);
1376
1377     return lti_get_tools_by_domain($domain, $state, $courseid);
1378 }
1379
1380 function lti_get_tools_by_domain($domain, $state = null, $courseid = null) {
1381     global $DB, $SITE;
1382
1383     $filters = array('tooldomain' => $domain);
1384
1385     $statefilter = '';
1386     $coursefilter = '';
1387
1388     if ($state) {
1389         $statefilter = 'AND state = :state';
1390     }
1391
1392     if ($courseid && $courseid != $SITE->id) {
1393         $coursefilter = 'OR course = :courseid';
1394     }
1395
1396     $query = "SELECT *
1397                 FROM {lti_types}
1398                WHERE tooldomain = :tooldomain
1399                  AND (course = :siteid $coursefilter)
1400                  $statefilter";
1401
1402     return $DB->get_records_sql($query, array(
1403         'courseid' => $courseid,
1404         'siteid' => $SITE->id,
1405         'tooldomain' => $domain,
1406         'state' => $state
1407     ));
1408 }
1409
1410 /**
1411  * Returns all basicLTI tools configured by the administrator
1412  *
1413  */
1414 function lti_filter_get_types($course) {
1415     global $DB;
1416
1417     if (!empty($course)) {
1418         $where = "WHERE t.course = :course";
1419         $params = array('course' => $course);
1420     } else {
1421         $where = '';
1422         $params = array();
1423     }
1424     $query = "SELECT t.id, t.name, t.baseurl, t.state, t.toolproxyid, t.timecreated, tp.name tpname
1425                 FROM {lti_types} t LEFT OUTER JOIN {lti_tool_proxies} tp ON t.toolproxyid = tp.id
1426                 {$where}";
1427     return $DB->get_records_sql($query, $params);
1428 }
1429
1430 /**
1431  * Given an array of tools, filter them based on their state
1432  *
1433  * @param array $tools An array of lti_types records
1434  * @param int $state One of the LTI_TOOL_STATE_* constants
1435  * @return array
1436  */
1437 function lti_filter_tool_types(array $tools, $state) {
1438     $return = array();
1439     foreach ($tools as $key => $tool) {
1440         if ($tool->state == $state) {
1441             $return[$key] = $tool;
1442         }
1443     }
1444     return $return;
1445 }
1446
1447 /**
1448  * Returns all lti types visible in this course
1449  *
1450  * @param int $courseid The id of the course to retieve types for
1451  * @param array $coursevisible options for 'coursevisible' field,
1452  *        default [LTI_COURSEVISIBLE_PRECONFIGURED, LTI_COURSEVISIBLE_ACTIVITYCHOOSER]
1453  * @return stdClass[] All the lti types visible in the given course
1454  */
1455 function lti_get_lti_types_by_course($courseid, $coursevisible = null) {
1456     global $DB, $SITE;
1457
1458     if ($coursevisible === null) {
1459         $coursevisible = [LTI_COURSEVISIBLE_PRECONFIGURED, LTI_COURSEVISIBLE_ACTIVITYCHOOSER];
1460     }
1461
1462     list($coursevisiblesql, $coursevisparams) = $DB->get_in_or_equal($coursevisible, SQL_PARAMS_NAMED, 'coursevisible');
1463     $query = "SELECT *
1464                 FROM {lti_types}
1465                WHERE coursevisible $coursevisiblesql
1466                  AND (course = :siteid OR course = :courseid)
1467                  AND state = :active";
1468
1469     return $DB->get_records_sql($query,
1470         array('siteid' => $SITE->id, 'courseid' => $courseid, 'active' => LTI_TOOL_STATE_CONFIGURED) + $coursevisparams);
1471 }
1472
1473 /**
1474  * Returns tool types for lti add instance and edit page
1475  *
1476  * @return array Array of lti types
1477  */
1478 function lti_get_types_for_add_instance() {
1479     global $COURSE;
1480     $admintypes = lti_get_lti_types_by_course($COURSE->id);
1481
1482     $types = array();
1483     $types[0] = (object)array('name' => get_string('automatic', 'lti'), 'course' => 0, 'toolproxyid' => null);
1484
1485     foreach ($admintypes as $type) {
1486         $types[$type->id] = $type;
1487     }
1488
1489     return $types;
1490 }
1491
1492 /**
1493  * Returns a list of configured types in the given course
1494  *
1495  * @param int $courseid The id of the course to retieve types for
1496  * @param int $sectionreturn section to return to for forming the URLs
1497  * @return array Array of lti types. Each element is object with properties: name, title, icon, help, helplink, link
1498  */
1499 function lti_get_configured_types($courseid, $sectionreturn = 0) {
1500     global $OUTPUT;
1501     $types = array();
1502     $admintypes = lti_get_lti_types_by_course($courseid, [LTI_COURSEVISIBLE_ACTIVITYCHOOSER]);
1503
1504     foreach ($admintypes as $ltitype) {
1505         $type           = new stdClass();
1506         $type->modclass = MOD_CLASS_ACTIVITY;
1507         $type->name     = 'lti_type_' . $ltitype->id;
1508         // Clean the name. We don't want tags here.
1509         $type->title    = clean_param($ltitype->name, PARAM_NOTAGS);
1510         $trimmeddescription = trim($ltitype->description);
1511         if ($trimmeddescription != '') {
1512             // Clean the description. We don't want tags here.
1513             $type->help     = clean_param($trimmeddescription, PARAM_NOTAGS);
1514             $type->helplink = get_string('modulename_shortcut_link', 'lti');
1515         }
1516         if (empty($ltitype->icon)) {
1517             $type->icon = $OUTPUT->pix_icon('icon', '', 'lti', array('class' => 'icon'));
1518         } else {
1519             $type->icon = html_writer::empty_tag('img', array('src' => $ltitype->icon, 'alt' => $ltitype->name, 'class' => 'icon'));
1520         }
1521         $type->link = new moodle_url('/course/modedit.php', array('add' => 'lti', 'return' => 0, 'course' => $courseid,
1522             'sr' => $sectionreturn, 'typeid' => $ltitype->id));
1523         $types[] = $type;
1524     }
1525     return $types;
1526 }
1527
1528 function lti_get_domain_from_url($url) {
1529     $matches = array();
1530
1531     if (preg_match(LTI_URL_DOMAIN_REGEX, $url, $matches)) {
1532         return $matches[1];
1533     }
1534 }
1535
1536 function lti_get_tool_by_url_match($url, $courseid = null, $state = LTI_TOOL_STATE_CONFIGURED) {
1537     $possibletools = lti_get_tools_by_url($url, $state, $courseid);
1538
1539     return lti_get_best_tool_by_url($url, $possibletools, $courseid);
1540 }
1541
1542 function lti_get_url_thumbprint($url) {
1543     // Parse URL requires a schema otherwise everything goes into 'path'.  Fixed 5.4.7 or later.
1544     if (preg_match('/https?:\/\//', $url) !== 1) {
1545         $url = 'http://'.$url;
1546     }
1547     $urlparts = parse_url(strtolower($url));
1548     if (!isset($urlparts['path'])) {
1549         $urlparts['path'] = '';
1550     }
1551
1552     if (!isset($urlparts['query'])) {
1553         $urlparts['query'] = '';
1554     }
1555
1556     if (!isset($urlparts['host'])) {
1557         $urlparts['host'] = '';
1558     }
1559
1560     if (substr($urlparts['host'], 0, 4) === 'www.') {
1561         $urlparts['host'] = substr($urlparts['host'], 4);
1562     }
1563
1564     $urllower = $urlparts['host'] . '/' . $urlparts['path'];
1565
1566     if ($urlparts['query'] != '') {
1567         $urllower .= '?' . $urlparts['query'];
1568     }
1569
1570     return $urllower;
1571 }
1572
1573 function lti_get_best_tool_by_url($url, $tools, $courseid = null) {
1574     if (count($tools) === 0) {
1575         return null;
1576     }
1577
1578     $urllower = lti_get_url_thumbprint($url);
1579
1580     foreach ($tools as $tool) {
1581         $tool->_matchscore = 0;
1582
1583         $toolbaseurllower = lti_get_url_thumbprint($tool->baseurl);
1584
1585         if ($urllower === $toolbaseurllower) {
1586             // 100 points for exact thumbprint match.
1587             $tool->_matchscore += 100;
1588         } else if (substr($urllower, 0, strlen($toolbaseurllower)) === $toolbaseurllower) {
1589             // 50 points if tool thumbprint starts with the base URL thumbprint.
1590             $tool->_matchscore += 50;
1591         }
1592
1593         // Prefer course tools over site tools.
1594         if (!empty($courseid)) {
1595             // Minus 10 points for not matching the course id (global tools).
1596             if ($tool->course != $courseid) {
1597                 $tool->_matchscore -= 10;
1598             }
1599         }
1600     }
1601
1602     $bestmatch = array_reduce($tools, function($value, $tool) {
1603         if ($tool->_matchscore > $value->_matchscore) {
1604             return $tool;
1605         } else {
1606             return $value;
1607         }
1608
1609     }, (object)array('_matchscore' => -1));
1610
1611     // None of the tools are suitable for this URL.
1612     if ($bestmatch->_matchscore <= 0) {
1613         return null;
1614     }
1615
1616     return $bestmatch;
1617 }
1618
1619 function lti_get_shared_secrets_by_key($key) {
1620     global $DB;
1621
1622     // Look up the shared secret for the specified key in both the types_config table (for configured tools)
1623     // And in the lti resource table for ad-hoc tools.
1624     $query = "SELECT t2.value
1625                 FROM {lti_types_config} t1
1626                 JOIN {lti_types_config} t2 ON t1.typeid = t2.typeid
1627                 JOIN {lti_types} type ON t2.typeid = type.id
1628               WHERE t1.name = 'resourcekey'
1629                 AND t1.value = :key1
1630                 AND t2.name = 'password'
1631                 AND type.state = :configured1
1632                UNION
1633               SELECT tp.secret AS value
1634                 FROM {lti_tool_proxies} tp
1635                 JOIN {lti_types} t ON tp.id = t.toolproxyid
1636               WHERE tp.guid = :key2
1637                 AND t.state = :configured2
1638               UNION
1639              SELECT password AS value
1640                FROM {lti}
1641               WHERE resourcekey = :key3";
1642
1643     $sharedsecrets = $DB->get_records_sql($query, array('configured1' => LTI_TOOL_STATE_CONFIGURED,
1644         'configured2' => LTI_TOOL_STATE_CONFIGURED, 'key1' => $key, 'key2' => $key, 'key3' => $key));
1645
1646     $values = array_map(function($item) {
1647         return $item->value;
1648     }, $sharedsecrets);
1649
1650     // There should really only be one shared secret per key. But, we can't prevent
1651     // more than one getting entered. For instance, if the same key is used for two tool providers.
1652     return $values;
1653 }
1654
1655 /**
1656  * Delete a Basic LTI configuration
1657  *
1658  * @param int $id   Configuration id
1659  */
1660 function lti_delete_type($id) {
1661     global $DB;
1662
1663     // We should probably just copy the launch URL to the tool instances in this case... using a single query.
1664     /*
1665     $instances = $DB->get_records('lti', array('typeid' => $id));
1666     foreach ($instances as $instance) {
1667         $instance->typeid = 0;
1668         $DB->update_record('lti', $instance);
1669     }*/
1670
1671     $DB->delete_records('lti_types', array('id' => $id));
1672     $DB->delete_records('lti_types_config', array('typeid' => $id));
1673 }
1674
1675 function lti_set_state_for_type($id, $state) {
1676     global $DB;
1677
1678     $DB->update_record('lti_types', array('id' => $id, 'state' => $state));
1679 }
1680
1681 /**
1682  * Transforms a basic LTI object to an array
1683  *
1684  * @param object $ltiobject    Basic LTI object
1685  *
1686  * @return array Basic LTI configuration details
1687  */
1688 function lti_get_config($ltiobject) {
1689     $typeconfig = array();
1690     $typeconfig = (array)$ltiobject;
1691     $additionalconfig = lti_get_type_config($ltiobject->typeid);
1692     $typeconfig = array_merge($typeconfig, $additionalconfig);
1693     return $typeconfig;
1694 }
1695
1696 /**
1697  *
1698  * Generates some of the tool configuration based on the instance details
1699  *
1700  * @param int $id
1701  *
1702  * @return Instance configuration
1703  *
1704  */
1705 function lti_get_type_config_from_instance($id) {
1706     global $DB;
1707
1708     $instance = $DB->get_record('lti', array('id' => $id));
1709     $config = lti_get_config($instance);
1710
1711     $type = new \stdClass();
1712     $type->lti_fix = $id;
1713     if (isset($config['toolurl'])) {
1714         $type->lti_toolurl = $config['toolurl'];
1715     }
1716     if (isset($config['instructorchoicesendname'])) {
1717         $type->lti_sendname = $config['instructorchoicesendname'];
1718     }
1719     if (isset($config['instructorchoicesendemailaddr'])) {
1720         $type->lti_sendemailaddr = $config['instructorchoicesendemailaddr'];
1721     }
1722     if (isset($config['instructorchoiceacceptgrades'])) {
1723         $type->lti_acceptgrades = $config['instructorchoiceacceptgrades'];
1724     }
1725     if (isset($config['instructorchoiceallowroster'])) {
1726         $type->lti_allowroster = $config['instructorchoiceallowroster'];
1727     }
1728
1729     if (isset($config['instructorcustomparameters'])) {
1730         $type->lti_allowsetting = $config['instructorcustomparameters'];
1731     }
1732     return $type;
1733 }
1734
1735 /**
1736  * Generates some of the tool configuration based on the admin configuration details
1737  *
1738  * @param int $id
1739  *
1740  * @return Configuration details
1741  */
1742 function lti_get_type_type_config($id) {
1743     global $DB;
1744
1745     $basicltitype = $DB->get_record('lti_types', array('id' => $id));
1746     $config = lti_get_type_config($id);
1747
1748     $type = new \stdClass();
1749
1750     $type->lti_typename = $basicltitype->name;
1751
1752     $type->typeid = $basicltitype->id;
1753
1754     $type->toolproxyid = $basicltitype->toolproxyid;
1755
1756     $type->lti_toolurl = $basicltitype->baseurl;
1757
1758     $type->lti_description = $basicltitype->description;
1759
1760     $type->lti_parameters = $basicltitype->parameter;
1761
1762     $type->lti_icon = $basicltitype->icon;
1763
1764     $type->lti_secureicon = $basicltitype->secureicon;
1765
1766     if (isset($config['resourcekey'])) {
1767         $type->lti_resourcekey = $config['resourcekey'];
1768     }
1769     if (isset($config['password'])) {
1770         $type->lti_password = $config['password'];
1771     }
1772
1773     if (isset($config['sendname'])) {
1774         $type->lti_sendname = $config['sendname'];
1775     }
1776     if (isset($config['instructorchoicesendname'])) {
1777         $type->lti_instructorchoicesendname = $config['instructorchoicesendname'];
1778     }
1779     if (isset($config['sendemailaddr'])) {
1780         $type->lti_sendemailaddr = $config['sendemailaddr'];
1781     }
1782     if (isset($config['instructorchoicesendemailaddr'])) {
1783         $type->lti_instructorchoicesendemailaddr = $config['instructorchoicesendemailaddr'];
1784     }
1785     if (isset($config['acceptgrades'])) {
1786         $type->lti_acceptgrades = $config['acceptgrades'];
1787     }
1788     if (isset($config['instructorchoiceacceptgrades'])) {
1789         $type->lti_instructorchoiceacceptgrades = $config['instructorchoiceacceptgrades'];
1790     }
1791     if (isset($config['allowroster'])) {
1792         $type->lti_allowroster = $config['allowroster'];
1793     }
1794     if (isset($config['instructorchoiceallowroster'])) {
1795         $type->lti_instructorchoiceallowroster = $config['instructorchoiceallowroster'];
1796     }
1797
1798     if (isset($config['customparameters'])) {
1799         $type->lti_customparameters = $config['customparameters'];
1800     }
1801
1802     if (isset($config['forcessl'])) {
1803         $type->lti_forcessl = $config['forcessl'];
1804     }
1805
1806     if (isset($config['organizationid'])) {
1807         $type->lti_organizationid = $config['organizationid'];
1808     }
1809     if (isset($config['organizationurl'])) {
1810         $type->lti_organizationurl = $config['organizationurl'];
1811     }
1812     if (isset($config['organizationdescr'])) {
1813         $type->lti_organizationdescr = $config['organizationdescr'];
1814     }
1815     if (isset($config['launchcontainer'])) {
1816         $type->lti_launchcontainer = $config['launchcontainer'];
1817     }
1818
1819     if (isset($config['coursevisible'])) {
1820         $type->lti_coursevisible = $config['coursevisible'];
1821     }
1822
1823     if (isset($config['contentitem'])) {
1824         $type->lti_contentitem = $config['contentitem'];
1825     }
1826
1827     if (isset($config['debuglaunch'])) {
1828         $type->lti_debuglaunch = $config['debuglaunch'];
1829     }
1830
1831     if (isset($config['module_class_type'])) {
1832         $type->lti_module_class_type = $config['module_class_type'];
1833     }
1834
1835     return $type;
1836 }
1837
1838 function lti_prepare_type_for_save($type, $config) {
1839     if (isset($config->lti_toolurl)) {
1840         $type->baseurl = $config->lti_toolurl;
1841         $type->tooldomain = lti_get_domain_from_url($config->lti_toolurl);
1842     }
1843     if (isset($config->lti_description)) {
1844         $type->description = $config->lti_description;
1845     }
1846     if (isset($config->lti_typename)) {
1847         $type->name = $config->lti_typename;
1848     }
1849     if (isset($config->lti_coursevisible)) {
1850         $type->coursevisible = $config->lti_coursevisible;
1851     }
1852
1853     if (isset($config->lti_icon)) {
1854         $type->icon = $config->lti_icon;
1855     }
1856     if (isset($config->lti_secureicon)) {
1857         $type->secureicon = $config->lti_secureicon;
1858     }
1859
1860     $type->forcessl = !empty($config->lti_forcessl) ? $config->lti_forcessl : 0;
1861     $config->lti_forcessl = $type->forcessl;
1862     if (isset($config->lti_contentitem)) {
1863         $type->contentitem = !empty($config->lti_contentitem) ? $config->lti_contentitem : 0;
1864         $config->lti_contentitem = $type->contentitem;
1865     }
1866
1867     $type->timemodified = time();
1868
1869     unset ($config->lti_typename);
1870     unset ($config->lti_toolurl);
1871     unset ($config->lti_description);
1872     unset ($config->lti_icon);
1873     unset ($config->lti_secureicon);
1874 }
1875
1876 function lti_update_type($type, $config) {
1877     global $DB, $CFG;
1878
1879     lti_prepare_type_for_save($type, $config);
1880
1881     $clearcache = false;
1882     if (lti_request_is_using_ssl() && !empty($type->secureicon)) {
1883         $clearcache = !isset($config->oldicon) || ($config->oldicon !== $type->secureicon);
1884     } else {
1885         $clearcache = isset($type->icon) && (!isset($config->oldicon) || ($config->oldicon !== $type->icon));
1886     }
1887     unset($config->oldicon);
1888
1889     if ($DB->update_record('lti_types', $type)) {
1890         foreach ($config as $key => $value) {
1891             if (substr($key, 0, 4) == 'lti_' && !is_null($value)) {
1892                 $record = new \StdClass();
1893                 $record->typeid = $type->id;
1894                 $record->name = substr($key, 4);
1895                 $record->value = $value;
1896                 lti_update_config($record);
1897             }
1898         }
1899         require_once($CFG->libdir.'/modinfolib.php');
1900         if ($clearcache) {
1901             $sql = "SELECT DISTINCT course
1902                       FROM {lti}
1903                      WHERE typeid = ?";
1904
1905             $courses = $DB->get_fieldset_sql($sql, array($type->id));
1906
1907             foreach ($courses as $courseid) {
1908                 rebuild_course_cache($courseid, true);
1909             }
1910         }
1911     }
1912 }
1913
1914 function lti_add_type($type, $config) {
1915     global $USER, $SITE, $DB;
1916
1917     lti_prepare_type_for_save($type, $config);
1918
1919     if (!isset($type->state)) {
1920         $type->state = LTI_TOOL_STATE_PENDING;
1921     }
1922
1923     if (!isset($type->timecreated)) {
1924         $type->timecreated = time();
1925     }
1926
1927     if (!isset($type->createdby)) {
1928         $type->createdby = $USER->id;
1929     }
1930
1931     if (!isset($type->course)) {
1932         $type->course = $SITE->id;
1933     }
1934
1935     // Create a salt value to be used for signing passed data to extension services
1936     // The outcome service uses the service salt on the instance. This can be used
1937     // for communication with services not related to a specific LTI instance.
1938     $config->lti_servicesalt = uniqid('', true);
1939
1940     $id = $DB->insert_record('lti_types', $type);
1941
1942     if ($id) {
1943         foreach ($config as $key => $value) {
1944             if (substr($key, 0, 4) == 'lti_' && !is_null($value)) {
1945                 $record = new \StdClass();
1946                 $record->typeid = $id;
1947                 $record->name = substr($key, 4);
1948                 $record->value = $value;
1949
1950                 lti_add_config($record);
1951             }
1952         }
1953     }
1954
1955     return $id;
1956 }
1957
1958 /**
1959  * Given an array of tool proxies, filter them based on their state
1960  *
1961  * @param array $toolproxies An array of lti_tool_proxies records
1962  * @param int $state One of the LTI_TOOL_PROXY_STATE_* constants
1963  *
1964  * @return array
1965  */
1966 function lti_filter_tool_proxy_types(array $toolproxies, $state) {
1967     $return = array();
1968     foreach ($toolproxies as $key => $toolproxy) {
1969         if ($toolproxy->state == $state) {
1970             $return[$key] = $toolproxy;
1971         }
1972     }
1973     return $return;
1974 }
1975
1976 /**
1977  * Get the tool proxy instance given its GUID
1978  *
1979  * @param string  $toolproxyguid   Tool proxy GUID value
1980  *
1981  * @return object
1982  */
1983 function lti_get_tool_proxy_from_guid($toolproxyguid) {
1984     global $DB;
1985
1986     $toolproxy = $DB->get_record('lti_tool_proxies', array('guid' => $toolproxyguid));
1987
1988     return $toolproxy;
1989 }
1990
1991 /**
1992  * Get the tool proxy instance given its registration URL
1993  *
1994  * @param string $regurl Tool proxy registration URL
1995  *
1996  * @return array The record of the tool proxy with this url
1997  */
1998 function lti_get_tool_proxies_from_registration_url($regurl) {
1999     global $DB;
2000
2001     return $DB->get_records_sql(
2002         'SELECT * FROM {lti_tool_proxies}
2003         WHERE '.$DB->sql_compare_text('regurl', 256).' = :regurl',
2004         array('regurl' => $regurl)
2005     );
2006 }
2007
2008 /**
2009  * Generates some of the tool proxy configuration based on the admin configuration details
2010  *
2011  * @param int $id
2012  *
2013  * @return Tool Proxy details
2014  */
2015 function lti_get_tool_proxy($id) {
2016     global $DB;
2017
2018     $toolproxy = $DB->get_record('lti_tool_proxies', array('id' => $id));
2019     return $toolproxy;
2020 }
2021
2022 /**
2023  * Returns lti tool proxies.
2024  *
2025  * @param bool $orphanedonly Only retrieves tool proxies that have no type associated with them
2026  * @return array of basicLTI types
2027  */
2028 function lti_get_tool_proxies($orphanedonly) {
2029     global $DB;
2030
2031     if ($orphanedonly) {
2032         $tools = $DB->get_records('lti_types');
2033         $usedproxyids = array_values($DB->get_fieldset_select('lti_types', 'toolproxyid', 'toolproxyid IS NOT NULL'));
2034         $proxies = $DB->get_records('lti_tool_proxies', null, 'state DESC, timemodified DESC');
2035         foreach ($proxies as $key => $value) {
2036             if (in_array($value->id, $usedproxyids)) {
2037                 unset($proxies[$key]);
2038             }
2039         }
2040         return $proxies;
2041     } else {
2042         return $DB->get_records('lti_tool_proxies', null, 'state DESC, timemodified DESC');
2043     }
2044 }
2045
2046 /**
2047  * Generates some of the tool proxy configuration based on the admin configuration details
2048  *
2049  * @param int $id
2050  *
2051  * @return Tool Proxy details
2052  */
2053 function lti_get_tool_proxy_config($id) {
2054     $toolproxy = lti_get_tool_proxy($id);
2055
2056     $tp = new \stdClass();
2057     $tp->lti_registrationname = $toolproxy->name;
2058     $tp->toolproxyid = $toolproxy->id;
2059     $tp->state = $toolproxy->state;
2060     $tp->lti_registrationurl = $toolproxy->regurl;
2061     $tp->lti_capabilities = explode("\n", $toolproxy->capabilityoffered);
2062     $tp->lti_services = explode("\n", $toolproxy->serviceoffered);
2063
2064     return $tp;
2065 }
2066
2067 /**
2068  * Update the database with a tool proxy instance
2069  *
2070  * @param object   $config    Tool proxy definition
2071  *
2072  * @return int  Record id number
2073  */
2074 function lti_add_tool_proxy($config) {
2075     global $USER, $DB;
2076
2077     $toolproxy = new \stdClass();
2078     if (isset($config->lti_registrationname)) {
2079         $toolproxy->name = trim($config->lti_registrationname);
2080     }
2081     if (isset($config->lti_registrationurl)) {
2082         $toolproxy->regurl = trim($config->lti_registrationurl);
2083     }
2084     if (isset($config->lti_capabilities)) {
2085         $toolproxy->capabilityoffered = implode("\n", $config->lti_capabilities);
2086     } else {
2087         $toolproxy->capabilityoffered = implode("\n", array_keys(lti_get_capabilities()));
2088     }
2089     if (isset($config->lti_services)) {
2090         $toolproxy->serviceoffered = implode("\n", $config->lti_services);
2091     } else {
2092         $func = function($s) {
2093             return $s->get_id();
2094         };
2095         $servicenames = array_map($func, lti_get_services());
2096         $toolproxy->serviceoffered = implode("\n", $servicenames);
2097     }
2098     if (isset($config->toolproxyid) && !empty($config->toolproxyid)) {
2099         $toolproxy->id = $config->toolproxyid;
2100         if (!isset($toolproxy->state) || ($toolproxy->state != LTI_TOOL_PROXY_STATE_ACCEPTED)) {
2101             $toolproxy->state = LTI_TOOL_PROXY_STATE_CONFIGURED;
2102             $toolproxy->guid = random_string();
2103             $toolproxy->secret = random_string();
2104         }
2105         $id = lti_update_tool_proxy($toolproxy);
2106     } else {
2107         $toolproxy->state = LTI_TOOL_PROXY_STATE_CONFIGURED;
2108         $toolproxy->timemodified = time();
2109         $toolproxy->timecreated = $toolproxy->timemodified;
2110         if (!isset($toolproxy->createdby)) {
2111             $toolproxy->createdby = $USER->id;
2112         }
2113         $toolproxy->guid = random_string();
2114         $toolproxy->secret = random_string();
2115         $id = $DB->insert_record('lti_tool_proxies', $toolproxy);
2116     }
2117
2118     return $id;
2119 }
2120
2121 /**
2122  * Updates a tool proxy in the database
2123  *
2124  * @param object  $toolproxy   Tool proxy
2125  *
2126  * @return int    Record id number
2127  */
2128 function lti_update_tool_proxy($toolproxy) {
2129     global $DB;
2130
2131     $toolproxy->timemodified = time();
2132     $id = $DB->update_record('lti_tool_proxies', $toolproxy);
2133
2134     return $id;
2135 }
2136
2137 /**
2138  * Delete a Tool Proxy
2139  *
2140  * @param int $id   Tool Proxy id
2141  */
2142 function lti_delete_tool_proxy($id) {
2143     global $DB;
2144     $DB->delete_records('lti_tool_settings', array('toolproxyid' => $id));
2145     $tools = $DB->get_records('lti_types', array('toolproxyid' => $id));
2146     foreach ($tools as $tool) {
2147         lti_delete_type($tool->id);
2148     }
2149     $DB->delete_records('lti_tool_proxies', array('id' => $id));
2150 }
2151
2152 /**
2153  * Add a tool configuration in the database
2154  *
2155  * @param object $config   Tool configuration
2156  *
2157  * @return int Record id number
2158  */
2159 function lti_add_config($config) {
2160     global $DB;
2161
2162     return $DB->insert_record('lti_types_config', $config);
2163 }
2164
2165 /**
2166  * Updates a tool configuration in the database
2167  *
2168  * @param object  $config   Tool configuration
2169  *
2170  * @return Record id number
2171  */
2172 function lti_update_config($config) {
2173     global $DB;
2174
2175     $return = true;
2176     $old = $DB->get_record('lti_types_config', array('typeid' => $config->typeid, 'name' => $config->name));
2177
2178     if ($old) {
2179         $config->id = $old->id;
2180         $return = $DB->update_record('lti_types_config', $config);
2181     } else {
2182         $return = $DB->insert_record('lti_types_config', $config);
2183     }
2184     return $return;
2185 }
2186
2187 /**
2188  * Gets the tool settings
2189  *
2190  * @param int  $toolproxyid   Id of tool proxy record
2191  * @param int  $courseid      Id of course (null if system settings)
2192  * @param int  $instanceid    Id of course module (null if system or context settings)
2193  *
2194  * @return array  Array settings
2195  */
2196 function lti_get_tool_settings($toolproxyid, $courseid = null, $instanceid = null) {
2197     global $DB;
2198
2199     $settings = array();
2200     $settingsstr = $DB->get_field('lti_tool_settings', 'settings', array('toolproxyid' => $toolproxyid,
2201         'course' => $courseid, 'coursemoduleid' => $instanceid));
2202     if ($settingsstr !== false) {
2203         $settings = json_decode($settingsstr, true);
2204     }
2205     return $settings;
2206 }
2207
2208 /**
2209  * Sets the tool settings (
2210  *
2211  * @param array  $settings      Array of settings
2212  * @param int    $toolproxyid   Id of tool proxy record
2213  * @param int    $courseid      Id of course (null if system settings)
2214  * @param int    $instanceid    Id of course module (null if system or context settings)
2215  */
2216 function lti_set_tool_settings($settings, $toolproxyid, $courseid = null, $instanceid = null) {
2217     global $DB;
2218
2219     $json = json_encode($settings);
2220     $record = $DB->get_record('lti_tool_settings', array('toolproxyid' => $toolproxyid,
2221         'course' => $courseid, 'coursemoduleid' => $instanceid));
2222     if ($record !== false) {
2223         $DB->update_record('lti_tool_settings', array('id' => $record->id, 'settings' => $json, 'timemodified' => time()));
2224     } else {
2225         $record = new \stdClass();
2226         $record->toolproxyid = $toolproxyid;
2227         $record->course = $courseid;
2228         $record->coursemoduleid = $instanceid;
2229         $record->settings = $json;
2230         $record->timecreated = time();
2231         $record->timemodified = $record->timecreated;
2232         $DB->insert_record('lti_tool_settings', $record);
2233     }
2234 }
2235
2236 /**
2237  * Signs the petition to launch the external tool using OAuth
2238  *
2239  * @param $oldparms     Parameters to be passed for signing
2240  * @param $endpoint     url of the external tool
2241  * @param $method       Method for sending the parameters (e.g. POST)
2242  * @param $oauth_consumoer_key          Key
2243  * @param $oauth_consumoer_secret       Secret
2244  */
2245 function lti_sign_parameters($oldparms, $endpoint, $method, $oauthconsumerkey, $oauthconsumersecret) {
2246
2247     $parms = $oldparms;
2248
2249     $testtoken = '';
2250
2251     // TODO: Switch to core oauthlib once implemented - MDL-30149.
2252     $hmacmethod = new lti\OAuthSignatureMethod_HMAC_SHA1();
2253     $testconsumer = new lti\OAuthConsumer($oauthconsumerkey, $oauthconsumersecret, null);
2254     $accreq = lti\OAuthRequest::from_consumer_and_token($testconsumer, $testtoken, $method, $endpoint, $parms);
2255     $accreq->sign_request($hmacmethod, $testconsumer, $testtoken);
2256
2257     $newparms = $accreq->get_parameters();
2258
2259     return $newparms;
2260 }
2261
2262 /**
2263  * Posts the launch petition HTML
2264  *
2265  * @param $newparms     Signed parameters
2266  * @param $endpoint     URL of the external tool
2267  * @param $debug        Debug (true/false)
2268  */
2269 function lti_post_launch_html($newparms, $endpoint, $debug=false) {
2270     $r = "<form action=\"" . $endpoint .
2271         "\" name=\"ltiLaunchForm\" id=\"ltiLaunchForm\" method=\"post\" encType=\"application/x-www-form-urlencoded\">\n";
2272
2273     // Contruct html for the launch parameters.
2274     foreach ($newparms as $key => $value) {
2275         $key = htmlspecialchars($key);
2276         $value = htmlspecialchars($value);
2277         if ( $key == "ext_submit" ) {
2278             $r .= "<input type=\"submit\"";
2279         } else {
2280             $r .= "<input type=\"hidden\" name=\"{$key}\"";
2281         }
2282         $r .= " value=\"";
2283         $r .= $value;
2284         $r .= "\"/>\n";
2285     }
2286
2287     if ( $debug ) {
2288         $r .= "<script language=\"javascript\"> \n";
2289         $r .= "  //<![CDATA[ \n";
2290         $r .= "function basicltiDebugToggle() {\n";
2291         $r .= "    var ele = document.getElementById(\"basicltiDebug\");\n";
2292         $r .= "    if (ele.style.display == \"block\") {\n";
2293         $r .= "        ele.style.display = \"none\";\n";
2294         $r .= "    }\n";
2295         $r .= "    else {\n";
2296         $r .= "        ele.style.display = \"block\";\n";
2297         $r .= "    }\n";
2298         $r .= "} \n";
2299         $r .= "  //]]> \n";
2300         $r .= "</script>\n";
2301         $r .= "<a id=\"displayText\" href=\"javascript:basicltiDebugToggle();\">";
2302         $r .= get_string("toggle_debug_data", "lti")."</a>\n";
2303         $r .= "<div id=\"basicltiDebug\" style=\"display:none\">\n";
2304         $r .= "<b>".get_string("basiclti_endpoint", "lti")."</b><br/>\n";
2305         $r .= $endpoint . "<br/>\n&nbsp;<br/>\n";
2306         $r .= "<b>".get_string("basiclti_parameters", "lti")."</b><br/>\n";
2307         foreach ($newparms as $key => $value) {
2308             $key = htmlspecialchars($key);
2309             $value = htmlspecialchars($value);
2310             $r .= "$key = $value<br/>\n";
2311         }
2312         $r .= "&nbsp;<br/>\n";
2313         $r .= "</div>\n";
2314     }
2315     $r .= "</form>\n";
2316
2317     if ( ! $debug ) {
2318         $r .= " <script type=\"text/javascript\"> \n" .
2319             "  //<![CDATA[ \n" .
2320             "    document.ltiLaunchForm.submit(); \n" .
2321             "  //]]> \n" .
2322             " </script> \n";
2323     }
2324     return $r;
2325 }
2326
2327 function lti_get_type($typeid) {
2328     global $DB;
2329
2330     return $DB->get_record('lti_types', array('id' => $typeid));
2331 }
2332
2333 function lti_get_launch_container($lti, $toolconfig) {
2334     if (empty($lti->launchcontainer)) {
2335         $lti->launchcontainer = LTI_LAUNCH_CONTAINER_DEFAULT;
2336     }
2337
2338     if ($lti->launchcontainer == LTI_LAUNCH_CONTAINER_DEFAULT) {
2339         if (isset($toolconfig['launchcontainer'])) {
2340             $launchcontainer = $toolconfig['launchcontainer'];
2341         }
2342     } else {
2343         $launchcontainer = $lti->launchcontainer;
2344     }
2345
2346     if (empty($launchcontainer) || $launchcontainer == LTI_LAUNCH_CONTAINER_DEFAULT) {
2347         $launchcontainer = LTI_LAUNCH_CONTAINER_EMBED_NO_BLOCKS;
2348     }
2349
2350     $devicetype = core_useragent::get_device_type();
2351
2352     // Scrolling within the object element doesn't work on iOS or Android
2353     // Opening the popup window also had some issues in testing
2354     // For mobile devices, always take up the entire screen to ensure the best experience.
2355     if ($devicetype === core_useragent::DEVICETYPE_MOBILE || $devicetype === core_useragent::DEVICETYPE_TABLET ) {
2356         $launchcontainer = LTI_LAUNCH_CONTAINER_REPLACE_MOODLE_WINDOW;
2357     }
2358
2359     return $launchcontainer;
2360 }
2361
2362 function lti_request_is_using_ssl() {
2363     global $CFG;
2364     return (stripos($CFG->httpswwwroot, 'https://') === 0);
2365 }
2366
2367 function lti_ensure_url_is_https($url) {
2368     if (!strstr($url, '://')) {
2369         $url = 'https://' . $url;
2370     } else {
2371         // If the URL starts with http, replace with https.
2372         if (stripos($url, 'http://') === 0) {
2373             $url = 'https://' . substr($url, 7);
2374         }
2375     }
2376
2377     return $url;
2378 }
2379
2380 /**
2381  * Determines if we should try to log the request
2382  *
2383  * @param string $rawbody
2384  * @return bool
2385  */
2386 function lti_should_log_request($rawbody) {
2387     global $CFG;
2388
2389     if (empty($CFG->mod_lti_log_users)) {
2390         return false;
2391     }
2392
2393     $logusers = explode(',', $CFG->mod_lti_log_users);
2394     if (empty($logusers)) {
2395         return false;
2396     }
2397
2398     try {
2399         $xml = new \SimpleXMLElement($rawbody);
2400         $ns  = $xml->getNamespaces();
2401         $ns  = array_shift($ns);
2402         $xml->registerXPathNamespace('lti', $ns);
2403         $requestuserid = '';
2404         if ($node = $xml->xpath('//lti:userId')) {
2405             $node = $node[0];
2406             $requestuserid = clean_param((string) $node, PARAM_INT);
2407         } else if ($node = $xml->xpath('//lti:sourcedId')) {
2408             $node = $node[0];
2409             $resultjson = json_decode((string) $node);
2410             $requestuserid = clean_param($resultjson->data->userid, PARAM_INT);
2411         }
2412     } catch (Exception $e) {
2413         return false;
2414     }
2415
2416     if (empty($requestuserid) or !in_array($requestuserid, $logusers)) {
2417         return false;
2418     }
2419
2420     return true;
2421 }
2422
2423 /**
2424  * Logs the request to a file in temp dir.
2425  *
2426  * @param string $rawbody
2427  */
2428 function lti_log_request($rawbody) {
2429     if ($tempdir = make_temp_directory('mod_lti', false)) {
2430         if ($tempfile = tempnam($tempdir, 'mod_lti_request'.date('YmdHis'))) {
2431             $content  = "Request Headers:\n";
2432             foreach (moodle\mod\lti\OAuthUtil::get_headers() as $header => $value) {
2433                 $content .= "$header: $value\n";
2434             }
2435             $content .= "Request Body:\n";
2436             $content .= $rawbody;
2437
2438             file_put_contents($tempfile, $content);
2439             chmod($tempfile, 0644);
2440         }
2441     }
2442 }
2443
2444 /**
2445  * Log an LTI response.
2446  *
2447  * @param string $responsexml The response XML
2448  * @param Exception $e If there was an exception, pass that too
2449  */
2450 function lti_log_response($responsexml, $e = null) {
2451     if ($tempdir = make_temp_directory('mod_lti', false)) {
2452         if ($tempfile = tempnam($tempdir, 'mod_lti_response'.date('YmdHis'))) {
2453             $content = '';
2454             if ($e instanceof Exception) {
2455                 $info = get_exception_info($e);
2456
2457                 $content .= "Exception:\n";
2458                 $content .= "Message: $info->message\n";
2459                 $content .= "Debug info: $info->debuginfo\n";
2460                 $content .= "Backtrace:\n";
2461                 $content .= format_backtrace($info->backtrace, true);
2462                 $content .= "\n";
2463             }
2464             $content .= "Response XML:\n";
2465             $content .= $responsexml;
2466
2467             file_put_contents($tempfile, $content);
2468             chmod($tempfile, 0644);
2469         }
2470     }
2471 }
2472
2473 /**
2474  * Fetches LTI type configuration for an LTI instance
2475  *
2476  * @param stdClass $instance
2477  * @return array Can be empty if no type is found
2478  */
2479 function lti_get_type_config_by_instance($instance) {
2480     $typeid = null;
2481     if (empty($instance->typeid)) {
2482         $tool = lti_get_tool_by_url_match($instance->toolurl, $instance->course);
2483         if ($tool) {
2484             $typeid = $tool->id;
2485         }
2486     } else {
2487         $typeid = $instance->typeid;
2488     }
2489     if (!empty($typeid)) {
2490         return lti_get_type_config($typeid);
2491     }
2492     return array();
2493 }
2494
2495 /**
2496  * Enforce type config settings onto the LTI instance
2497  *
2498  * @param stdClass $instance
2499  * @param array $typeconfig
2500  */
2501 function lti_force_type_config_settings($instance, array $typeconfig) {
2502     $forced = array(
2503         'instructorchoicesendname'      => 'sendname',
2504         'instructorchoicesendemailaddr' => 'sendemailaddr',
2505         'instructorchoiceacceptgrades'  => 'acceptgrades',
2506     );
2507
2508     foreach ($forced as $instanceparam => $typeconfigparam) {
2509         if (array_key_exists($typeconfigparam, $typeconfig) && $typeconfig[$typeconfigparam] != LTI_SETTING_DELEGATE) {
2510             $instance->$instanceparam = $typeconfig[$typeconfigparam];
2511         }
2512     }
2513 }
2514
2515 /**
2516  * Initializes an array with the capabilities supported by the LTI module
2517  *
2518  * @return array List of capability names (without a dollar sign prefix)
2519  */
2520 function lti_get_capabilities() {
2521
2522     $capabilities = array(
2523        'basic-lti-launch-request' => '',
2524        'ContentItemSelectionRequest' => '',
2525        'ToolProxyRegistrationRequest' => '',
2526        'Context.id' => 'context_id',
2527        'Context.title' => 'context_title',
2528        'Context.label' => 'context_label',
2529        'Context.sourcedId' => 'lis_course_section_sourcedid',
2530        'Context.longDescription' => '$COURSE->summary',
2531        'Context.timeFrame.begin' => '$COURSE->startdate',
2532        'CourseSection.title' => 'context_title',
2533        'CourseSection.label' => 'context_label',
2534        'CourseSection.sourcedId' => 'lis_course_section_sourcedid',
2535        'CourseSection.longDescription' => '$COURSE->summary',
2536        'CourseSection.timeFrame.begin' => '$COURSE->startdate',
2537        'ResourceLink.id' => 'resource_link_id',
2538        'ResourceLink.title' => 'resource_link_title',
2539        'ResourceLink.description' => 'resource_link_description',
2540        'User.id' => 'user_id',
2541        'User.username' => '$USER->username',
2542        'Person.name.full' => 'lis_person_name_full',
2543        'Person.name.given' => 'lis_person_name_given',
2544        'Person.name.family' => 'lis_person_name_family',
2545        'Person.email.primary' => 'lis_person_contact_email_primary',
2546        'Person.sourcedId' => 'lis_person_sourcedid',
2547        'Person.name.middle' => '$USER->middlename',
2548        'Person.address.street1' => '$USER->address',
2549        'Person.address.locality' => '$USER->city',
2550        'Person.address.country' => '$USER->country',
2551        'Person.address.timezone' => '$USER->timezone',
2552        'Person.phone.primary' => '$USER->phone1',
2553        'Person.phone.mobile' => '$USER->phone2',
2554        'Person.webaddress' => '$USER->url',
2555        'Membership.role' => 'roles',
2556        'Result.sourcedId' => 'lis_result_sourcedid',
2557        'Result.autocreate' => 'lis_outcome_service_url');
2558
2559     return $capabilities;
2560
2561 }
2562
2563 /**
2564  * Initializes an array with the services supported by the LTI module
2565  *
2566  * @return array List of services
2567  */
2568 function lti_get_services() {
2569
2570     $services = array();
2571     $definedservices = core_component::get_plugin_list('ltiservice');
2572     foreach ($definedservices as $name => $location) {
2573         $classname = "\\ltiservice_{$name}\\local\\service\\{$name}";
2574         $services[] = new $classname();
2575     }
2576
2577     return $services;
2578
2579 }
2580
2581 /**
2582  * Initializes an instance of the named service
2583  *
2584  * @param string $servicename Name of service
2585  *
2586  * @return mod_lti\local\ltiservice\service_base Service
2587  */
2588 function lti_get_service_by_name($servicename) {
2589
2590     $service = false;
2591     $classname = "\\ltiservice_{$servicename}\\local\\service\\{$servicename}";
2592     if (class_exists($classname)) {
2593         $service = new $classname();
2594     }
2595
2596     return $service;
2597
2598 }
2599
2600 /**
2601  * Finds a service by id
2602  *
2603  * @param array  $services    Array of services
2604  * @param string $resourceid  ID of resource
2605  *
2606  * @return mod_lti\local\ltiservice\service_base Service
2607  */
2608 function lti_get_service_by_resource_id($services, $resourceid) {
2609
2610     $service = false;
2611     foreach ($services as $aservice) {
2612         foreach ($aservice->get_resources() as $resource) {
2613             if ($resource->get_id() === $resourceid) {
2614                 $service = $aservice;
2615                 break 2;
2616             }
2617         }
2618     }
2619
2620     return $service;
2621
2622 }
2623
2624 /**
2625  * Extracts the named contexts from a tool proxy
2626  *
2627  * @param object $json
2628  *
2629  * @return array Contexts
2630  */
2631 function lti_get_contexts($json) {
2632
2633     $contexts = array();
2634     if (isset($json->{'@context'})) {
2635         foreach ($json->{'@context'} as $context) {
2636             if (is_object($context)) {
2637                 $contexts = array_merge(get_object_vars($context), $contexts);
2638             }
2639         }
2640     }
2641
2642     return $contexts;
2643
2644 }
2645
2646 /**
2647  * Converts an ID to a fully-qualified ID
2648  *
2649  * @param array $contexts
2650  * @param string $id
2651  *
2652  * @return string Fully-qualified ID
2653  */
2654 function lti_get_fqid($contexts, $id) {
2655
2656     $parts = explode(':', $id, 2);
2657     if (count($parts) > 1) {
2658         if (array_key_exists($parts[0], $contexts)) {
2659             $id = $contexts[$parts[0]] . $parts[1];
2660         }
2661     }
2662
2663     return $id;
2664
2665 }
2666
2667 /**
2668  * Returns the icon for the given tool type
2669  *
2670  * @param stdClass $type The tool type
2671  *
2672  * @return string The url to the tool type's corresponding icon
2673  */
2674 function get_tool_type_icon_url(stdClass $type) {
2675     global $OUTPUT;
2676
2677     $iconurl = $type->secureicon;
2678
2679     if (empty($iconurl)) {
2680         $iconurl = $type->icon;
2681     }
2682
2683     if (empty($iconurl)) {
2684         $iconurl = $OUTPUT->image_url('icon', 'lti')->out();
2685     }
2686
2687     return $iconurl;
2688 }
2689
2690 /**
2691  * Returns the edit url for the given tool type
2692  *
2693  * @param stdClass $type The tool type
2694  *
2695  * @return string The url to edit the tool type
2696  */
2697 function get_tool_type_edit_url(stdClass $type) {
2698     $url = new moodle_url('/mod/lti/typessettings.php',
2699                           array('action' => 'update', 'id' => $type->id, 'sesskey' => sesskey(), 'returnto' => 'toolconfigure'));
2700     return $url->out();
2701 }
2702
2703 /**
2704  * Returns the edit url for the given tool proxy.
2705  *
2706  * @param stdClass $proxy The tool proxy
2707  *
2708  * @return string The url to edit the tool type
2709  */
2710 function get_tool_proxy_edit_url(stdClass $proxy) {
2711     $url = new moodle_url('/mod/lti/registersettings.php',
2712                           array('action' => 'update', 'id' => $proxy->id, 'sesskey' => sesskey(), 'returnto' => 'toolconfigure'));
2713     return $url->out();
2714 }
2715
2716 /**
2717  * Returns the course url for the given tool type
2718  *
2719  * @param stdClass $type The tool type
2720  *
2721  * @return string|void The url to the course of the tool type, void if it is a site wide type
2722  */
2723 function get_tool_type_course_url(stdClass $type) {
2724     if ($type->course == 1) {
2725         return;
2726     } else {
2727         $url = new moodle_url('/course/view.php', array('id' => $type->course));
2728         return $url->out();
2729     }
2730 }
2731
2732 /**
2733  * Returns the icon and edit urls for the tool type and the course url if it is a course type.
2734  *
2735  * @param stdClass $type The tool type
2736  *
2737  * @return string The urls of the tool type
2738  */
2739 function get_tool_type_urls(stdClass $type) {
2740     $courseurl = get_tool_type_course_url($type);
2741
2742     $urls = array(
2743         'icon' => get_tool_type_icon_url($type),
2744         'edit' => get_tool_type_edit_url($type),
2745     );
2746
2747     if ($courseurl) {
2748         $urls['course'] = $courseurl;
2749     }
2750
2751     return $urls;
2752 }
2753
2754 /**
2755  * Returns the icon and edit urls for the tool proxy.
2756  *
2757  * @param stdClass $proxy The tool proxy
2758  *
2759  * @return string The urls of the tool proxy
2760  */
2761 function get_tool_proxy_urls(stdClass $proxy) {
2762     global $OUTPUT;
2763
2764     $urls = array(
2765         'icon' => $OUTPUT->image_url('icon', 'lti')->out(),
2766         'edit' => get_tool_proxy_edit_url($proxy),
2767     );
2768
2769     return $urls;
2770 }
2771
2772 /**
2773  * Returns information on the current state of the tool type
2774  *
2775  * @param stdClass $type The tool type
2776  *
2777  * @return array An array with a text description of the state, and boolean for whether it is in each state:
2778  * pending, configured, rejected, unknown
2779  */
2780 function get_tool_type_state_info(stdClass $type) {
2781     $state = '';
2782     $isconfigured = false;
2783     $ispending = false;
2784     $isrejected = false;
2785     $isunknown = false;
2786     switch ($type->state) {
2787         case LTI_TOOL_STATE_CONFIGURED:
2788             $state = get_string('active', 'mod_lti');
2789             $isconfigured = true;
2790             break;
2791         case LTI_TOOL_STATE_PENDING:
2792             $state = get_string('pending', 'mod_lti');
2793             $ispending = true;
2794             break;
2795         case LTI_TOOL_STATE_REJECTED:
2796             $state = get_string('rejected', 'mod_lti');
2797             $isrejected = true;
2798             break;
2799         default:
2800             $state = get_string('unknownstate', 'mod_lti');
2801             $isunknown = true;
2802             break;
2803     }
2804
2805     return array(
2806         'text' => $state,
2807         'pending' => $ispending,
2808         'configured' => $isconfigured,
2809         'rejected' => $isrejected,
2810         'unknown' => $isunknown
2811     );
2812 }
2813
2814 /**
2815  * Returns a summary of each LTI capability this tool type requires in plain language
2816  *
2817  * @param stdClass $type The tool type
2818  *
2819  * @return array An array of text descriptions of each of the capabilities this tool type requires
2820  */
2821 function get_tool_type_capability_groups($type) {
2822     $capabilities = lti_get_enabled_capabilities($type);
2823     $groups = array();
2824     $hascourse = false;
2825     $hasactivities = false;
2826     $hasuseraccount = false;
2827     $hasuserpersonal = false;
2828
2829     foreach ($capabilities as $capability) {
2830         // Bail out early if we've already found all groups.
2831         if (count($groups) >= 4) {
2832             continue;
2833         }
2834
2835         if (!$hascourse && preg_match('/^CourseSection/', $capability)) {
2836             $hascourse = true;
2837             $groups[] = get_string('courseinformation', 'mod_lti');
2838         } else if (!$hasactivities && preg_match('/^ResourceLink/', $capability)) {
2839             $hasactivities = true;
2840             $groups[] = get_string('courseactivitiesorresources', 'mod_lti');
2841         } else if (!$hasuseraccount && preg_match('/^User/', $capability) || preg_match('/^Membership/', $capability)) {
2842             $hasuseraccount = true;
2843             $groups[] = get_string('useraccountinformation', 'mod_lti');
2844         } else if (!$hasuserpersonal && preg_match('/^Person/', $capability)) {
2845             $hasuserpersonal = true;
2846             $groups[] = get_string('userpersonalinformation', 'mod_lti');
2847         }
2848     }
2849
2850     return $groups;
2851 }
2852
2853
2854 /**
2855  * Returns the ids of each instance of this tool type
2856  *
2857  * @param stdClass $type The tool type
2858  *
2859  * @return array An array of ids of the instances of this tool type
2860  */
2861 function get_tool_type_instance_ids($type) {
2862     global $DB;
2863
2864     return array_keys($DB->get_fieldset_select('lti', 'id', 'typeid = ?', array($type->id)));
2865 }
2866
2867 /**
2868  * Serialises this tool type
2869  *
2870  * @param stdClass $type The tool type
2871  *
2872  * @return array An array of values representing this type
2873  */
2874 function serialise_tool_type(stdClass $type) {
2875     $capabilitygroups = get_tool_type_capability_groups($type);
2876     $instanceids = get_tool_type_instance_ids($type);
2877     // Clean the name. We don't want tags here.
2878     $name = clean_param($type->name, PARAM_NOTAGS);
2879     if (!empty($type->description)) {
2880         // Clean the description. We don't want tags here.
2881         $description = clean_param($type->description, PARAM_NOTAGS);
2882     } else {
2883         $description = get_string('editdescription', 'mod_lti');
2884     }
2885     return array(
2886         'id' => $type->id,
2887         'name' => $name,
2888         'description' => $description,
2889         'urls' => get_tool_type_urls($type),
2890         'state' => get_tool_type_state_info($type),
2891         'hascapabilitygroups' => !empty($capabilitygroups),
2892         'capabilitygroups' => $capabilitygroups,
2893         // Course ID of 1 means it's not linked to a course.
2894         'courseid' => $type->course == 1 ? 0 : $type->course,
2895         'instanceids' => $instanceids,
2896         'instancecount' => count($instanceids)
2897     );
2898 }
2899
2900 /**
2901  * Serialises this tool proxy.
2902  *
2903  * @param stdClass $proxy The tool proxy
2904  *
2905  * @return array An array of values representing this type
2906  */
2907 function serialise_tool_proxy(stdClass $proxy) {
2908     return array(
2909         'id' => $proxy->id,
2910         'name' => $proxy->name,
2911         'description' => get_string('activatetoadddescription', 'mod_lti'),
2912         'urls' => get_tool_proxy_urls($proxy),
2913         'state' => array(
2914             'text' => get_string('pending', 'mod_lti'),
2915             'pending' => true,
2916             'configured' => false,
2917             'rejected' => false,
2918             'unknown' => false
2919         ),
2920         'hascapabilitygroups' => true,
2921         'capabilitygroups' => array(),
2922         'courseid' => 0,
2923         'instanceids' => array(),
2924         'instancecount' => 0
2925     );
2926 }
2927
2928 /**
2929  * Loads the cartridge information into the tool type, if the launch url is for a cartridge file
2930  *
2931  * @param stdClass $type The tool type object to be filled in
2932  * @since Moodle 3.1
2933  */
2934 function lti_load_type_if_cartridge($type) {
2935     if (!empty($type->lti_toolurl) && lti_is_cartridge($type->lti_toolurl)) {
2936         lti_load_type_from_cartridge($type->lti_toolurl, $type);
2937     }
2938 }
2939
2940 /**
2941  * Loads the cartridge information into the new tool, if the launch url is for a cartridge file
2942  *
2943  * @param stdClass $lti The tools config
2944  * @since Moodle 3.1
2945  */
2946 function lti_load_tool_if_cartridge($lti) {
2947     if (!empty($lti->toolurl) && lti_is_cartridge($lti->toolurl)) {
2948         lti_load_tool_from_cartridge($lti->toolurl, $lti);
2949     }
2950 }
2951
2952 /**
2953  * Determines if the given url is for a IMS basic cartridge
2954  *
2955  * @param  string $url The url to be checked
2956  * @return True if the url is for a cartridge
2957  * @since Moodle 3.1
2958  */
2959 function lti_is_cartridge($url) {
2960     // If it is empty, it's not a cartridge.
2961     if (empty($url)) {
2962         return false;
2963     }
2964     // If it has xml at the end of the url, it's a cartridge.
2965     if (preg_match('/\.xml$/', $url)) {
2966         return true;
2967     }
2968     // Even if it doesn't have .xml, load the url to check if it's a cartridge..
2969     try {
2970         $toolinfo = lti_load_cartridge($url,
2971             array(
2972                 "launch_url" => "launchurl"
2973             )
2974         );
2975         if (!empty($toolinfo['launchurl'])) {
2976             return true;
2977         }
2978     } catch (moodle_exception $e) {
2979         return false; // Error loading the xml, so it's not a cartridge.
2980     }
2981     return false;
2982 }
2983
2984 /**
2985  * Allows you to load settings for an external tool type from an IMS cartridge.
2986  *
2987  * @param  string   $url     The URL to the cartridge
2988  * @param  stdClass $type    The tool type object to be filled in
2989  * @throws moodle_exception if the cartridge could not be loaded correctly
2990  * @since Moodle 3.1
2991  */
2992 function lti_load_type_from_cartridge($url, $type) {
2993     $toolinfo = lti_load_cartridge($url,
2994         array(
2995             "title" => "lti_typename",
2996             "launch_url" => "lti_toolurl",
2997             "description" => "lti_description",
2998             "icon" => "lti_icon",
2999             "secure_icon" => "lti_secureicon"
3000         ),
3001         array(
3002             "icon_url" => "lti_extension_icon",
3003             "secure_icon_url" => "lti_extension_secureicon"
3004         )
3005     );
3006     // If an activity name exists, unset the cartridge name so we don't override it.
3007     if (isset($type->lti_typename)) {
3008         unset($toolinfo['lti_typename']);
3009     }
3010
3011     // Always prefer cartridge core icons first, then, if none are found, look at the extension icons.
3012     if (empty($toolinfo['lti_icon']) && !empty($toolinfo['lti_extension_icon'])) {
3013         $toolinfo['lti_icon'] = $toolinfo['lti_extension_icon'];
3014     }
3015     unset($toolinfo['lti_extension_icon']);
3016
3017     if (empty($toolinfo['lti_secureicon']) && !empty($toolinfo['lti_extension_secureicon'])) {
3018         $toolinfo['lti_secureicon'] = $toolinfo['lti_extension_secureicon'];
3019     }
3020     unset($toolinfo['lti_extension_secureicon']);
3021
3022     foreach ($toolinfo as $property => $value) {
3023         $type->$property = $value;
3024     }
3025 }
3026
3027 /**
3028  * Allows you to load in the configuration for an external tool from an IMS cartridge.
3029  *
3030  * @param  string   $url    The URL to the cartridge
3031  * @param  stdClass $lti    LTI object
3032  * @throws moodle_exception if the cartridge could not be loaded correctly
3033  * @since Moodle 3.1
3034  */
3035 function lti_load_tool_from_cartridge($url, $lti) {
3036     $toolinfo = lti_load_cartridge($url,
3037         array(
3038             "title" => "name",
3039             "launch_url" => "toolurl",
3040             "secure_launch_url" => "securetoolurl",
3041             "description" => "intro",
3042             "icon" => "icon",
3043             "secure_icon" => "secureicon"
3044         ),
3045         array(
3046             "icon_url" => "extension_icon",
3047             "secure_icon_url" => "extension_secureicon"
3048         )
3049     );
3050     // If an activity name exists, unset the cartridge name so we don't override it.
3051     if (isset($lti->name)) {
3052         unset($toolinfo['name']);
3053     }
3054
3055     // Always prefer cartridge core icons first, then, if none are found, look at the extension icons.
3056     if (empty($toolinfo['icon']) && !empty($toolinfo['extension_icon'])) {
3057         $toolinfo['icon'] = $toolinfo['extension_icon'];
3058     }
3059     unset($toolinfo['extension_icon']);
3060
3061     if (empty($toolinfo['secureicon']) && !empty($toolinfo['extension_secureicon'])) {
3062         $toolinfo['secureicon'] = $toolinfo['extension_secureicon'];
3063     }
3064     unset($toolinfo['extension_secureicon']);
3065
3066     foreach ($toolinfo as $property => $value) {
3067         $lti->$property = $value;
3068     }
3069 }
3070
3071 /**
3072  * Search for a tag within an XML DOMDocument
3073  *
3074  * @param  string $url The url of the cartridge to be loaded
3075  * @param  array  $map The map of tags to keys in the return array
3076  * @param  array  $propertiesmap The map of properties to keys in the return array
3077  * @return array An associative array with the given keys and their values from the cartridge
3078  * @throws moodle_exception if the cartridge could not be loaded correctly
3079  * @since Moodle 3.1
3080  */
3081 function lti_load_cartridge($url, $map, $propertiesmap = array()) {
3082     global $CFG;
3083     require_once($CFG->libdir. "/filelib.php");
3084
3085     $curl = new curl();
3086     $response = $curl->get($url);
3087
3088     // TODO MDL-46023 Replace this code with a call to the new library.
3089     $origerrors = libxml_use_internal_errors(true);
3090     $origentity = libxml_disable_entity_loader(true);
3091     libxml_clear_errors();
3092
3093     $document = new DOMDocument();
3094     @$document->loadXML($response, LIBXML_DTDLOAD | LIBXML_DTDATTR);
3095
3096     $cartridge = new DomXpath($document);
3097
3098     $errors = libxml_get_errors();
3099
3100     libxml_clear_errors();
3101     libxml_use_internal_errors($origerrors);
3102     libxml_disable_entity_loader($origentity);
3103
3104     if (count($errors) > 0) {
3105         $message = 'Failed to load cartridge.';
3106         foreach ($errors as $error) {
3107             $message .= "\n" . trim($error->message, "\n\r\t .") . " at line " . $error->line;
3108         }
3109         throw new moodle_exception('errorreadingfile', '', '', $url, $message);
3110     }
3111
3112     $toolinfo = array();
3113     foreach ($map as $tag => $key) {
3114         $value = get_tag($tag, $cartridge);
3115         if ($value) {
3116             $toolinfo[$key] = $value;
3117         }
3118     }
3119     if (!empty($propertiesmap)) {
3120         foreach ($propertiesmap as $property => $key) {
3121             $value = get_tag("property", $cartridge, $property);
3122             if ($value) {
3123                 $toolinfo[$key] = $value;
3124             }
3125         }
3126     }
3127
3128     return $toolinfo;
3129 }
3130
3131 /**
3132  * Search for a tag within an XML DOMDocument
3133  *
3134  * @param  stdClass $tagname The name of the tag to search for
3135  * @param  XPath    $xpath   The XML to find the tag in
3136  * @param  XPath    $attribute The attribute to search for (if we should search for a child node with the given
3137  * value for the name attribute
3138  * @since Moodle 3.1
3139  */
3140 function get_tag($tagname, $xpath, $attribute = null) {
3141     if ($attribute) {
3142         $result = $xpath->query('//*[local-name() = \'' . $tagname . '\'][@name="' . $attribute . '"]');
3143     } else {
3144         $result = $xpath->query('//*[local-name() = \'' . $tagname . '\']');
3145     }
3146     if ($result->length > 0) {
3147         return $result->item(0)->nodeValue;
3148     }
3149     return null;
3150 }