lib/form/filemanager.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 /**
  19  * FileManager form element
  20  *
  21  * Contains HTML class for a filemanager form element
  22  *
  23  * @package   core_form
  24  * @copyright 2009 Dongsheng Cai <dongsheng@moodle.com>
  25  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  26  */
  27
  28 global $CFG;
  29
  30 require_once('HTML/QuickForm/element.php');
  31 require_once($CFG->dirroot.'/lib/filelib.php');
  32 require_once($CFG->dirroot.'/repository/lib.php');
  33 require_once('templatable_form_element.php');
  34
  35 /**
  36  * Filemanager form element
  37  *
  38  * FilemaneManager lets user to upload/manage multiple files
  39  * @package   core_form
  40  * @category  form
  41  * @copyright 2009 Dongsheng Cai <dongsheng@moodle.com>
  42  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  43  */
  44 class MoodleQuickForm_filemanager extends HTML_QuickForm_element implements templatable {
  45     use templatable_form_element {
  46         export_for_template as export_for_template_base;
  47     }
  48
  49     /** @var string html for help button, if empty then no help will icon will be dispalyed. */
  50     public $_helpbutton = '';
  51
  52     /** @var array options provided to initalize filemanager */
  53     // PHP doesn't support 'key' => $value1 | $value2 in class definition
  54     // We cannot do $_options = array('return_types'=> FILE_INTERNAL | FILE_REFERENCE);
  55     // So I have to set null here, and do it in constructor
  56     protected $_options = array('mainfile' => '', 'subdirs' => 1, 'maxbytes' => -1, 'maxfiles' => -1,
  57             'accepted_types' => '*', 'return_types' =>  null, 'areamaxbytes' => FILE_AREA_MAX_BYTES_UNLIMITED);
  58
  59     /**
  60      * Constructor
  61      *
  62      * @param string $elementName (optional) name of the filemanager
  63      * @param string $elementLabel (optional) filemanager label
  64      * @param array $attributes (optional) Either a typical HTML attribute string
  65      *              or an associative array
  66      * @param array $options set of options to initalize filemanager
  67      */
  68     public function __construct($elementName=null, $elementLabel=null, $attributes=null, $options=null) {
  69         global $CFG, $PAGE;
  70
  71         $options = (array)$options;
  72         foreach ($options as $name=>$value) {
  73             if (array_key_exists($name, $this->_options)) {
  74                 $this->_options[$name] = $value;
  75             }
  76         }
  77         if (!empty($options['maxbytes'])) {
  78             $this->_options['maxbytes'] = get_user_max_upload_file_size($PAGE->context, $CFG->maxbytes, $options['maxbytes']);
  79         }
  80         if (empty($options['return_types'])) {
  81             $this->_options['return_types'] = (FILE_INTERNAL | FILE_REFERENCE | FILE_CONTROLLED_LINK);
  82         }
  83         $this->_type = 'filemanager';
  84         parent::__construct($elementName, $elementLabel, $attributes);
  85     }
  86
  87     /**
  88      * Old syntax of class constructor. Deprecated in PHP7.
  89      *
  90      * @deprecated since Moodle 3.1
  91      */
  92     public function MoodleQuickForm_filemanager($elementName=null, $elementLabel=null, $attributes=null, $options=null) {
  93         debugging('Use of class name as constructor is deprecated', DEBUG_DEVELOPER);
  94         self::__construct($elementName, $elementLabel, $attributes, $options);
  95     }
  96
  97     /**
  98      * Called by HTML_QuickForm whenever form event is made on this element
  99      *
 100      * @param string $event Name of event
 101      * @param mixed $arg event arguments
 102      * @param object $caller calling object
 103      * @return bool
 104      */
 105     function onQuickFormEvent($event, $arg, &$caller)
 106     {
 107         switch ($event) {
 108             case 'createElement':
 109                 $caller->setType($arg[0], PARAM_INT);
 110                 break;
 111         }
 112         return parent::onQuickFormEvent($event, $arg, $caller);
 113     }
 114
 115     /**
 116      * Sets name of filemanager
 117      *
 118      * @param string $name name of the filemanager
 119      */
 120     function setName($name) {
 121         $this->updateAttributes(array('name'=>$name));
 122     }
 123
 124     /**
 125      * Returns name of filemanager
 126      *
 127      * @return string
 128      */
 129     function getName() {
 130         return $this->getAttribute('name');
 131     }
 132
 133     /**
 134      * Updates filemanager attribute value
 135      *
 136      * @param string $value value to set
 137      */
 138     function setValue($value) {
 139         $this->updateAttributes(array('value'=>$value));
 140     }
 141
 142     /**
 143      * Returns filemanager attribute value
 144      *
 145      * @return string
 146      */
 147     function getValue() {
 148         return $this->getAttribute('value');
 149     }
 150
 151     /**
 152      * Returns maximum file size which can be uploaded
 153      *
 154      * @return int
 155      */
 156     function getMaxbytes() {
 157         return $this->_options['maxbytes'];
 158     }
 159
 160     /**
 161      * Sets maximum file size which can be uploaded
 162      *
 163      * @param int $maxbytes file size
 164      */
 165     function setMaxbytes($maxbytes) {
 166         global $CFG, $PAGE;
 167         $this->_options['maxbytes'] = get_user_max_upload_file_size($PAGE->context, $CFG->maxbytes, $maxbytes);
 168     }
 169
 170     /**
 171      * Returns the maximum size of the area.
 172      *
 173      * @return int
 174      */
 175     function getAreamaxbytes() {
 176         return $this->_options['areamaxbytes'];
 177     }
 178
 179     /**
 180      * Sets the maximum size of the area.
 181      *
 182      * @param int $areamaxbytes size limit
 183      */
 184     function setAreamaxbytes($areamaxbytes) {
 185         $this->_options['areamaxbytes'] = $areamaxbytes;
 186     }
 187
 188     /**
 189      * Returns true if subdirectoy can be created, else false
 190      *
 191      * @return bool
 192      */
 193     function getSubdirs() {
 194         return $this->_options['subdirs'];
 195     }
 196
 197     /**
 198      * Set option to create sub directory, while uploading  file
 199      *
 200      * @param bool $allow true if sub directory can be created.
 201      */
 202     function setSubdirs($allow) {
 203         $this->_options['subdirs'] = $allow;
 204     }
 205
 206     /**
 207      * Returns maximum number of files which can be uploaded
 208      *
 209      * @return int
 210      */
 211     function getMaxfiles() {
 212         return $this->_options['maxfiles'];
 213     }
 214
 215     /**
 216      * Sets maximum number of files which can be uploaded.
 217      *
 218      * @param int $num number of files
 219      */
 220     function setMaxfiles($num) {
 221         $this->_options['maxfiles'] = $num;
 222     }
 223
 224     /**
 225      * Returns html for help button.
 226      *
 227      * @return string html for help button
 228      */
 229     function getHelpButton() {
 230         return $this->_helpbutton;
 231     }
 232
 233     /**
 234      * Returns type of filemanager element
 235      *
 236      * @return string
 237      */
 238     function getElementTemplateType() {
 239         if ($this->_flagFrozen){
 240             return 'nodisplay';
 241         } else {
 242             return 'default';
 243         }
 244     }
 245
 246     /**
 247      * Returns HTML for filemanager form element.
 248      *
 249      * @return string
 250      */
 251     function toHtml() {
 252         global $CFG, $USER, $COURSE, $PAGE, $OUTPUT;
 253         require_once("$CFG->dirroot/repository/lib.php");
 254
 255         // security - never ever allow guest/not logged in user to upload anything or use this element!
 256         if (isguestuser() or !isloggedin()) {
 257             print_error('noguest');
 258         }
 259
 260         if ($this->_flagFrozen) {
 261             return $this->getFrozenHtml();
 262         }
 263
 264         $id          = $this->_attributes['id'];
 265         $elname      = $this->_attributes['name'];
 266         $subdirs     = $this->_options['subdirs'];
 267         $maxbytes    = $this->_options['maxbytes'];
 268         $draftitemid = $this->getValue();
 269         $accepted_types = $this->_options['accepted_types'];
 270
 271         if (empty($draftitemid)) {
 272             // no existing area info provided - let's use fresh new draft area
 273             require_once("$CFG->libdir/filelib.php");
 274             $this->setValue(file_get_unused_draft_itemid());
 275             $draftitemid = $this->getValue();
 276         }
 277
 278         $client_id = uniqid();
 279
 280         // filemanager options
 281         $options = new stdClass();
 282         $options->mainfile  = $this->_options['mainfile'];
 283         $options->maxbytes  = $this->_options['maxbytes'];
 284         $options->maxfiles  = $this->getMaxfiles();
 285         $options->client_id = $client_id;
 286         $options->itemid    = $draftitemid;
 287         $options->subdirs   = $this->_options['subdirs'];
 288         $options->target    = $id;
 289         $options->accepted_types = $accepted_types;
 290         $options->return_types = $this->_options['return_types'];
 291         $options->context = $PAGE->context;
 292         $options->areamaxbytes = $this->_options['areamaxbytes'];
 293
 294         $html = $this->_getTabs();
 295         $fm = new form_filemanager($options);
 296         $output = $PAGE->get_renderer('core', 'files');
 297         $html .= $output->render($fm);
 298
 299         $html .= html_writer::empty_tag('input', array('value' => $draftitemid, 'name' => $elname, 'type' => 'hidden'));
 300         // label element needs 'for' attribute work
 301         $html .= html_writer::empty_tag('input', array('value' => '', 'id' => 'id_'.$elname, 'type' => 'hidden'));
 302
 303         if (!empty($options->accepted_types) && $options->accepted_types != '*') {
 304             $html .= html_writer::tag('p', get_string('filesofthesetypes', 'form'));
 305             $util = new \core_form\filetypes_util();
 306             $filetypes = $options->accepted_types;
 307             $filetypedescriptions = $util->describe_file_types($filetypes);
 308             $html .= $OUTPUT->render_from_template('core_form/filetypes-descriptions', $filetypedescriptions);
 309         }
 310
 311         return $html;
 312     }
 313
 314     public function export_for_template(renderer_base $output) {
 315         $context = $this->export_for_template_base($output);
 316         $context['html'] = $this->toHtml();
 317         return $context;
 318     }
 319
 320     /**
 321      * Check that all files have the allowed type.
 322      *
 323      * @param array $value Draft item id with the uploaded files.
 324      * @return string|null Validation error message or null.
 325      */
 326     public function validateSubmitValue($value) {
 327
 328         $filetypesutil = new \core_form\filetypes_util();
 329         $whitelist = $filetypesutil->normalize_file_types($this->_options['accepted_types']);
 330
 331         if (empty($whitelist) || $whitelist === ['*']) {
 332             // Any file type is allowed, nothing to check here.
 333             return;
 334         }
 335
 336         $draftfiles = file_get_drafarea_files($value);
 337         $wrongfiles = array();
 338
 339         if (empty($draftfiles)) {
 340             // No file uploaded, nothing to check here.
 341             return;
 342         }
 343
 344         foreach ($draftfiles->list as $file) {
 345             if (!$filetypesutil->is_allowed_file_type($file->filename, $whitelist)) {
 346                 $wrongfiles[] = $file->filename;
 347             }
 348         }
 349
 350         if ($wrongfiles) {
 351             $a = array(
 352                 'whitelist' => implode(', ', $whitelist),
 353                 'wrongfiles' => implode(', ', $wrongfiles),
 354             );
 355             return get_string('err_wrongfileextension', 'core_form', $a);
 356         }
 357
 358         return;
 359     }
 360 }
 361
 362 /**
 363  * Data structure representing a file manager.
 364  *
 365  * This class defines the data structure for file mnager
 366  *
 367  * @package   core_form
 368  * @copyright 2010 Dongsheng Cai
 369  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 370  * @todo      do not use this abstraction (skodak)
 371  */
 372 class form_filemanager implements renderable {
 373     /** @var stdClass $options options for filemanager */
 374     public $options;
 375
 376     /**
 377      * Constructor
 378      *
 379      * @param stdClass $options options for filemanager
 380      *   default options are:
 381      *       maxbytes=>-1,
 382      *       areamaxbytes => FILE_AREA_MAX_BYTES_UNLIMITED,
 383      *       maxfiles=>-1,
 384      *       itemid=>0,
 385      *       subdirs=>false,
 386      *       client_id=>uniqid(),
 387      *       acepted_types=>'*',
 388      *       return_types=>FILE_INTERNAL,
 389      *       context=>$PAGE->context,
 390      *       author=>fullname($USER),
 391      *       licenses=>array build from $CFG->licenses,
 392      *       defaultlicense=>$CFG->sitedefaultlicense
 393      */
 394     public function __construct(stdClass $options) {
 395         global $CFG, $USER, $PAGE;
 396         require_once($CFG->dirroot. '/repository/lib.php');
 397         $defaults = array(
 398             'maxbytes'=>-1,
 399             'areamaxbytes' => FILE_AREA_MAX_BYTES_UNLIMITED,
 400             'maxfiles'=>-1,
 401             'itemid'=>0,
 402             'subdirs'=>0,
 403             'client_id'=>uniqid(),
 404             'accepted_types'=>'*',
 405             'return_types'=>FILE_INTERNAL,
 406             'context'=>$PAGE->context,
 407             'author'=>fullname($USER),
 408             'licenses'=>array()
 409             );
 410         if (!empty($CFG->licenses)) {
 411             $array = explode(',', $CFG->licenses);
 412             foreach ($array as $license) {
 413                 $l = new stdClass();
 414                 $l->shortname = $license;
 415                 $l->fullname = get_string($license, 'license');
 416                 $defaults['licenses'][] = $l;
 417             }
 418         }
 419         if (!empty($CFG->sitedefaultlicense)) {
 420             $defaults['defaultlicense'] = $CFG->sitedefaultlicense;
 421         }
 422         foreach ($defaults as $key=>$value) {
 423             // Using !isset() prevents us from overwriting falsey values with defaults (as empty() did).
 424             if (!isset($options->$key)) {
 425                 $options->$key = $value;
 426             }
 427         }
 428
 429         $fs = get_file_storage();
 430
 431         // initilise options, getting files in root path
 432         $this->options = file_get_drafarea_files($options->itemid, '/');
 433
 434         // calculate file count
 435         $usercontext = context_user::instance($USER->id);
 436         $files = $fs->get_area_files($usercontext->id, 'user', 'draft', $options->itemid, 'id', false);
 437         $filecount = count($files);
 438         $this->options->filecount = $filecount;
 439
 440         // copying other options
 441         foreach ($options as $name=>$value) {
 442             $this->options->$name = $value;
 443         }
 444
 445         // calculate the maximum file size as minimum from what is specified in filepicker options,
 446         // course options, global configuration and php settings
 447         $coursebytes = $maxbytes = 0;
 448         list($context, $course, $cm) = get_context_info_array($this->options->context->id);
 449         if (is_object($course)) {
 450             $coursebytes = $course->maxbytes;
 451         }
 452         if (!empty($this->options->maxbytes) && $this->options->maxbytes > 0) {
 453             $maxbytes = $this->options->maxbytes;
 454         }
 455         $this->options->maxbytes = get_user_max_upload_file_size($context, $CFG->maxbytes, $coursebytes, $maxbytes);
 456
 457         $this->options->userprefs = array();
 458         $this->options->userprefs['recentviewmode'] = get_user_preferences('filemanager_recentviewmode', '');
 459         user_preference_allow_ajax_update('filemanager_recentviewmode', PARAM_INT);
 460
 461         // building file picker options
 462         $params = new stdClass();
 463         $params->accepted_types = $options->accepted_types;
 464         $params->return_types = $options->return_types;
 465         $params->context = $options->context;
 466         $params->env = 'filemanager';
 467         $params->disable_types = !empty($options->disable_types)?$options->disable_types:array();
 468         $filepicker_options = initialise_filepicker($params);
 469         $this->options->filepicker = $filepicker_options;
 470     }
 471
 472     public function get_nonjsurl() {
 473         global $PAGE;
 474         return new moodle_url('/repository/draftfiles_manager.php', array(
 475             'env'=>'filemanager',
 476             'action'=>'browse',
 477             'itemid'=>$this->options->itemid,
 478             'subdirs'=>$this->options->subdirs,
 479             'maxbytes'=>$this->options->maxbytes,
 480             'areamaxbytes' => $this->options->areamaxbytes,
 481             'maxfiles'=>$this->options->maxfiles,
 482             'ctx_id'=>$PAGE->context->id, // TODO ?
 483             'course'=>$PAGE->course->id, // TODO ?
 484             'sesskey'=>sesskey(),
 485             ));
 486     }
 487 }