repository/equella/lib.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 /**
  18  * This plugin is used to access equella repositories.
  19  *
  20  * @since Moodle 2.3
  21  * @package    repository_equella
  22  * @copyright  2012 Dongsheng Cai {@link http://dongsheng.org}
  23  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  24  */
  25
  26 defined('MOODLE_INTERNAL') || die();
  27
  28 require_once($CFG->dirroot . '/repository/lib.php');
  29
  30 /**
  31  * repository_equella class implements equella_client
  32  *
  33  * @since Moodle 2.3
  34  * @package    repository_equella
  35  * @copyright  2012 Dongsheng Cai {@link http://dongsheng.org}
  36  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  37  */
  38 class repository_equella extends repository {
  39     /** @var array mimetype filter */
  40     private $mimetypes = array();
  41
  42     /**
  43      * Constructor
  44      *
  45      * @param int $repositoryid repository instance id
  46      * @param int|stdClass $context a context id or context object
  47      * @param array $options repository options
  48      */
  49     public function __construct($repositoryid, $context = SYSCONTEXTID, $options = array()) {
  50         parent::__construct($repositoryid, $context, $options);
  51
  52         if (isset($this->options['mimetypes'])) {
  53             $mt = $this->options['mimetypes'];
  54             if (!empty($mt) && is_array($mt) && !in_array('*', $mt)) {
  55                 $this->mimetypes = array_unique(array_map(array($this, 'to_mime_type'), $mt));
  56             }
  57         }
  58     }
  59
  60     /**
  61      * Display embedded equella interface
  62      *
  63      * @param string $path
  64      * @param mixed $page
  65      * @return array
  66      */
  67     public function get_listing($path = null, $page = null) {
  68         global $COURSE;
  69         $callbackurl = new moodle_url('/repository/equella/callback.php', array('repo_id'=>$this->id));
  70
  71         $mimetypesstr = '';
  72         $restrict = '';
  73         if (!empty($this->mimetypes)) {
  74             $mimetypesstr = '&mimeTypes=' . implode(',', $this->mimetypes);
  75             // We're restricting to a mime type, so we always restrict to selecting resources only.
  76             $restrict = '&attachmentonly=true';
  77         } else if ($this->get_option('equella_select_restriction') != 'none') {
  78             // The option value matches the EQUELLA paramter name.
  79             $restrict = '&' . $this->get_option('equella_select_restriction') . '=true';
  80         }
  81
  82         $url = $this->get_option('equella_url')
  83                 . '?method=lms'
  84                 . '&returnurl='.urlencode($callbackurl)
  85                 . '&returnprefix=tle'
  86                 . '&template=standard'
  87                 . '&token='.urlencode($this->getssotoken('write'))
  88                 . '&courseId='.urlencode($COURSE->idnumber)
  89                 . '&courseCode='.urlencode($COURSE->shortname)
  90                 . '&action=searchThin'
  91                 . '&forcePost=true'
  92                 . '&cancelDisabled=true'
  93                 . '&attachmentUuidUrls=true'
  94                 . '&options='.urlencode($this->get_option('equella_options') . $mimetypesstr)
  95                 . $restrict;
  96
  97         $manageurl = $this->get_option('equella_url');
  98         $manageurl = str_ireplace('signon.do', 'logon.do', $manageurl);
  99         $manageurl = $this->appendtoken($manageurl);
 100
 101         $list = array();
 102         $list['object'] = array();
 103         $list['object']['type'] = 'text/html';
 104         $list['object']['src'] = $url;
 105         $list['nologin']  = true;
 106         $list['nosearch'] = true;
 107         $list['norefresh'] = true;
 108         $list['manage'] = $manageurl;
 109         return $list;
 110     }
 111
 112     /**
 113      * Supported equella file types
 114      *
 115      * @return int
 116      */
 117     public function supported_returntypes() {
 118         return FILE_REFERENCE;
 119     }
 120
 121     /**
 122      * Prepare file reference information
 123      *
 124      * @param string $source
 125      * @return string file referece
 126      */
 127     public function get_file_reference($source) {
 128         // Internally we store serialized value but user input is json-encoded for security reasons.
 129         $ref = json_decode(base64_decode($source));
 130         $filename  = clean_param($ref->filename, PARAM_FILE);
 131         $url = clean_param($ref->url, PARAM_URL);
 132         return base64_encode(serialize((object)array('url' => $url, 'filename' => $filename)));
 133     }
 134
 135     /**
 136      * Counts the number of failed connections.
 137      *
 138      * If we received the connection timeout more than 3 times in a row, we don't attemt to
 139      * connect to the server any more during this request.
 140      *
 141      * This function is used by {@link repository_equella::sync_reference()} that
 142      * synchronises the file size of referenced files.
 143      *
 144      * @param int $errno omit if we just want to know the return value, the last curl_errno otherwise
 145      * @return bool true if we had less than 3 failed connections, false if no more connections
 146      * attempts recommended
 147      */
 148     private function connection_result($errno = null) {
 149         static $countfailures = array();
 150         $sess = sesskey();
 151         if (!array_key_exists($sess, $countfailures)) {
 152             $countfailures[$sess] = 0;
 153         }
 154         if ($errno !== null) {
 155             if ($errno == 0) {
 156                 // reset count of failed connections
 157                 $countfailures[$sess] = 0;
 158             } else if ($errno == 7 /*CURLE_COULDNT_CONNECT*/ || $errno == 9 /*CURLE_REMOTE_ACCESS_DENIED*/) {
 159                 // problems with server
 160                 $countfailures[$sess]++;
 161             }
 162         }
 163         return ($countfailures[$sess] < 3);
 164     }
 165
 166     /**
 167      * Download a file, this function can be overridden by subclass. {@link curl}
 168      *
 169      * @param string $reference the source of the file
 170      * @param string $filename filename (without path) to save the downloaded file in the
 171      * temporary directory
 172      * @return null|array null if download failed or array with elements:
 173      *   path: internal location of the file
 174      *   url: URL to the source (from parameters)
 175      */
 176     public function get_file($reference, $filename = '') {
 177         global $USER, $CFG;
 178         $ref = @unserialize(base64_decode($reference));
 179         if (!isset($ref->url) || !($url = $this->appendtoken($ref->url))) {
 180             // Occurs when the user isn't known..
 181             return null;
 182         }
 183         $path = $this->prepare_file($filename);
 184         $cookiepathname = $this->prepare_file($USER->id. '_'. uniqid('', true). '.cookie');
 185         $c = new curl(array('cookie'=>$cookiepathname));
 186         $result = $c->download_one($url, null, array('filepath' => $path, 'followlocation' => true, 'timeout' => $CFG->repositorygetfiletimeout));
 187         // Delete cookie jar.
 188         if (file_exists($cookiepathname)) {
 189             unlink($cookiepathname);
 190         }
 191         if ($result !== true) {
 192             throw new moodle_exception('errorwhiledownload', 'repository', '', $result);
 193         }
 194         return array('path'=>$path, 'url'=>$url);
 195     }
 196
 197     public function sync_reference(stored_file $file) {
 198         global $USER, $CFG;
 199         if ($file->get_referencelastsync() + DAYSECS > time() || !$this->connection_result()) {
 200             // Synchronise not more often than once a day.
 201             // if we had several unsuccessfull attempts to connect to server - do not try any more.
 202             return false;
 203         }
 204         $ref = @unserialize(base64_decode($file->get_reference()));
 205         if (!isset($ref->url) || !($url = $this->appendtoken($ref->url))) {
 206             // Occurs when the user isn't known..
 207             $file->set_missingsource();
 208             return true;
 209         }
 210
 211         $cookiepathname = $this->prepare_file($USER->id. '_'. uniqid('', true). '.cookie');
 212         $c = new curl(array('cookie' => $cookiepathname));
 213         if (file_extension_in_typegroup($ref->filename, 'web_image')) {
 214             $path = $this->prepare_file('');
 215             $result = $c->download_one($url, null, array('filepath' => $path, 'followlocation' => true, 'timeout' => $CFG->repositorysyncimagetimeout));
 216             if ($result === true) {
 217                 $fs = get_file_storage();
 218                 list($contenthash, $filesize, $newfile) = $fs->add_file_to_pool($path);
 219                 $file->set_synchronized($contenthash, $filesize);
 220                 return true;
 221             }
 222         } else {
 223             $result = $c->head($url, array('followlocation' => true, 'timeout' => $CFG->repositorysyncfiletimeout));
 224         }
 225         // Delete cookie jar.
 226         if (file_exists($cookiepathname)) {
 227             unlink($cookiepathname);
 228         }
 229
 230         $this->connection_result($c->get_errno());
 231         $curlinfo = $c->get_info();
 232         if (isset($curlinfo['http_code']) && $curlinfo['http_code'] == 200
 233                 && array_key_exists('download_content_length', $curlinfo)
 234                 && $curlinfo['download_content_length'] >= 0) {
 235             // we received a correct header and at least can tell the file size
 236             $file->set_synchronized(null, $curlinfo['download_content_length']);
 237             return true;
 238         }
 239         $file->set_missingsource();
 240         return true;
 241     }
 242
 243     /**
 244      * Repository method to serve the referenced file
 245      *
 246      * @param stored_file $storedfile the file that contains the reference
 247      * @param int $lifetime Number of seconds before the file should expire from caches (null means $CFG->filelifetime)
 248      * @param int $filter 0 (default)=no filtering, 1=all files, 2=html files only
 249      * @param bool $forcedownload If true (default false), forces download of file rather than view in browser/plugin
 250      * @param array $options additional options affecting the file serving
 251      */
 252     public function send_file($stored_file, $lifetime=null , $filter=0, $forcedownload=false, array $options = null) {
 253         $reference  = unserialize(base64_decode($stored_file->get_reference()));
 254         $url = $this->appendtoken($reference->url);
 255         if ($url) {
 256             header('Location: ' . $url);
 257         } else {
 258             send_file_not_found();
 259         }
 260     }
 261
 262     /**
 263      * Add Instance settings input to Moodle form
 264      *
 265      * @param moodleform $mform
 266      */
 267     public static function instance_config_form($mform) {
 268         $mform->addElement('text', 'equella_url', get_string('equellaurl', 'repository_equella'));
 269         $mform->setType('equella_url', PARAM_URL);
 270
 271         $strrequired = get_string('required');
 272         $mform->addRule('equella_url', $strrequired, 'required', null, 'client');
 273
 274         $mform->addElement('text', 'equella_options', get_string('equellaoptions', 'repository_equella'));
 275         $mform->setType('equella_options', PARAM_NOTAGS);
 276
 277         $choices = array(
 278             'none' => get_string('restrictionnone', 'repository_equella'),
 279             'itemonly' => get_string('restrictionitemsonly', 'repository_equella'),
 280             'attachmentonly' => get_string('restrictionattachmentsonly', 'repository_equella'),
 281         );
 282         $mform->addElement('select', 'equella_select_restriction', get_string('selectrestriction', 'repository_equella'), $choices);
 283
 284         $mform->addElement('header', 'groupheader',
 285             get_string('group', 'repository_equella', get_string('groupdefault', 'repository_equella')));
 286         $mform->addElement('text', 'equella_shareid', get_string('sharedid', 'repository_equella'));
 287         $mform->setType('equella_shareid', PARAM_RAW);
 288         $mform->addRule('equella_shareid', $strrequired, 'required', null, 'client');
 289
 290         $mform->addElement('text', 'equella_sharedsecret', get_string('sharedsecrets', 'repository_equella'));
 291         $mform->setType('equella_sharedsecret', PARAM_RAW);
 292         $mform->addRule('equella_sharedsecret', $strrequired, 'required', null, 'client');
 293
 294         foreach (self::get_all_editing_roles() as $role) {
 295             $mform->addElement('header', 'groupheader_'.$role->shortname, get_string('group', 'repository_equella',
 296                 format_string($role->name)));
 297             $mform->addElement('text', "equella_{$role->shortname}_shareid", get_string('sharedid', 'repository_equella'));
 298             $mform->setType("equella_{$role->shortname}_shareid", PARAM_RAW);
 299             $mform->addElement('text', "equella_{$role->shortname}_sharedsecret",
 300                 get_string('sharedsecrets', 'repository_equella'));
 301             $mform->setType("equella_{$role->shortname}_sharedsecret", PARAM_RAW);
 302         }
 303     }
 304
 305     /**
 306      * Names of the instance settings
 307      *
 308      * @return array
 309      */
 310     public static function get_instance_option_names() {
 311         $rv = array('equella_url', 'equella_select_restriction', 'equella_options',
 312             'equella_shareid', 'equella_sharedsecret'
 313         );
 314
 315         foreach (self::get_all_editing_roles() as $role) {
 316             array_push($rv, "equella_{$role->shortname}_shareid");
 317             array_push($rv, "equella_{$role->shortname}_sharedsecret");
 318         }
 319
 320         return $rv;
 321     }
 322
 323     /**
 324      * Generate equella token
 325      *
 326      * @param string $username
 327      * @param string $shareid
 328      * @param string $sharedsecret
 329      * @return string
 330      */
 331     private static function getssotoken_raw($username, $shareid, $sharedsecret) {
 332         $time = time() . '000';
 333         return urlencode($username)
 334             . ':'
 335             . $shareid
 336             . ':'
 337             . $time
 338             . ':'
 339             . base64_encode(pack('H*', md5($username . $shareid . $time . $sharedsecret)));
 340     }
 341
 342     /**
 343      * Append token
 344      *
 345      * @param string $url
 346      * @param $readwrite
 347      * @return string
 348      */
 349     private function appendtoken($url, $readwrite = null) {
 350         $ssotoken = $this->getssotoken($readwrite);
 351         if (!$ssotoken) {
 352             return false;
 353         }
 354         return $url . (strpos($url, '?') != false ? '&' : '?') . 'token=' . urlencode($ssotoken);
 355     }
 356
 357     /**
 358      * Generate equella sso token
 359      *
 360      * @param string $readwrite
 361      * @return string
 362      */
 363     private function getssotoken($readwrite = 'read') {
 364         global $USER;
 365
 366         if (empty($USER->username)) {
 367             return false;
 368         }
 369
 370         if ($readwrite == 'write') {
 371
 372             foreach (self::get_all_editing_roles() as $role) {
 373                 if (user_has_role_assignment($USER->id, $role->id, $this->context->id)) {
 374                     // See if the user has a role that is linked to an equella role.
 375                     $shareid = $this->get_option("equella_{$role->shortname}_shareid");
 376                     if (!empty($shareid)) {
 377                         return $this->getssotoken_raw($USER->username, $shareid,
 378                             $this->get_option("equella_{$role->shortname}_sharedsecret"));
 379                     }
 380                 }
 381             }
 382         }
 383         // If we are only reading, use the unadorned shareid and secret.
 384         $shareid = $this->get_option('equella_shareid');
 385         if (!empty($shareid)) {
 386             return $this->getssotoken_raw($USER->username, $shareid, $this->get_option('equella_sharedsecret'));
 387         }
 388     }
 389
 390     private static function get_all_editing_roles() {
 391         return get_roles_with_capability('moodle/course:manageactivities', CAP_ALLOW);
 392     }
 393
 394     /**
 395      * Convert moodle mimetypes list to equella format
 396      *
 397      * @param string $value
 398      * @return string
 399      */
 400     private static function to_mime_type($value) {
 401         return mimeinfo('type', $value);
 402     }
 403
 404     /**
 405      * Return the source information
 406      *
 407      * @param string $source
 408      * @return string|null
 409      */
 410     public function get_file_source_info($source) {
 411         $ref = json_decode(base64_decode($source));
 412         $filename  = clean_param($ref->filename, PARAM_FILE);
 413         return 'EQUELLA: ' . $filename;
 414     }
 415
 416     /**
 417      * Return human readable reference information
 418      * {@link stored_file::get_reference()}
 419      *
 420      * @param string $reference
 421      * @param int $filestatus status of the file, 0 - ok, 666 - source missing
 422      * @return string
 423      */
 424     public function get_reference_details($reference, $filestatus = 0) {
 425         if (!$filestatus) {
 426             $ref = unserialize(base64_decode($reference));
 427             return $this->get_name(). ': '. $ref->filename;
 428         } else {
 429             return get_string('lostsource', 'repository', '');
 430         }
 431     }
 432
 433     /**
 434      * Is this repository accessing private data?
 435      *
 436      * @return bool
 437      */
 438     public function contains_private_data() {
 439         return false;
 440     }
 441 }