MDL-24144 hiding of empty folders in repository/local
[moodle.git] / lib / filebrowser / file_info_context_course.php
1 <?php
3 // This file is part of Moodle - http://moodle.org/
4 //
5 // Moodle is free software: you can redistribute it and/or modify
6 // it under the terms of the GNU General Public License as published by
7 // the Free Software Foundation, either version 3 of the License, or
8 // (at your option) any later version.
9 //
10 // Moodle is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
19 /**
20  * Utility class for browsing of course files.
21  *
22  * @package    core
23  * @subpackage filebrowser
24  * @copyright  2008 Petr Skoda (http://skodak.org)
25  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
26  */
28 defined('MOODLE_INTERNAL') || die();
30 /**
31  * Represents a course context in the tree navigated by @see{file_browser}.
32  *
33  * @package    core
34  * @subpackage filebrowser
35  * @copyright  2008 Petr Skoda (http://skodak.org)
36  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
37  */
38 class file_info_context_course extends file_info {
39     protected $course;
41     public function __construct($browser, $context, $course) {
42         parent::__construct($browser, $context);
43         $this->course   = $course;
44     }
46     /**
47      * Return information about this specific context level
48      *
49      * @param $component
50      * @param $filearea
51      * @param $itemid
52      * @param $filepath
53      * @param $filename
54      */
55     public function get_file_info($component, $filearea, $itemid, $filepath, $filename) {
56         global $DB;
58         if (!$this->course->visible and !has_capability('moodle/course:viewhiddencourses', $this->context)) {
59             return null;
60         }
62         if (empty($component)) {
63             return $this;
64         }
66         $methodname = "get_area_{$component}_{$filearea}";
68         if (method_exists($this, $methodname)) {
69             return $this->$methodname($itemid, $filepath, $filename);
70         }
72         return null;
73     }
75     protected function get_area_course_summary($itemid, $filepath, $filename) {
76         global $CFG;
78         if (!has_capability('moodle/course:update', $this->context)) {
79             return null;
80         }
81         if (is_null($itemid)) {
82             return $this;
83         }
85         $fs = get_file_storage();
87         $filepath = is_null($filepath) ? '/' : $filepath;
88         $filename = is_null($filename) ? '.' : $filename;
89         if (!$storedfile = $fs->get_file($this->context->id, 'course', 'summary', 0, $filepath, $filename)) {
90             if ($filepath === '/' and $filename === '.') {
91                 $storedfile = new virtual_root_file($this->context->id, 'course', 'summary', 0);
92             } else {
93                 // not found
94                 return null;
95             }
96         }
97         $urlbase = $CFG->wwwroot.'/pluginfile.php';
98         return new file_info_stored($this->browser, $this->context, $storedfile, $urlbase, get_string('areacourseintro', 'repository'), false, true, true, false);
99     }
102     protected function get_area_course_section($itemid, $filepath, $filename) {
103         global $CFG, $DB;
105         if (!has_capability('moodle/course:update', $this->context)) {
106             return null;
107         }
109         if (empty($itemid)) {
110             // list all sections
111             return new file_info_area_course_section($this->browser, $this->context, $this->course, $this);
112         }
114         if (!$section = $DB->get_record('course_sections', array('course'=>$this->course->id, 'id'=>$itemid))) {
115             return null; // does not exist
116         }
118         $fs = get_file_storage();
120         $filepath = is_null($filepath) ? '/' : $filepath;
121         $filename = is_null($filename) ? '.' : $filename;
122         if (!$storedfile = $fs->get_file($this->context->id, 'course', 'section', $itemid, $filepath, $filename)) {
123             if ($filepath === '/' and $filename === '.') {
124                 $storedfile = new virtual_root_file($this->context->id, 'course', 'section', $itemid);
125             } else {
126                 // not found
127                 return null;
128             }
129         }
130         $urlbase = $CFG->wwwroot.'/pluginfile.php';
131         return new file_info_stored($this->browser, $this->context, $storedfile, $urlbase, $section->section, true, true, true, false);
132     }
135     protected function get_area_course_legacy($itemid, $filepath, $filename) {
136         if (!has_capability('moodle/course:managefiles', $this->context)) {
137             return null;
138         }
140         if ($this->course->id != SITEID and $this->course->legacyfiles != 2) {
141             // bad luck, legacy course files not used any more
142         }
144         if (is_null($itemid)) {
145             return $this;
146         }
148         $fs = get_file_storage();
150         $filepath = is_null($filepath) ? '/' : $filepath;
151         $filename = is_null($filename) ? '.' : $filename;
152         if (!$storedfile = $fs->get_file($this->context->id, 'course', 'legacy', 0, $filepath, $filename)) {
153             if ($filepath === '/' and $filename === '.') {
154                 $storedfile = new virtual_root_file($this->context->id, 'course', 'legacy', 0);
155             } else {
156                 // not found
157                 return null;
158             }
159         }
161         return new file_info_area_course_legacy($this->browser, $this->context, $storedfile);
162     }
164     protected function get_area_backup_course($itemid, $filepath, $filename) {
165         global $CFG;
167         if (!has_capability('moodle/backup:backupcourse', $this->context) and !has_capability('moodle/restore:restorecourse', $this->context)) {
168             return null;
169         }
170         if (is_null($itemid)) {
171             return $this;
172         }
174         $fs = get_file_storage();
176         $filepath = is_null($filepath) ? '/' : $filepath;
177         $filename = is_null($filename) ? '.' : $filename;
178         if (!$storedfile = $fs->get_file($this->context->id, 'backup', 'course', 0, $filepath, $filename)) {
179             if ($filepath === '/' and $filename === '.') {
180                 $storedfile = new virtual_root_file($this->context->id, 'backup', 'course', 0);
181             } else {
182                 // not found
183                 return null;
184             }
185         }
187         $downloadable = has_capability('moodle/backup:downloadfile', $this->context);
188         $uploadable   = has_capability('moodle/restore:uploadfile', $this->context);
190         $urlbase = $CFG->wwwroot.'/pluginfile.php';
191         return new file_info_stored($this->browser, $this->context, $storedfile, $urlbase, get_string('coursebackup', 'repository'), false, $downloadable, $uploadable, false);
192     }
194     protected function get_area_backup_section($itemid, $filepath, $filename) {
195         global $CFG, $DB;
197         if (!has_capability('moodle/backup:backupcourse', $this->context) and !has_capability('moodle/restore:restorecourse', $this->context)) {
198             return null;
199         }
201         if (empty($itemid)) {
202             // list all sections
203             return new file_info_area_backup_section($this->browser, $this->context, $this->course, $this);
204         }
206         if (!$section = $DB->get_record('course_sections', array('course'=>$this->course->id, 'id'=>$itemid))) {
207             return null; // does not exist
208         }
210         $fs = get_file_storage();
212         $filepath = is_null($filepath) ? '/' : $filepath;
213         $filename = is_null($filename) ? '.' : $filename;
214         if (!$storedfile = $fs->get_file($this->context->id, 'backup', 'section', $itemid, $filepath, $filename)) {
215             if ($filepath === '/' and $filename === '.') {
216                 $storedfile = new virtual_root_file($this->context->id, 'backup', 'section', $itemid);
217             } else {
218                 // not found
219                 return null;
220             }
221         }
223         $downloadable = has_capability('moodle/backup:downloadfile', $this->context);
224         $uploadable   = has_capability('moodle/restore:uploadfile', $this->context);
226         $urlbase = $CFG->wwwroot.'/pluginfile.php';
227         return new file_info_stored($this->browser, $this->context, $storedfile, $urlbase, $section->id, true, $downloadable, $uploadable, false);
228     }
230     public function get_visible_name() {
231         return ($this->course->id == SITEID) ? get_string('frontpage', 'admin') : format_string($this->course->fullname, true, array('context'=>$this->context));
232     }
234     /**
235      * Can I add new files or directories?
236      * @return bool
237      */
238     public function is_writable() {
239         return false;
240     }
242     /**
243      * Is directory?
244      * @return bool
245      */
246     public function is_directory() {
247         return true;
248     }
250     /**
251      * Returns list of children.
252      * @return array of file_info instances
253      */
254     public function get_children() {
255         $children = array();
257         if ($child = $this->get_area_course_summary(0, '/', '.')) {
258             $children[] = $child;
259         }
260         if ($child = $this->get_area_course_section(null, null, null)) {
261             $children[] = $child;
262         }
263         if ($child = $this->get_area_backup_section(null, null, null)) {
264             $children[] = $child;
265         }
266         if ($child = $this->get_area_backup_course(0, '/', '.')) {
267             $children[] = $child;
268         }
269         if ($child = $this->get_area_course_legacy(0, '/', '.')) {
270             $children[] = $child;
271         }
273         // now list all modules
274         $modinfo = get_fast_modinfo($this->course);
275         foreach ($modinfo->cms as $cminfo) {
276             if (empty($cminfo->uservisible)) {
277                 continue;
278             }
279             $modcontext = get_context_instance(CONTEXT_MODULE, $cminfo->id);
280             if ($child = $this->browser->get_file_info($modcontext)) {
281                 $children[] = $child;
282             }
283         }
285         return $children;
286     }
288     /**
289      * Returns parent file_info instance
290      * @return file_info or null for root
291      */
292     public function get_parent() {
293         //TODO: error checking if get_parent_contextid() returns false
294         $pcid = get_parent_contextid($this->context);
295         $parent = get_context_instance_by_id($pcid);
296         return $this->browser->get_file_info($parent);
297     }
301 /**
302  * Subclass of file_info_stored for files in the course files area.
303  *
304  * @package    core
305  * @subpackage filebrowser
306  * @copyright  2008 Petr Skoda (http://skodak.org)
307  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
308  */
309 class file_info_area_course_legacy extends file_info_stored {
310     public function __construct($browser, $context, $storedfile) {
311         global $CFG;
312         $urlbase = $CFG->wwwroot.'/file.php';
313         parent::__construct($browser, $context, $storedfile, $urlbase, get_string('coursefiles'), false, true, true, false);
314     }
316     /**
317      * Returns file download url
318      * @param bool $forcedownload
319      * @param bool $htts force https
320      * @return string url
321      */
322     public function get_url($forcedownload=false, $https=false) {
323         if (!$this->is_readable()) {
324             return null;
325         }
327         if ($this->lf->is_directory()) {
328             return null;
329         }
331         $filepath = $this->lf->get_filepath();
332         $filename = $this->lf->get_filename();
333         $courseid = $this->context->instanceid;
335         $path = '/'.$courseid.$filepath.$filename;
337         return file_encode_url($this->urlbase, $path, $forcedownload, $https);
338     }
340     /**
341      * Returns list of children.
342      * @return array of file_info instances
343      */
344     public function get_children() {
345         if (!$this->lf->is_directory()) {
346             return array();
347         }
349         $result = array();
350         $fs = get_file_storage();
352         $storedfiles = $fs->get_directory_files($this->context->id, 'course', 'legacy', 0, $this->lf->get_filepath(), false, true, "filepath ASC, filename ASC");
353         foreach ($storedfiles as $file) {
354             $result[] = new file_info_area_course_legacy($this->browser, $this->context, $file);
355         }
357         return $result;
358     }
361 /**
362  * Represents a course category context in the tree navigated by @see{file_browser}.
363  *
364  * @package    core
365  * @subpackage filebrowser
366  * @copyright  2008 Petr Skoda (http://skodak.org)
367  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
368  */
369 class file_info_area_course_section extends file_info {
370     protected $course;
371     protected $courseinfo;
373     public function __construct($browser, $context, $course, file_info_context_course $courseinfo) {
374         parent::__construct($browser, $context);
375         $this->course     = $course;
376         $this->courseinfo = $courseinfo;
377     }
379     /**
380      * Returns list of standard virtual file/directory identification.
381      * The difference from stored_file parameters is that null values
382      * are allowed in all fields
383      * @return array with keys contextid, filearea, itemid, filepath and filename
384      */
385     public function get_params() {
386         return array('contextid' => $this->context->id,
387                      'component' => 'course',
388                      'filearea'  => 'section',
389                      'itemid'    => null,
390                      'filepath'  => null,
391                      'filename'  => null);
392     }
394     /**
395      * Returns localised visible name.
396      * @return string
397      */
398     public function get_visible_name() {
399         $format = $this->course->format;
400         $sectionsname = get_string("coursesectionsummaries");
402         return $sectionsname;
403     }
405     /**
406      * Can I add new files or directories?
407      * @return bool
408      */
409     public function is_writable() {
410         return false;
411     }
413     /**
414      * Is this empty area?
415      *
416      * @return bool
417      */
418     public function is_empty_area() {
419         $fs = get_file_storage();
420         return $fs->is_area_empty($this->context->id, 'course', 'section');
421     }
423     /**
424      * Is directory?
425      * @return bool
426      */
427     public function is_directory() {
428         return true;
429     }
431     /**
432      * Returns list of children.
433      * @return array of file_info instances
434      */
435     public function get_children() {
436         global $DB;
438         $children = array();
440         $course_sections = $DB->get_records('course_sections', array('course'=>$this->course->id), 'section');
441         foreach ($course_sections as $section) {
442             if ($child = $this->courseinfo->get_file_info('course', 'section', $section->id, '/', '.')) {
443                 $children[] = $child;
444             }
445         }
447         return $children;
448     }
450     /**
451      * Returns parent file_info instance
452      * @return file_info or null for root
453      */
454     public function get_parent() {
455         return $this->courseinfo;
456     }
460 /**
461  * Implementation of course section backup area
462  *
463  * @package    core
464  * @subpackage filebrowser
465  * @copyright  2008 Petr Skoda (http://skodak.org)
466  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
467  */
468 class file_info_area_backup_section extends file_info {
469     protected $course;
470     protected $courseinfo;
472     public function __construct($browser, $context, $course, file_info_context_course $courseinfo) {
473         parent::__construct($browser, $context);
474         $this->course     = $course;
475         $this->courseinfo = $courseinfo;
476     }
478     /**
479      * Returns list of standard virtual file/directory identification.
480      * The difference from stored_file parameters is that null values
481      * are allowed in all fields
482      * @return array with keys contextid, component, filearea, itemid, filepath and filename
483      */
484     public function get_params() {
485         return array('contextid' => $this->context->id,
486                      'component' => 'backup',
487                      'filearea'  => 'section',
488                      'itemid'    => null,
489                      'filepath'  => null,
490                      'filename'  => null);
491     }
493     /**
494      * Returns localised visible name.
495      * @return string
496      */
497     public function get_visible_name() {
498         $format = $this->course->format;
499         $sectionsname = get_string('sectionbackup', 'repository');
501         return $sectionsname;
502     }
504     /**
505      * Can I add new files or directories?
506      * @return bool
507      */
508     public function is_writable() {
509         return false;
510     }
512     /**
513      * Is this empty area?
514      *
515      * @return bool
516      */
517     public function is_empty_area() {
518         $fs = get_file_storage();
519         return $fs->is_area_empty($this->context->id, 'backup', 'section');
520     }
522     /**
523      * Is directory?
524      * @return bool
525      */
526     public function is_directory() {
527         return true;
528     }
530     /**
531      * Returns list of children.
532      * @return array of file_info instances
533      */
534     public function get_children() {
535         global $DB;
537         $children = array();
539         $course_sections = $DB->get_records('course_sections', array('course'=>$this->course->id), 'section');
540         foreach ($course_sections as $section) {
541             if ($child = $this->courseinfo->get_file_info('backup', 'section', $section->id, '/', '.')) {
542                 $children[] = $child;
543             }
544         }
546         return $children;
547     }
549     /**
550      * Returns parent file_info instance
551      * @return file_info or null for root
552      */
553     public function get_parent() {
554         return $this->browser->get_file_info($this->context);
555     }