Search moodle.org's
Developer Documentation

See Release Notes

  • Bug fixes for general core bugs in 3.11.x will end 14 Nov 2022 (12 months plus 6 months extension).
  • Bug fixes for security issues in 3.11.x will end 13 Nov 2023 (18 months plus 12 months extension).
  • PHP version: minimum PHP 7.3.0 Note: minimum PHP version has increased since Moodle 3.10. PHP 7.4.x is supported too.
   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   * Utility class for browsing of course files.
  20   *
  21   * @package    core_files
  22   * @copyright  2008 Petr Skoda (http://skodak.org)
  23   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  24   */
  25  
  26  defined('MOODLE_INTERNAL') || die();
  27  
  28  /**
  29   * Represents a course context in the tree navigated by {@link file_browser}.
  30   *
  31   * @package    core_files
  32   * @copyright  2008 Petr Skoda (http://skodak.org)
  33   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  34   */
  35  class file_info_context_course extends file_info {
  36      /** @var stdClass course object */
  37      protected $course;
  38  
  39      /** @var file_info_context_module[] cached child modules. See {@link get_child_module()} */
  40      protected $childrenmodules = [];
  41  
  42      /**
  43       * Constructor
  44       *
  45       * @param file_browser $browser file browser instance
  46       * @param stdClass $context context object
  47       * @param stdClass $course course object
  48       */
  49      public function __construct($browser, $context, $course) {
  50          parent::__construct($browser, $context);
  51          $this->course   = $course;
  52      }
  53  
  54      /**
  55       * Return information about this specific context level
  56       *
  57       * @param string $component component
  58       * @param string $filearea file area
  59       * @param int $itemid item ID
  60       * @param string $filepath file path
  61       * @param string $filename file name
  62       * @return file_info|null file_info instance or null if not found or access not allowed
  63       */
  64      public function get_file_info($component, $filearea, $itemid, $filepath, $filename) {
  65          // try to emulate require_login() tests here
  66          if (!isloggedin()) {
  67              return null;
  68          }
  69  
  70          if (!$this->course->visible and !has_capability('moodle/course:viewhiddencourses', $this->context)) {
  71              return null;
  72          }
  73  
  74          if (!is_viewing($this->context) and !$this->browser->is_enrolled($this->course->id)) {
  75              // no peaking here if not enrolled or inspector
  76              return null;
  77          }
  78  
  79          if (empty($component)) {
  80              return $this;
  81          }
  82  
  83          $methodname = "get_area_{$component}_{$filearea}";
  84  
  85          if (method_exists($this, $methodname)) {
  86              return $this->$methodname($itemid, $filepath, $filename);
  87          }
  88  
  89          return null;
  90      }
  91  
  92      /**
  93       * Returns list of areas inside this course
  94       *
  95       * @param string $extensions Only return areas that have files with these extensions
  96       * @param bool $returnemptyfolders return all areas always, if true it will ignore the previous argument
  97       * @return array
  98       */
  99      protected function get_course_areas($extensions = '*', $returnemptyfolders = false) {
 100          global $DB;
 101  
 102          $allareas = [
 103              'course_summary',
 104              'course_overviewfiles',
 105              'course_section',
 106              'backup_section',
 107              'backup_course',
 108              'backup_automated',
 109              'course_legacy'
 110          ];
 111  
 112          if ($returnemptyfolders) {
 113              return $allareas;
 114          }
 115  
 116          $params1 = ['contextid' => $this->context->id, 'emptyfilename' => '.'];
 117          $sql1 = "SELECT " . $DB->sql_concat('f.component', "'_'", 'f.filearea') . "
 118              FROM {files} f
 119              WHERE f.filename <> :emptyfilename AND f.contextid = :contextid ";
 120          $sql3 = ' GROUP BY f.component, f.filearea';
 121          list($sql2, $params2) = $this->build_search_files_sql($extensions);
 122          $areaswithfiles = $DB->get_fieldset_sql($sql1 . $sql2 . $sql3, array_merge($params1, $params2));
 123  
 124          return array_intersect($allareas, $areaswithfiles);
 125      }
 126  
 127      /**
 128       * Gets a stored file for the course summary filearea directory
 129       *
 130       * @param int $itemid item ID
 131       * @param string $filepath file path
 132       * @param string $filename file name
 133       * @return file_info|null file_info instance or null if not found or access not allowed
 134       */
 135      protected function get_area_course_summary($itemid, $filepath, $filename) {
 136          global $CFG;
 137  
 138          if (!has_capability('moodle/course:update', $this->context)) {
 139              return null;
 140          }
 141          if (is_null($itemid)) {
 142              return $this;
 143          }
 144  
 145          $fs = get_file_storage();
 146  
 147          $filepath = is_null($filepath) ? '/' : $filepath;
 148          $filename = is_null($filename) ? '.' : $filename;
 149          if (!$storedfile = $fs->get_file($this->context->id, 'course', 'summary', 0, $filepath, $filename)) {
 150              if ($filepath === '/' and $filename === '.') {
 151                  $storedfile = new virtual_root_file($this->context->id, 'course', 'summary', 0);
 152              } else {
 153                  // not found
 154                  return null;
 155              }
 156          }
 157          $urlbase = $CFG->wwwroot.'/pluginfile.php';
 158          return new file_info_stored($this->browser, $this->context, $storedfile, $urlbase, get_string('areacourseintro', 'repository'), false, true, true, false);
 159      }
 160  
 161      /**
 162       * Gets a stored file for the course images filearea directory
 163       *
 164       * @param int $itemid item ID
 165       * @param string $filepath file path
 166       * @param string $filename file name
 167       * @return file_info|null file_info instance or null if not found or access not allowed
 168       */
 169      protected function get_area_course_overviewfiles($itemid, $filepath, $filename) {
 170          global $CFG;
 171  
 172          if (!has_capability('moodle/course:update', $this->context)) {
 173              return null;
 174          }
 175          if (is_null($itemid)) {
 176              return $this;
 177          }
 178  
 179          $fs = get_file_storage();
 180  
 181          $filepath = is_null($filepath) ? '/' : $filepath;
 182          $filename = is_null($filename) ? '.' : $filename;
 183          if (!$storedfile = $fs->get_file($this->context->id, 'course', 'overviewfiles', 0, $filepath, $filename)) {
 184              if ($filepath === '/' and $filename === '.') {
 185                  $storedfile = new virtual_root_file($this->context->id, 'course', 'overviewfiles', 0);
 186              } else {
 187                  // not found
 188                  return null;
 189              }
 190          }
 191          $urlbase = $CFG->wwwroot.'/pluginfile.php';
 192          return new file_info_stored($this->browser, $this->context, $storedfile, $urlbase, get_string('areacourseoverviewfiles', 'repository'), false, true, true, false);
 193      }
 194  
 195      /**
 196       * Gets a stored file for the course section filearea directory
 197       *
 198       * @param int $itemid item ID
 199       * @param string $filepath file path
 200       * @param string $filename file name
 201       * @return file_info|null file_info instance or null if not found or access not allowed
 202       */
 203      protected function get_area_course_section($itemid, $filepath, $filename) {
 204          global $CFG, $DB;
 205  
 206          if (!has_capability('moodle/course:update', $this->context)) {
 207              return null;
 208          }
 209  
 210          if (empty($itemid)) {
 211              // list all sections
 212              return new file_info_area_course_section($this->browser, $this->context, $this->course, $this);
 213          }
 214  
 215          if (!$section = $DB->get_record('course_sections', array('course'=>$this->course->id, 'id'=>$itemid))) {
 216              return null; // does not exist
 217          }
 218  
 219          $fs = get_file_storage();
 220  
 221          $filepath = is_null($filepath) ? '/' : $filepath;
 222          $filename = is_null($filename) ? '.' : $filename;
 223          if (!$storedfile = $fs->get_file($this->context->id, 'course', 'section', $itemid, $filepath, $filename)) {
 224              if ($filepath === '/' and $filename === '.') {
 225                  $storedfile = new virtual_root_file($this->context->id, 'course', 'section', $itemid);
 226              } else {
 227                  // not found
 228                  return null;
 229              }
 230          }
 231          $urlbase = $CFG->wwwroot.'/pluginfile.php';
 232          require_once($CFG->dirroot.'/course/lib.php');
 233          $sectionname = get_section_name($this->course, $section);
 234          return new file_info_stored($this->browser, $this->context, $storedfile, $urlbase, $sectionname, true, true, true, false);
 235      }
 236  
 237      /**
 238       * Gets a stored file for the course legacy filearea directory
 239       *
 240       * @param int $itemid item ID
 241       * @param string $filepath file path
 242       * @param string $filename file name
 243       * @return file_info|null file_info instance or null if not found or access not allowed
 244       */
 245      protected function get_area_course_legacy($itemid, $filepath, $filename) {
 246          if (!has_capability('moodle/course:managefiles', $this->context)) {
 247              return null;
 248          }
 249  
 250          if ($this->course->id != SITEID and $this->course->legacyfiles != 2) {
 251              // bad luck, legacy course files not used any more
 252          }
 253  
 254          if (is_null($itemid)) {
 255              return $this;
 256          }
 257  
 258          $fs = get_file_storage();
 259  
 260          $filepath = is_null($filepath) ? '/' : $filepath;
 261          $filename = is_null($filename) ? '.' : $filename;
 262          if (!$storedfile = $fs->get_file($this->context->id, 'course', 'legacy', 0, $filepath, $filename)) {
 263              if ($filepath === '/' and $filename === '.') {
 264                  $storedfile = new virtual_root_file($this->context->id, 'course', 'legacy', 0);
 265              } else {
 266                  // not found
 267                  return null;
 268              }
 269          }
 270  
 271          return new file_info_area_course_legacy($this->browser, $this->context, $storedfile);
 272      }
 273  
 274      /**
 275       * Gets a stored file for the backup course filearea directory
 276       *
 277       * @param int $itemid item ID
 278       * @param string $filepath file path
 279       * @param string $filename file name
 280       * @return file_info|null file_info instance or null if not found or access not allowed
 281       */
 282      protected function get_area_backup_course($itemid, $filepath, $filename) {
 283          global $CFG;
 284  
 285          if (!has_capability('moodle/backup:backupcourse', $this->context) and !has_capability('moodle/restore:restorecourse', $this->context)) {
 286              return null;
 287          }
 288          if (is_null($itemid)) {
 289              return $this;
 290          }
 291  
 292          $fs = get_file_storage();
 293  
 294          $filepath = is_null($filepath) ? '/' : $filepath;
 295          $filename = is_null($filename) ? '.' : $filename;
 296          if (!$storedfile = $fs->get_file($this->context->id, 'backup', 'course', 0, $filepath, $filename)) {
 297              if ($filepath === '/' and $filename === '.') {
 298                  $storedfile = new virtual_root_file($this->context->id, 'backup', 'course', 0);
 299              } else {
 300                  // not found
 301                  return null;
 302              }
 303          }
 304  
 305          $downloadable = has_capability('moodle/backup:downloadfile', $this->context);
 306          $uploadable   = has_capability('moodle/restore:uploadfile', $this->context);
 307  
 308          $urlbase = $CFG->wwwroot.'/pluginfile.php';
 309          return new file_info_stored($this->browser, $this->context, $storedfile, $urlbase, get_string('coursebackup', 'repository'), false, $downloadable, $uploadable, false);
 310      }
 311  
 312      /**
 313       * Gets a stored file for the automated backup filearea directory
 314       *
 315       * @param int $itemid item ID
 316       * @param string $filepath file path
 317       * @param string $filename file name
 318       * @return file_info|null
 319       */
 320      protected function get_area_backup_automated($itemid, $filepath, $filename) {
 321          global $CFG;
 322  
 323          if (!has_capability('moodle/restore:viewautomatedfilearea', $this->context)) {
 324              return null;
 325          }
 326          if (is_null($itemid)) {
 327              return $this;
 328          }
 329  
 330          $fs = get_file_storage();
 331  
 332          $filepath = is_null($filepath) ? '/' : $filepath;
 333          $filename = is_null($filename) ? '.' : $filename;
 334          if (!$storedfile = $fs->get_file($this->context->id, 'backup', 'automated', 0, $filepath, $filename)) {
 335              if ($filepath === '/' and $filename === '.') {
 336                  $storedfile = new virtual_root_file($this->context->id, 'backup', 'automated', 0);
 337              } else {
 338                  // not found
 339                  return null;
 340              }
 341          }
 342  
 343          // Automated backup files are only downloadable if the user has both 'backup:downloadfile and 'restore:userinfo'.
 344          $downloadable = has_capability('moodle/backup:downloadfile', $this->context) &&
 345                          has_capability('moodle/restore:userinfo', $this->context);
 346          $uploadable   = false;
 347  
 348          $urlbase = $CFG->wwwroot.'/pluginfile.php';
 349          return new file_info_stored($this->browser, $this->context, $storedfile, $urlbase, get_string('automatedbackup', 'repository'), true, $downloadable, $uploadable, false);
 350      }
 351  
 352      /**
 353       * Gets a stored file for the backup section filearea directory
 354       *
 355       * @param int $itemid item ID
 356       * @param string $filepath file path
 357       * @param string $filename file name
 358       * @return file_info|null file_info instance or null if not found or access not allowed
 359       */
 360      protected function get_area_backup_section($itemid, $filepath, $filename) {
 361          global $CFG, $DB;
 362  
 363          if (!has_capability('moodle/backup:backupcourse', $this->context) and !has_capability('moodle/restore:restorecourse', $this->context)) {
 364              return null;
 365          }
 366  
 367          if (empty($itemid)) {
 368              // list all sections
 369              return new file_info_area_backup_section($this->browser, $this->context, $this->course, $this);
 370          }
 371  
 372          if (!$section = $DB->get_record('course_sections', array('course'=>$this->course->id, 'id'=>$itemid))) {
 373              return null; // does not exist
 374          }
 375  
 376          $fs = get_file_storage();
 377  
 378          $filepath = is_null($filepath) ? '/' : $filepath;
 379          $filename = is_null($filename) ? '.' : $filename;
 380          if (!$storedfile = $fs->get_file($this->context->id, 'backup', 'section', $itemid, $filepath, $filename)) {
 381              if ($filepath === '/' and $filename === '.') {
 382                  $storedfile = new virtual_root_file($this->context->id, 'backup', 'section', $itemid);
 383              } else {
 384                  // not found
 385                  return null;
 386              }
 387          }
 388  
 389          $downloadable = has_capability('moodle/backup:downloadfile', $this->context);
 390          $uploadable   = has_capability('moodle/restore:uploadfile', $this->context);
 391  
 392          $urlbase = $CFG->wwwroot.'/pluginfile.php';
 393          return new file_info_stored($this->browser, $this->context, $storedfile, $urlbase, $section->id, true, $downloadable, $uploadable, false);
 394      }
 395  
 396      /**
 397       * Returns localised visible name.
 398       *
 399       * @return string
 400       */
 401      public function get_visible_name() {
 402          return ($this->course->id == SITEID) ? get_string('frontpage', 'admin') : format_string(get_course_display_name_for_list($this->course), true, array('context'=>$this->context));
 403      }
 404  
 405      /**
 406       * Whether or not new files or directories can be added
 407       *
 408       * @return bool
 409       */
 410      public function is_writable() {
 411          return false;
 412      }
 413  
 414      /**
 415       * Whether or not this is a directory
 416       *
 417       * @return bool
 418       */
 419      public function is_directory() {
 420          return true;
 421      }
 422  
 423      /**
 424       * Returns list of children.
 425       *
 426       * @return array of file_info instances
 427       */
 428      public function get_children() {
 429          return $this->get_filtered_children('*', false, true);
 430      }
 431  
 432      /**
 433       * Returns the child module if it is accessible by the current user
 434       *
 435       * @param cm_info|int $cm
 436       * @return file_info_context_module|null
 437       */
 438      protected function get_child_module($cm) {
 439          $cmid = is_object($cm) ? $cm->id : $cm;
 440          if (!array_key_exists($cmid, $this->childrenmodules)) {
 441              $this->childrenmodules[$cmid] = null;
 442              if (!($cm instanceof cm_info)) {
 443                  $cms = get_fast_modinfo($this->course)->cms;
 444                  $cm = array_key_exists($cmid, $cms) ? $cms[$cmid] : null;
 445              }
 446              if ($cm && $cm->uservisible) {
 447                  $this->childrenmodules[$cmid] = new file_info_context_module($this->browser,
 448                      $cm->context, $this->course, $cm, $cm->modname);
 449              }
 450          }
 451          return $this->childrenmodules[$cmid];
 452      }
 453  
 454      /**
 455       * Help function to return files matching extensions or their count
 456       *
 457       * @param string|array $extensions, either '*' or array of lowercase extensions, i.e. array('.gif','.jpg')
 458       * @param bool|int $countonly if false returns the children, if an int returns just the
 459       *    count of children but stops counting when $countonly number of children is reached
 460       * @param bool $returnemptyfolders if true returns items that don't have matching files inside
 461       * @return array|int array of file_info instances or the count
 462       */
 463      private function get_filtered_children($extensions = '*', $countonly = false, $returnemptyfolders = false) {
 464          $children = array();
 465  
 466          $courseareas = $this->get_course_areas($extensions, $returnemptyfolders);
 467          foreach ($courseareas as $areaname) {
 468              $area = explode('_', $areaname, 2);
 469              if ($child = $this->get_file_info($area[0], $area[1], 0, '/', '.')) {
 470                  $children[] = $child;
 471                  if (($countonly !== false) && count($children) >= $countonly) {
 472                      return $countonly;
 473                  }
 474              }
 475          }
 476  
 477          $cnt = count($children);
 478          if (!has_capability('moodle/course:managefiles', $this->context)) {
 479              // 'managefiles' capability is checked in every activity module callback.
 480              // Don't even waste time on retrieving the modules if we can't browse the files anyway
 481          } else {
 482              if ($returnemptyfolders) {
 483                  $modinfo = get_fast_modinfo($this->course);
 484                  foreach ($modinfo->cms as $cminfo) {
 485                      if ($child = $this->get_child_module($cminfo)) {
 486                          $children[] = $child;
 487                          $cnt++;
 488                      }
 489                  }
 490              } else if ($moduleareas = $this->get_module_areas_with_files($extensions)) {
 491                  // We found files in some of the modules.
 492                  // Create array of children modules ordered with the same way as cms in modinfo.
 493                  $modulechildren = array_fill_keys(array_keys(get_fast_modinfo($this->course)->get_cms()), null);
 494                  foreach ($moduleareas as $area) {
 495                      if ($modulechildren[$area->cmid]) {
 496                          // We already found non-empty area within the same module, do not analyse other areas.
 497                          continue;
 498                      }
 499                      if ($child = $this->get_child_module($area->cmid)) {
 500                          if ($child->get_file_info($area->component, $area->filearea, $area->itemid, null, null)) {
 501                              $modulechildren[$area->cmid] = $child;
 502                              $cnt++;
 503                              if (($countonly !== false) && $cnt >= $countonly) {
 504                                  return $cnt;
 505                              }
 506                          }
 507                      }
 508                  }
 509                  $children = array_merge($children, array_values(array_filter($modulechildren)));
 510              }
 511          }
 512  
 513          if ($countonly !== false) {
 514              return count($children);
 515          }
 516          return $children;
 517      }
 518  
 519      /**
 520       * Returns list of areas inside the course modules that have files with the given extension
 521       *
 522       * @param string $extensions
 523       * @return array
 524       */
 525      protected function get_module_areas_with_files($extensions = '*') {
 526          global $DB;
 527  
 528          $params1 = ['contextid' => $this->context->id,
 529              'emptyfilename' => '.',
 530              'contextlevel' => CONTEXT_MODULE,
 531              'course' => $this->course->id];
 532          $ctxfieldsas = context_helper::get_preload_record_columns_sql('ctx');
 533          $ctxfields = implode(', ', array_keys(context_helper::get_preload_record_columns('ctx')));
 534          $sql1 = "SELECT
 535                      ctx.id AS contextid,
 536                      f.component,
 537                      f.filearea,
 538                      f.itemid,
 539                      ctx.instanceid AS cmid,
 540                      {$ctxfieldsas}
 541              FROM {files} f
 542              INNER JOIN {context} ctx ON ctx.id = f.contextid
 543              INNER JOIN {course_modules} cm ON cm.id = ctx.instanceid
 544              WHERE f.filename <> :emptyfilename
 545                AND cm.course = :course
 546                AND ctx.contextlevel = :contextlevel";
 547          $sql3 = "
 548              GROUP BY ctx.id, f.component, f.filearea, f.itemid, {$ctxfields}
 549              ORDER BY ctx.id, f.component, f.filearea, f.itemid";
 550          list($sql2, $params2) = $this->build_search_files_sql($extensions);
 551          $areas = [];
 552          if ($rs = $DB->get_recordset_sql($sql1. $sql2 . $sql3, array_merge($params1, $params2))) {
 553              foreach ($rs as $record) {
 554                  context_helper::preload_from_record($record);
 555                  $areas[] = $record;
 556              }
 557              $rs->close();
 558          }
 559  
 560          // Sort areas so 'backup' and 'intro' are in the beginning of the list, they are the easiest to check access to.
 561          usort($areas, function($a, $b) {
 562              $aeasy = ($a->filearea === 'intro' && substr($a->component, 0, 4) === 'mod_') ||
 563                  ($a->filearea === 'activity' && $a->component === 'backup');
 564              $beasy = ($b->filearea === 'intro' && substr($b->component, 0, 4) === 'mod_') ||
 565                  ($b->filearea === 'activity' && $b->component === 'backup');
 566              return $aeasy == $beasy ? 0 : ($aeasy ? -1 : 1);
 567          });
 568          return $areas;
 569      }
 570  
 571      /**
 572       * Returns list of children which are either files matching the specified extensions
 573       * or folders that contain at least one such file.
 574       *
 575       * @param string|array $extensions, either '*' or array of lowercase extensions, i.e. array('.gif','.jpg')
 576       * @return array of file_info instances
 577       */
 578      public function get_non_empty_children($extensions = '*') {
 579          return $this->get_filtered_children($extensions, false);
 580      }
 581  
 582      /**
 583       * Returns the number of children which are either files matching the specified extensions
 584       * or folders containing at least one such file.
 585       *
 586       * @param string|array $extensions, for example '*' or array('.gif','.jpg')
 587       * @param int $limit stop counting after at least $limit non-empty children are found
 588       * @return int
 589       */
 590      public function count_non_empty_children($extensions = '*', $limit = 1) {
 591          return $this->get_filtered_children($extensions, $limit);
 592      }
 593  
 594      /**
 595       * Returns parent file_info instance
 596       *
 597       * @return file_info or null for root
 598       */
 599      public function get_parent() {
 600          $parent = $this->context->get_parent_context();
 601          return $this->browser->get_file_info($parent);
 602      }
 603  }
 604  
 605  
 606  /**
 607   * Subclass of file_info_stored for files in the course files area.
 608   *
 609   * @package   core_files
 610   * @copyright 2008 Petr Skoda (http://skodak.org)
 611   * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 612   */
 613  class file_info_area_course_legacy extends file_info_stored {
 614      /**
 615       * Constructor
 616       *
 617       * @param file_browser $browser file browser instance
 618       * @param stdClass $context context object
 619       * @param stored_file $storedfile stored_file instance
 620       */
 621      public function __construct($browser, $context, $storedfile) {
 622          global $CFG;
 623          $urlbase = $CFG->wwwroot.'/file.php';
 624          parent::__construct($browser, $context, $storedfile, $urlbase, get_string('coursefiles'), false, true, true, false);
 625      }
 626  
 627      /**
 628       * Returns file download url
 629       *
 630       * @param bool $forcedownload whether or not force download
 631       * @param bool $https whether or not force https
 632       * @return string url
 633       */
 634      public function get_url($forcedownload=false, $https=false) {
 635          if (!$this->is_readable()) {
 636              return null;
 637          }
 638  
 639          if ($this->lf->is_directory()) {
 640              return null;
 641          }
 642  
 643          $filepath = $this->lf->get_filepath();
 644          $filename = $this->lf->get_filename();
 645          $courseid = $this->context->instanceid;
 646  
 647          $path = '/'.$courseid.$filepath.$filename;
 648  
 649          return file_encode_url($this->urlbase, $path, $forcedownload, $https);
 650      }
 651  
 652      /**
 653       * Returns list of children.
 654       *
 655       * @return array of file_info instances
 656       */
 657      public function get_children() {
 658          if (!$this->lf->is_directory()) {
 659              return array();
 660          }
 661  
 662          $result = array();
 663          $fs = get_file_storage();
 664  
 665          $storedfiles = $fs->get_directory_files($this->context->id, 'course', 'legacy', 0, $this->lf->get_filepath(), false, true, "filepath ASC, filename ASC");
 666          foreach ($storedfiles as $file) {
 667              $result[] = new file_info_area_course_legacy($this->browser, $this->context, $file);
 668          }
 669  
 670          return $result;
 671      }
 672  
 673      /**
 674       * Returns list of children which are either files matching the specified extensions
 675       * or folders that contain at least one such file.
 676       *
 677       * @param string|array $extensions, either '*' or array of lowercase extensions, i.e. array('.gif','.jpg')
 678       * @return array of file_info instances
 679       */
 680      public function get_non_empty_children($extensions = '*') {
 681          if (!$this->lf->is_directory()) {
 682              return array();
 683          }
 684  
 685          $result = array();
 686          $fs = get_file_storage();
 687  
 688          $storedfiles = $fs->get_directory_files($this->context->id, 'course', 'legacy', 0,
 689                                                  $this->lf->get_filepath(), false, true, "filepath, filename");
 690          foreach ($storedfiles as $file) {
 691              $extension = core_text::strtolower(pathinfo($file->get_filename(), PATHINFO_EXTENSION));
 692              if ($file->is_directory() || $extensions === '*' || (!empty($extension) && in_array('.'.$extension, $extensions))) {
 693                  $fileinfo = new file_info_area_course_legacy($this->browser, $this->context, $file, $this->urlbase, $this->topvisiblename,
 694                                                   $this->itemidused, $this->readaccess, $this->writeaccess, false);
 695                  if (!$file->is_directory() || $fileinfo->count_non_empty_children($extensions)) {
 696                      $result[] = $fileinfo;
 697                  }
 698              }
 699          }
 700  
 701          return $result;
 702      }
 703  }
 704  
 705  /**
 706   * Represents a course category context in the tree navigated by {@link file_browser}.
 707   *
 708   * @package    core_files
 709   * @copyright  2008 Petr Skoda (http://skodak.org)
 710   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 711   */
 712  class file_info_area_course_section extends file_info {
 713      /** @var stdClass course object */
 714      protected $course;
 715      /** @var file_info_context_course course file info object */
 716      protected $courseinfo;
 717  
 718      /**
 719       * Constructor
 720       *
 721       * @param file_browser $browser file browser instance
 722       * @param stdClass $context context object
 723       * @param stdClass $course course object
 724       * @param file_info_context_course $courseinfo file info instance
 725       */
 726      public function __construct($browser, $context, $course, file_info_context_course $courseinfo) {
 727          parent::__construct($browser, $context);
 728          $this->course     = $course;
 729          $this->courseinfo = $courseinfo;
 730      }
 731  
 732      /**
 733       * Returns list of standard virtual file/directory identification.
 734       * The difference from stored_file parameters is that null values
 735       * are allowed in all fields
 736       *
 737       * @return array with keys contextid, filearea, itemid, filepath and filename
 738       */
 739      public function get_params() {
 740          return array('contextid' => $this->context->id,
 741                       'component' => 'course',
 742                       'filearea'  => 'section',
 743                       'itemid'    => null,
 744                       'filepath'  => null,
 745                       'filename'  => null);
 746      }
 747  
 748      /**
 749       * Returns localised visible name.
 750       *
 751       * @return string
 752       */
 753      public function get_visible_name() {
 754          //$format = $this->course->format;
 755          $sectionsname = get_string("coursesectionsummaries");
 756  
 757          return $sectionsname;
 758      }
 759  
 760      /**
 761       * Return whether or not new files or directories can be added
 762       *
 763       * @return bool
 764       */
 765      public function is_writable() {
 766          return false;
 767      }
 768  
 769      /**
 770       * Return whether or not this is a empty area
 771       *
 772       * @return bool
 773       */
 774      public function is_empty_area() {
 775          $fs = get_file_storage();
 776          return $fs->is_area_empty($this->context->id, 'course', 'section');
 777      }
 778  
 779      /**
 780       * Return whether or not this is a empty area
 781       *
 782       * @return bool
 783       */
 784      public function is_directory() {
 785          return true;
 786      }
 787  
 788      /**
 789       * Returns list of children.
 790       *
 791       * @return array of file_info instances
 792       */
 793      public function get_children() {
 794          global $DB;
 795  
 796          $children = array();
 797  
 798          $course_sections = $DB->get_records('course_sections', array('course'=>$this->course->id), 'section');
 799          foreach ($course_sections as $section) {
 800              if ($child = $this->courseinfo->get_file_info('course', 'section', $section->id, '/', '.')) {
 801                  $children[] = $child;
 802              }
 803          }
 804  
 805          return $children;
 806      }
 807  
 808      /**
 809       * Returns the number of children which are either files matching the specified extensions
 810       * or folders containing at least one such file.
 811       *
 812       * @param string|array $extensions, for example '*' or array('.gif','.jpg')
 813       * @param int $limit stop counting after at least $limit non-empty children are found
 814       * @return int
 815       */
 816      public function count_non_empty_children($extensions = '*', $limit = 1) {
 817          global $DB;
 818          $params1 = array(
 819              'courseid' => $this->course->id,
 820              'contextid' => $this->context->id,
 821              'component' => 'course',
 822              'filearea' => 'section',
 823              'emptyfilename' => '.');
 824          $sql1 = "SELECT DISTINCT cs.id FROM {files} f, {course_sections} cs
 825              WHERE cs.course = :courseid
 826              AND f.contextid = :contextid
 827              AND f.component = :component
 828              AND f.filearea = :filearea
 829              AND f.itemid = cs.id
 830              AND f.filename <> :emptyfilename";
 831          list($sql2, $params2) = $this->build_search_files_sql($extensions);
 832          $rs = $DB->get_recordset_sql($sql1. ' '. $sql2, array_merge($params1, $params2));
 833          $cnt = 0;
 834          foreach ($rs as $record) {
 835              if ((++$cnt) >= $limit) {
 836                  break;
 837              }
 838          }
 839          $rs->close();
 840          return $cnt;
 841      }
 842  
 843      /**
 844       * Returns parent file_info instance
 845       *
 846       * @return file_info|null file_info or null for root
 847       */
 848      public function get_parent() {
 849          return $this->courseinfo;
 850      }
 851  }
 852  
 853  
 854  /**
 855   * Implementation of course section backup area
 856   *
 857   * @package    core_files
 858   * @copyright  2008 Petr Skoda (http://skodak.org)
 859   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 860   */
 861  class file_info_area_backup_section extends file_info {
 862      /** @var stdClass course object */
 863      protected $course;
 864      /** @var file_info_context_course course file info object */
 865      protected $courseinfo;
 866  
 867      /**
 868       * Constructor
 869       *
 870       * @param file_browser $browser file browser instance
 871       * @param stdClass $context context object
 872       * @param stdClass $course course object
 873       * @param file_info_context_course $courseinfo file info instance
 874       */
 875      public function __construct($browser, $context, $course, file_info_context_course $courseinfo) {
 876          parent::__construct($browser, $context);
 877          $this->course     = $course;
 878          $this->courseinfo = $courseinfo;
 879      }
 880  
 881      /**
 882       * Returns list of standard virtual file/directory identification.
 883       * The difference from stored_file parameters is that null values
 884       * are allowed in all fields
 885       *
 886       * @return array with keys contextid, component, filearea, itemid, filepath and filename
 887       */
 888      public function get_params() {
 889          return array('contextid' => $this->context->id,
 890                       'component' => 'backup',
 891                       'filearea'  => 'section',
 892                       'itemid'    => null,
 893                       'filepath'  => null,
 894                       'filename'  => null);
 895      }
 896  
 897      /**
 898       * Returns localised visible name.
 899       *
 900       * @return string
 901       */
 902      public function get_visible_name() {
 903          return get_string('sectionbackup', 'repository');
 904      }
 905  
 906      /**
 907       * Return whether or not new files and directories can be added
 908       *
 909       * @return bool
 910       */
 911      public function is_writable() {
 912          return false;
 913      }
 914  
 915      /**
 916       * Whether or not this is an empty area
 917       *
 918       * @return bool
 919       */
 920      public function is_empty_area() {
 921          $fs = get_file_storage();
 922          return $fs->is_area_empty($this->context->id, 'backup', 'section');
 923      }
 924  
 925      /**
 926       * Return whether or not this is a directory
 927       *
 928       * @return bool
 929       */
 930      public function is_directory() {
 931          return true;
 932      }
 933  
 934      /**
 935       * Returns list of children.
 936       *
 937       * @return array of file_info instances
 938       */
 939      public function get_children() {
 940          global $DB;
 941  
 942          $children = array();
 943  
 944          $course_sections = $DB->get_records('course_sections', array('course'=>$this->course->id), 'section');
 945          foreach ($course_sections as $section) {
 946              if ($child = $this->courseinfo->get_file_info('backup', 'section', $section->id, '/', '.')) {
 947                  $children[] = $child;
 948              }
 949          }
 950  
 951          return $children;
 952      }
 953  
 954      /**
 955       * Returns the number of children which are either files matching the specified extensions
 956       * or folders containing at least one such file.
 957       *
 958       * @param string|array $extensions, for example '*' or array('.gif','.jpg')
 959       * @param int $limit stop counting after at least $limit non-empty children are found
 960       * @return int
 961       */
 962      public function count_non_empty_children($extensions = '*', $limit = 1) {
 963          global $DB;
 964          $params1 = array(
 965              'courseid' => $this->course->id,
 966              'contextid' => $this->context->id,
 967              'component' => 'backup',
 968              'filearea' => 'section',
 969              'emptyfilename' => '.');
 970          $sql1 = "SELECT DISTINCT cs.id AS sectionid FROM {files} f, {course_sections} cs
 971              WHERE cs.course = :courseid
 972              AND f.contextid = :contextid
 973              AND f.component = :component
 974              AND f.filearea = :filearea
 975              AND f.itemid = cs.id
 976              AND f.filename <> :emptyfilename";
 977          list($sql2, $params2) = $this->build_search_files_sql($extensions);
 978          $rs = $DB->get_recordset_sql($sql1. ' '. $sql2, array_merge($params1, $params2));
 979          $cnt = 0;
 980          foreach ($rs as $record) {
 981              if ((++$cnt) >= $limit) {
 982                  break;
 983              }
 984          }
 985          $rs->close();
 986          return $cnt;
 987      }
 988  
 989      /**
 990       * Returns parent file_info instance
 991       *
 992       * @return file_info or null for root
 993       */
 994      public function get_parent() {
 995          return $this->browser->get_file_info($this->context);
 996      }
 997  }