[Summary view] [Print] [Text view]

   1  <?php
   2  // This file is part of Moodle - http://moodle.org/
   3  //
   4  // Moodle is free software: you can redistribute it and/or modify
   5  // it under the terms of the GNU General Public License as published by
   6  // the Free Software Foundation, either version 3 of the License, or
   7  // (at your option) any later version.
   8  //
   9  // Moodle is distributed in the hope that it will be useful,
  10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  // GNU General Public License for more details.
  13  //
  14  // You should have received a copy of the GNU General Public License
  15  // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16  
  17  
  18  /**
  19   * FileManager form element
  20   *
  21   * Contains HTML class for a filemanager form element
  22   *
  23   * @package   core_form
  24   * @copyright 2009 Dongsheng Cai <[email protected]>
  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  
  34  /**
  35   * Filemanager form element
  36   *
  37   * FilemaneManager lets user to upload/manage multiple files
  38   * @package   core_form
  39   * @category  form
  40   * @copyright 2009 Dongsheng Cai <[email protected]>
  41   * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  42   */
  43  class MoodleQuickForm_filemanager extends HTML_QuickForm_element {
  44      /** @var string html for help button, if empty then no help will icon will be dispalyed. */
  45      public $_helpbutton = '';
  46  
  47      /** @var array options provided to initalize filemanager */
  48      // PHP doesn't support 'key' => $value1 | $value2 in class definition
  49      // We cannot do $_options = array('return_types'=> FILE_INTERNAL | FILE_REFERENCE);
  50      // So I have to set null here, and do it in constructor
  51      protected $_options = array('mainfile' => '', 'subdirs' => 1, 'maxbytes' => -1, 'maxfiles' => -1,
  52              'accepted_types' => '*', 'return_types' =>  null, 'areamaxbytes' => FILE_AREA_MAX_BYTES_UNLIMITED);
  53  
  54      /**
  55       * Constructor
  56       *
  57       * @param string $elementName (optional) name of the filemanager
  58       * @param string $elementLabel (optional) filemanager label
  59       * @param array $attributes (optional) Either a typical HTML attribute string
  60       *              or an associative array
  61       * @param array $options set of options to initalize filemanager
  62       */
  63      function MoodleQuickForm_filemanager($elementName=null, $elementLabel=null, $attributes=null, $options=null) {
  64          global $CFG, $PAGE;
  65  
  66          $options = (array)$options;
  67          foreach ($options as $name=>$value) {
  68              if (array_key_exists($name, $this->_options)) {
  69                  $this->_options[$name] = $value;
  70              }
  71          }
  72          if (!empty($options['maxbytes'])) {
  73              $this->_options['maxbytes'] = get_user_max_upload_file_size($PAGE->context, $CFG->maxbytes, $options['maxbytes']);
  74          }
  75          if (empty($options['return_types'])) {
  76              $this->_options['return_types'] = (FILE_INTERNAL | FILE_REFERENCE);
  77          }
  78          $this->_type = 'filemanager';
  79          parent::HTML_QuickForm_element($elementName, $elementLabel, $attributes);
  80      }
  81  
  82      /**
  83       * Called by HTML_QuickForm whenever form event is made on this element
  84       *
  85       * @param string $event Name of event
  86       * @param mixed $arg event arguments
  87       * @param object $caller calling object
  88       * @return bool
  89       */
  90      function onQuickFormEvent($event, $arg, &$caller)
  91      {
  92          switch ($event) {
  93              case 'createElement':
  94                  $caller->setType($arg[0], PARAM_INT);
  95                  break;
  96          }
  97          return parent::onQuickFormEvent($event, $arg, $caller);
  98      }
  99  
 100      /**
 101       * Sets name of filemanager
 102       *
 103       * @param string $name name of the filemanager
 104       */
 105      function setName($name) {
 106          $this->updateAttributes(array('name'=>$name));
 107      }
 108  
 109      /**
 110       * Returns name of filemanager
 111       *
 112       * @return string
 113       */
 114      function getName() {
 115          return $this->getAttribute('name');
 116      }
 117  
 118      /**
 119       * Updates filemanager attribute value
 120       *
 121       * @param string $value value to set
 122       */
 123      function setValue($value) {
 124          $this->updateAttributes(array('value'=>$value));
 125      }
 126  
 127      /**
 128       * Returns filemanager attribute value
 129       *
 130       * @return string
 131       */
 132      function getValue() {
 133          return $this->getAttribute('value');
 134      }
 135  
 136      /**
 137       * Returns maximum file size which can be uploaded
 138       *
 139       * @return int
 140       */
 141      function getMaxbytes() {
 142          return $this->_options['maxbytes'];
 143      }
 144  
 145      /**
 146       * Sets maximum file size which can be uploaded
 147       *
 148       * @param int $maxbytes file size
 149       */
 150      function setMaxbytes($maxbytes) {
 151          global $CFG, $PAGE;
 152          $this->_options['maxbytes'] = get_user_max_upload_file_size($PAGE->context, $CFG->maxbytes, $maxbytes);
 153      }
 154  
 155      /**
 156       * Returns the maximum size of the area.
 157       *
 158       * @return int
 159       */
 160      function getAreamaxbytes() {
 161          return $this->_options['areamaxbytes'];
 162      }
 163  
 164      /**
 165       * Sets the maximum size of the area.
 166       *
 167       * @param int $areamaxbytes size limit
 168       */
 169      function setAreamaxbytes($areamaxbytes) {
 170          $this->_options['areamaxbytes'] = $areamaxbytes;
 171      }
 172  
 173      /**
 174       * Returns true if subdirectoy can be created, else false
 175       *
 176       * @return bool
 177       */
 178      function getSubdirs() {
 179          return $this->_options['subdirs'];
 180      }
 181  
 182      /**
 183       * Set option to create sub directory, while uploading  file
 184       *
 185       * @param bool $allow true if sub directory can be created.
 186       */
 187      function setSubdirs($allow) {
 188          $this->_options['subdirs'] = $allow;
 189      }
 190  
 191      /**
 192       * Returns maximum number of files which can be uploaded
 193       *
 194       * @return int
 195       */
 196      function getMaxfiles() {
 197          return $this->_options['maxfiles'];
 198      }
 199  
 200      /**
 201       * Sets maximum number of files which can be uploaded.
 202       *
 203       * @param int $num number of files
 204       */
 205      function setMaxfiles($num) {
 206          $this->_options['maxfiles'] = $num;
 207      }
 208  
 209      /**
 210       * Returns html for help button.
 211       *
 212       * @return string html for help button
 213       */
 214      function getHelpButton() {
 215          return $this->_helpbutton;
 216      }
 217  
 218      /**
 219       * Returns type of filemanager element
 220       *
 221       * @return string
 222       */
 223      function getElementTemplateType() {
 224          if ($this->_flagFrozen){
 225              return 'nodisplay';
 226          } else {
 227              return 'default';
 228          }
 229      }
 230  
 231      /**
 232       * Returns HTML for filemanager form element.
 233       *
 234       * @return string
 235       */
 236      function toHtml() {
 237          global $CFG, $USER, $COURSE, $PAGE, $OUTPUT;
 238          require_once("$CFG->dirroot/repository/lib.php");
 239  
 240          // security - never ever allow guest/not logged in user to upload anything or use this element!
 241          if (isguestuser() or !isloggedin()) {
 242              print_error('noguest');
 243          }
 244  
 245          if ($this->_flagFrozen) {
 246              return $this->getFrozenHtml();
 247          }
 248  
 249          $id          = $this->_attributes['id'];
 250          $elname      = $this->_attributes['name'];
 251          $subdirs     = $this->_options['subdirs'];
 252          $maxbytes    = $this->_options['maxbytes'];
 253          $draftitemid = $this->getValue();
 254          $accepted_types = $this->_options['accepted_types'];
 255  
 256          if (empty($draftitemid)) {
 257              // no existing area info provided - let's use fresh new draft area
 258              require_once("$CFG->libdir/filelib.php");
 259              $this->setValue(file_get_unused_draft_itemid());
 260              $draftitemid = $this->getValue();
 261          }
 262  
 263          $client_id = uniqid();
 264  
 265          // filemanager options
 266          $options = new stdClass();
 267          $options->mainfile  = $this->_options['mainfile'];
 268          $options->maxbytes  = $this->_options['maxbytes'];
 269          $options->maxfiles  = $this->getMaxfiles();
 270          $options->client_id = $client_id;
 271          $options->itemid    = $draftitemid;
 272          $options->subdirs   = $this->_options['subdirs'];
 273          $options->target    = $id;
 274          $options->accepted_types = $accepted_types;
 275          $options->return_types = $this->_options['return_types'];
 276          $options->context = $PAGE->context;
 277          $options->areamaxbytes = $this->_options['areamaxbytes'];
 278  
 279          $html = $this->_getTabs();
 280          $fm = new form_filemanager($options);
 281          $output = $PAGE->get_renderer('core', 'files');
 282          $html .= $output->render($fm);
 283  
 284          $html .= html_writer::empty_tag('input', array('value' => $draftitemid, 'name' => $elname, 'type' => 'hidden'));
 285          // label element needs 'for' attribute work
 286          $html .= html_writer::empty_tag('input', array('value' => '', 'id' => 'id_'.$elname, 'type' => 'hidden'));
 287  
 288          return $html;
 289      }
 290  }
 291  
 292  /**
 293   * Data structure representing a file manager.
 294   *
 295   * This class defines the data structure for file mnager
 296   *
 297   * @package   core_form
 298   * @copyright 2010 Dongsheng Cai
 299   * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 300   * @todo      do not use this abstraction (skodak)
 301   */
 302  class form_filemanager implements renderable {
 303      /** @var stdClass $options options for filemanager */
 304      public $options;
 305  
 306      /**
 307       * Constructor
 308       *
 309       * @param stdClass $options options for filemanager
 310       *   default options are:
 311       *       maxbytes=>-1,
 312       *       areamaxbytes => FILE_AREA_MAX_BYTES_UNLIMITED,
 313       *       maxfiles=>-1,
 314       *       itemid=>0,
 315       *       subdirs=>false,
 316       *       client_id=>uniqid(),
 317       *       acepted_types=>'*',
 318       *       return_types=>FILE_INTERNAL,
 319       *       context=>$PAGE->context,
 320       *       author=>fullname($USER),
 321       *       licenses=>array build from $CFG->licenses,
 322       *       defaultlicense=>$CFG->sitedefaultlicense
 323       */
 324      public function __construct(stdClass $options) {
 325          global $CFG, $USER, $PAGE;
 326          require_once($CFG->dirroot. '/repository/lib.php');
 327          $defaults = array(
 328              'maxbytes'=>-1,
 329              'areamaxbytes' => FILE_AREA_MAX_BYTES_UNLIMITED,
 330              'maxfiles'=>-1,
 331              'itemid'=>0,
 332              'subdirs'=>0,
 333              'client_id'=>uniqid(),
 334              'accepted_types'=>'*',
 335              'return_types'=>FILE_INTERNAL,
 336              'context'=>$PAGE->context,
 337              'author'=>fullname($USER),
 338              'licenses'=>array()
 339              );
 340          if (!empty($CFG->licenses)) {
 341              $array = explode(',', $CFG->licenses);
 342              foreach ($array as $license) {
 343                  $l = new stdClass();
 344                  $l->shortname = $license;
 345                  $l->fullname = get_string($license, 'license');
 346                  $defaults['licenses'][] = $l;
 347              }
 348          }
 349          if (!empty($CFG->sitedefaultlicense)) {
 350              $defaults['defaultlicense'] = $CFG->sitedefaultlicense;
 351          }
 352          foreach ($defaults as $key=>$value) {
 353              // Using !isset() prevents us from overwriting falsey values with defaults (as empty() did).
 354              if (!isset($options->$key)) {
 355                  $options->$key = $value;
 356              }
 357          }
 358  
 359          $fs = get_file_storage();
 360  
 361          // initilise options, getting files in root path
 362          $this->options = file_get_drafarea_files($options->itemid, '/');
 363  
 364          // calculate file count
 365          $usercontext = context_user::instance($USER->id);
 366          $files = $fs->get_area_files($usercontext->id, 'user', 'draft', $options->itemid, 'id', false);
 367          $filecount = count($files);
 368          $this->options->filecount = $filecount;
 369  
 370          // copying other options
 371          foreach ($options as $name=>$value) {
 372              $this->options->$name = $value;
 373          }
 374  
 375          // calculate the maximum file size as minimum from what is specified in filepicker options,
 376          // course options, global configuration and php settings
 377          $coursebytes = $maxbytes = 0;
 378          list($context, $course, $cm) = get_context_info_array($this->options->context->id);
 379          if (is_object($course)) {
 380              $coursebytes = $course->maxbytes;
 381          }
 382          if (!empty($this->options->maxbytes) && $this->options->maxbytes > 0) {
 383              $maxbytes = $this->options->maxbytes;
 384          }
 385          $this->options->maxbytes = get_user_max_upload_file_size($context, $CFG->maxbytes, $coursebytes, $maxbytes);
 386  
 387          // building file picker options
 388          $params = new stdClass();
 389          $params->accepted_types = $options->accepted_types;
 390          $params->return_types = $options->return_types;
 391          $params->context = $options->context;
 392          $params->env = 'filemanager';
 393          $params->disable_types = !empty($options->disable_types)?$options->disable_types:array();
 394          $filepicker_options = initialise_filepicker($params);
 395          $this->options->filepicker = $filepicker_options;
 396      }
 397  
 398      public function get_nonjsurl() {
 399          global $PAGE;
 400          return new moodle_url('/repository/draftfiles_manager.php', array(
 401              'env'=>'filemanager',
 402              'action'=>'browse',
 403              'itemid'=>$this->options->itemid,
 404              'subdirs'=>$this->options->subdirs,
 405              'maxbytes'=>$this->options->maxbytes,
 406              'areamaxbytes' => $this->options->areamaxbytes,
 407              'maxfiles'=>$this->options->maxfiles,
 408              'ctx_id'=>$PAGE->context->id, // TODO ?
 409              'course'=>$PAGE->course->id, // TODO ?
 410              'sesskey'=>sesskey(),
 411              ));
 412      }
 413  }