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
28global $CFG;
29
30require_once('HTML/QuickForm/element.php');
31require_once($CFG->dirroot.'/lib/filelib.php');
32require_once($CFG->dirroot.'/repository/lib.php');
33require_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 */
44class 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', 'id' => $id));
300
301        if (!empty($options->accepted_types) && $options->accepted_types != '*') {
302            $html .= html_writer::tag('p', get_string('filesofthesetypes', 'form'));
303            $util = new \core_form\filetypes_util();
304            $filetypes = $options->accepted_types;
305            $filetypedescriptions = $util->describe_file_types($filetypes);
306            $html .= $OUTPUT->render_from_template('core_form/filetypes-descriptions', $filetypedescriptions);
307        }
308
309        return $html;
310    }
311
312    public function export_for_template(renderer_base $output) {
313        $context = $this->export_for_template_base($output);
314        $context['html'] = $this->toHtml();
315        return $context;
316    }
317
318    /**
319     * Check that all files have the allowed type.
320     *
321     * @param int $value Draft item id with the uploaded files.
322     * @return string|null Validation error message or null.
323     */
324    public function validateSubmitValue($value) {
325
326        if (empty($value)) {
327            return;
328        }
329
330        $filetypesutil = new \core_form\filetypes_util();
331        $allowlist = $filetypesutil->normalize_file_types($this->_options['accepted_types']);
332
333        if (empty($allowlist) || $allowlist === ['*']) {
334            // Any file type is allowed, nothing to check here.
335            return;
336        }
337
338        $draftfiles = file_get_all_files_in_draftarea($value);
339        $wrongfiles = array();
340
341        if (empty($draftfiles)) {
342            // No file uploaded, nothing to check here.
343            return;
344        }
345
346        foreach ($draftfiles as $file) {
347            if (!$filetypesutil->is_allowed_file_type($file->filename, $allowlist)) {
348                $wrongfiles[] = $file->filename;
349            }
350        }
351
352        if ($wrongfiles) {
353            $a = array(
354                'allowlist' => implode(', ', $allowlist),
355                'wrongfiles' => implode(', ', $wrongfiles),
356            );
357            return get_string('err_wrongfileextension', 'core_form', $a);
358        }
359
360        return;
361    }
362}
363
364/**
365 * Data structure representing a file manager.
366 *
367 * This class defines the data structure for file mnager
368 *
369 * @package   core_form
370 * @copyright 2010 Dongsheng Cai
371 * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
372 * @todo      do not use this abstraction (skodak)
373 */
374class form_filemanager implements renderable {
375    /** @var stdClass $options options for filemanager */
376    public $options;
377
378    /**
379     * Constructor
380     *
381     * @param stdClass $options options for filemanager
382     *   default options are:
383     *       maxbytes=>-1,
384     *       areamaxbytes => FILE_AREA_MAX_BYTES_UNLIMITED,
385     *       maxfiles=>-1,
386     *       itemid=>0,
387     *       subdirs=>false,
388     *       client_id=>uniqid(),
389     *       acepted_types=>'*',
390     *       return_types=>FILE_INTERNAL,
391     *       context=>$PAGE->context,
392     *       author=>fullname($USER),
393     *       licenses=>array build from $CFG->licenses,
394     *       defaultlicense=>$CFG->sitedefaultlicense
395     */
396    public function __construct(stdClass $options) {
397        global $CFG, $USER, $PAGE;
398        require_once($CFG->dirroot. '/repository/lib.php');
399        require_once($CFG->libdir . '/licenselib.php');
400        $defaults = array(
401            'maxbytes'=>-1,
402            'areamaxbytes' => FILE_AREA_MAX_BYTES_UNLIMITED,
403            'maxfiles'=>-1,
404            'itemid'=>0,
405            'subdirs'=>0,
406            'client_id'=>uniqid(),
407            'accepted_types'=>'*',
408            'return_types'=>FILE_INTERNAL,
409            'context'=>$PAGE->context,
410            'author'=>fullname($USER),
411            'licenses'=>array()
412            );
413
414        $defaults['licenses'] = license_manager::get_licenses();
415
416        if (!empty($CFG->sitedefaultlicense)) {
417            $defaults['defaultlicense'] = $CFG->sitedefaultlicense;
418        }
419        foreach ($defaults as $key=>$value) {
420            // Using !isset() prevents us from overwriting falsey values with defaults (as empty() did).
421            if (!isset($options->$key)) {
422                $options->$key = $value;
423            }
424        }
425
426        $fs = get_file_storage();
427
428        // initilise options, getting files in root path
429        $this->options = file_get_drafarea_files($options->itemid, '/');
430
431        // calculate file count
432        $usercontext = context_user::instance($USER->id);
433        $files = $fs->get_area_files($usercontext->id, 'user', 'draft', $options->itemid, 'id', false);
434        $filecount = count($files);
435        $this->options->filecount = $filecount;
436
437        // copying other options
438        foreach ($options as $name=>$value) {
439            $this->options->$name = $value;
440        }
441
442        // calculate the maximum file size as minimum from what is specified in filepicker options,
443        // course options, global configuration and php settings
444        $coursebytes = $maxbytes = 0;
445        list($context, $course, $cm) = get_context_info_array($this->options->context->id);
446        if (is_object($course)) {
447            $coursebytes = $course->maxbytes;
448        }
449        if (!empty($this->options->maxbytes) && $this->options->maxbytes > 0) {
450            $maxbytes = $this->options->maxbytes;
451        }
452        $this->options->maxbytes = get_user_max_upload_file_size($context, $CFG->maxbytes, $coursebytes, $maxbytes);
453
454        $this->options->userprefs = array();
455        $this->options->userprefs['recentviewmode'] = get_user_preferences('filemanager_recentviewmode', '');
456        user_preference_allow_ajax_update('filemanager_recentviewmode', PARAM_INT);
457
458        // building file picker options
459        $params = new stdClass();
460        $params->accepted_types = $options->accepted_types;
461        $params->return_types = $options->return_types;
462        $params->context = $options->context;
463        $params->env = 'filemanager';
464        $params->disable_types = !empty($options->disable_types)?$options->disable_types:array();
465        $filepicker_options = initialise_filepicker($params);
466        $this->options->filepicker = $filepicker_options;
467    }
468
469    public function get_nonjsurl() {
470        global $PAGE;
471        return new moodle_url('/repository/draftfiles_manager.php', array(
472            'env'=>'filemanager',
473            'action'=>'browse',
474            'itemid'=>$this->options->itemid,
475            'subdirs'=>$this->options->subdirs,
476            'maxbytes'=>$this->options->maxbytes,
477            'areamaxbytes' => $this->options->areamaxbytes,
478            'maxfiles'=>$this->options->maxfiles,
479            'ctx_id'=>$PAGE->context->id, // TODO ?
480            'course'=>$PAGE->course->id, // TODO ?
481            'sesskey'=>sesskey(),
482            ));
483    }
484}
485