[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   * This file contains backup and restore output renderers
  19   *
  20   * @package   core_backup
  21   * @copyright 2010 Sam Hemelryk
  22   * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23   */
  24  
  25  /**
  26   * The primary renderer for the backup.
  27   *
  28   * Can be retrieved with the following code:
  29   * <?php
  30   * $renderer = $PAGE->get_renderer('core', 'backup');
  31   * ?>
  32   *
  33   * @package   core_backup
  34   * @copyright 2010 Sam Hemelryk
  35   * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  36   */
  37  class core_backup_renderer extends plugin_renderer_base {
  38  
  39      /**
  40       * Renderers a progress bar for the backup or restore given the items that make it up.
  41       *
  42       * @param array $items An array of items
  43       * @return string
  44       */
  45      public function progress_bar(array $items) {
  46          foreach ($items as &$item) {
  47              $text = $item['text'];
  48              unset($item['text']);
  49              if (array_key_exists('link', $item)) {
  50                  $link = $item['link'];
  51                  unset($item['link']);
  52                  $item = html_writer::link($link, $text, $item);
  53              } else {
  54                  $item = html_writer::tag('span', $text, $item);
  55              }
  56          }
  57          return html_writer::tag('div', join(get_separator(), $items), array('class' => 'backup_progress clearfix'));
  58      }
  59  
  60      /**
  61       * The backup and restore pages may display a log (if any) in a scrolling box.
  62       *
  63       * @param string $loghtml Log content in HTML format
  64       * @return string HTML content that shows the log
  65       */
  66      public function log_display($loghtml) {
  67          global $OUTPUT;
  68          $out = html_writer::start_div('backup_log');
  69          $out .= $OUTPUT->heading(get_string('backuplog', 'backup'));
  70          $out .= html_writer::start_div('backup_log_contents');
  71          $out .= $loghtml;
  72          $out .= html_writer::end_div();
  73          $out .= html_writer::end_div();
  74          return $out;
  75      }
  76  
  77      /**
  78       * Prints a dependency notification
  79       *
  80       * @param string $message
  81       * @return string
  82       */
  83      public function dependency_notification($message) {
  84          return html_writer::tag('div', $message, array('class' => 'notification dependencies_enforced'));
  85      }
  86  
  87      /**
  88       * Displays the details of a backup file
  89       *
  90       * @param stdClass $details
  91       * @param moodle_url $nextstageurl
  92       * @return string
  93       */
  94      public function backup_details($details, $nextstageurl) {
  95          $yestick = $this->output->pix_icon('i/valid', get_string('yes'));
  96          $notick = $this->output->pix_icon('i/invalid', get_string('no'));
  97  
  98          $html  = html_writer::start_tag('div', array('class' => 'backup-restore'));
  99  
 100          $html .= html_writer::start_tag('div', array('class' => 'backup-section'));
 101          $html .= $this->output->heading(get_string('backupdetails', 'backup'), 2, array('class' => 'header'));
 102          $html .= $this->backup_detail_pair(get_string('backuptype', 'backup'), get_string('backuptype'.$details->type, 'backup'));
 103          $html .= $this->backup_detail_pair(get_string('backupformat', 'backup'), get_string('backupformat'.$details->format, 'backup'));
 104          $html .= $this->backup_detail_pair(get_string('backupmode', 'backup'), get_string('backupmode'.$details->mode, 'backup'));
 105          $html .= $this->backup_detail_pair(get_string('backupdate', 'backup'), userdate($details->backup_date));
 106          $html .= $this->backup_detail_pair(get_string('moodleversion', 'backup'),
 107                  html_writer::tag('span', $details->moodle_release, array('class' => 'moodle_release')).
 108                  html_writer::tag('span', '['.$details->moodle_version.']', array('class' => 'moodle_version sub-detail')));
 109          $html .= $this->backup_detail_pair(get_string('backupversion', 'backup'),
 110                  html_writer::tag('span', $details->backup_release, array('class' => 'moodle_release')).
 111                  html_writer::tag('span', '['.$details->backup_version.']', array('class' => 'moodle_version sub-detail')));
 112          $html .= $this->backup_detail_pair(get_string('originalwwwroot', 'backup'),
 113                  html_writer::tag('span', $details->original_wwwroot, array('class' => 'originalwwwroot')).
 114                  html_writer::tag('span', '['.$details->original_site_identifier_hash.']', array('class' => 'sitehash sub-detail')));
 115          if (!empty($details->include_file_references_to_external_content)) {
 116              $message = '';
 117              if (backup_general_helper::backup_is_samesite($details)) {
 118                  $message = $yestick . ' ' . get_string('filereferencessamesite', 'backup');
 119              } else {
 120                  $message = $notick . ' ' . get_string('filereferencesnotsamesite', 'backup');
 121              }
 122              $html .= $this->backup_detail_pair(get_string('includefilereferences', 'backup'), $message);
 123          }
 124  
 125          $html .= html_writer::end_tag('div');
 126  
 127          $html .= html_writer::start_tag('div', array('class' => 'backup-section settings-section'));
 128          $html .= $this->output->heading(get_string('backupsettings', 'backup'), 2, array('class' => 'header'));
 129          foreach ($details->root_settings as $label => $value) {
 130              if ($label == 'filename' or $label == 'user_files') {
 131                  continue;
 132              }
 133              $html .= $this->backup_detail_pair(get_string('rootsetting'.str_replace('_', '', $label), 'backup'), $value ? $yestick : $notick);
 134          }
 135          $html .= html_writer::end_tag('div');
 136  
 137          if ($details->type === 'course') {
 138              $html .= html_writer::start_tag('div', array('class' => 'backup-section'));
 139              $html .= $this->output->heading(get_string('backupcoursedetails', 'backup'), 2, array('class' => 'header'));
 140              $html .= $this->backup_detail_pair(get_string('coursetitle', 'backup'), $details->course->title);
 141              $html .= $this->backup_detail_pair(get_string('courseid', 'backup'), $details->course->courseid);
 142  
 143              // Warning users about front page backups.
 144              if ($details->original_course_format === 'site') {
 145                  $html .= $this->backup_detail_pair(get_string('type_format', 'plugin'), get_string('sitecourseformatwarning', 'backup'));
 146              }
 147              $html .= html_writer::start_tag('div', array('class' => 'backup-sub-section'));
 148              $html .= $this->output->heading(get_string('backupcoursesections', 'backup'), 3, array('class' => 'subheader'));
 149              foreach ($details->sections as $key => $section) {
 150                  $included = $key.'_included';
 151                  $userinfo = $key.'_userinfo';
 152                  if ($section->settings[$included] && $section->settings[$userinfo]) {
 153                      $value = get_string('sectionincanduser', 'backup');
 154                  } else if ($section->settings[$included]) {
 155                      $value = get_string('sectioninc', 'backup');
 156                  } else {
 157                      continue;
 158                  }
 159                  $html .= $this->backup_detail_pair(get_string('backupcoursesection', 'backup', $section->title), $value);
 160                  $table = null;
 161                  foreach ($details->activities as $activitykey => $activity) {
 162                      if ($activity->sectionid != $section->sectionid) {
 163                          continue;
 164                      }
 165                      if (empty($table)) {
 166                          $table = new html_table();
 167                          $table->head = array(get_string('module', 'backup'), get_string('title', 'backup'), get_string('userinfo', 'backup'));
 168                          $table->colclasses = array('modulename', 'moduletitle', 'userinfoincluded');
 169                          $table->align = array('left', 'left', 'center');
 170                          $table->attributes = array('class' => 'activitytable generaltable');
 171                          $table->data = array();
 172                      }
 173                      $name = get_string('pluginname', $activity->modulename);
 174                      $icon = new pix_icon('icon', $name, $activity->modulename, array('class' => 'iconlarge icon-pre'));
 175                      $table->data[] = array(
 176                          $this->output->render($icon).$name,
 177                          $activity->title,
 178                          ($activity->settings[$activitykey.'_userinfo']) ? $yestick : $notick,
 179                      );
 180                  }
 181                  if (!empty($table)) {
 182                      $html .= $this->backup_detail_pair(get_string('sectionactivities', 'backup'), html_writer::table($table));
 183                  }
 184  
 185              }
 186              $html .= html_writer::end_tag('div');
 187              $html .= html_writer::end_tag('div');
 188          }
 189  
 190          $html .= $this->output->single_button($nextstageurl, get_string('continue'), 'post');
 191          $html .= html_writer::end_tag('div');
 192  
 193          return $html;
 194      }
 195  
 196      /**
 197       * Displays the general information about a backup file with non-standard format
 198       *
 199       * @param moodle_url $nextstageurl URL to send user to
 200       * @param array $details basic info about the file (format, type)
 201       * @return string HTML code to display
 202       */
 203      public function backup_details_nonstandard($nextstageurl, array $details) {
 204  
 205          $html  = html_writer::start_tag('div', array('class' => 'backup-restore nonstandardformat'));
 206          $html .= html_writer::start_tag('div', array('class' => 'backup-section'));
 207          $html .= $this->output->heading(get_string('backupdetails', 'backup'), 2, 'header');
 208          $html .= $this->output->box(get_string('backupdetailsnonstandardinfo', 'backup'), 'noticebox');
 209          $html .= $this->backup_detail_pair(
 210              get_string('backupformat', 'backup'),
 211              get_string('backupformat'.$details['format'], 'backup'));
 212          $html .= $this->backup_detail_pair(
 213              get_string('backuptype', 'backup'),
 214              get_string('backuptype'.$details['type'], 'backup'));
 215          $html .= html_writer::end_tag('div');
 216          $html .= $this->output->single_button($nextstageurl, get_string('continue'), 'post');
 217          $html .= html_writer::end_tag('div');
 218  
 219          return $html;
 220      }
 221  
 222      /**
 223       * Displays the general information about a backup file with unknown format
 224       *
 225       * @param moodle_url $nextstageurl URL to send user to
 226       * @return string HTML code to display
 227       */
 228      public function backup_details_unknown(moodle_url $nextstageurl) {
 229  
 230          $html  = html_writer::start_div('unknownformat');
 231          $html .= $this->output->heading(get_string('errorinvalidformat', 'backup'), 2);
 232          $html .= $this->output->notification(get_string('errorinvalidformatinfo', 'backup'), 'notifyproblem');
 233          $html .= $this->output->single_button($nextstageurl, get_string('continue'), 'post');
 234          $html .= html_writer::end_div();
 235  
 236          return $html;
 237      }
 238  
 239      /**
 240       * Displays a course selector for restore
 241       *
 242       * @param moodle_url $nextstageurl
 243       * @param bool $wholecourse true if we are restoring whole course (as with backup::TYPE_1COURSE), false otherwise
 244       * @param restore_category_search $categories
 245       * @param restore_course_search $courses
 246       * @param int $currentcourse
 247       * @return string
 248       */
 249      public function course_selector(moodle_url $nextstageurl, $wholecourse = true, restore_category_search $categories = null,
 250                                      restore_course_search $courses = null, $currentcourse = null) {
 251          global $CFG, $PAGE;
 252          require_once($CFG->dirroot.'/course/lib.php');
 253  
 254          // These variables are used to check if the form using this function was submitted.
 255          $target = optional_param('target', false, PARAM_INT);
 256          $targetid = optional_param('targetid', null, PARAM_INT);
 257  
 258          // Check if they submitted the form but did not provide all the data we need.
 259          $missingdata = false;
 260          if ($target and is_null($targetid)) {
 261              $missingdata = true;
 262          }
 263  
 264          $nextstageurl->param('sesskey', sesskey());
 265  
 266          $form = html_writer::start_tag('form', array('method' => 'post', 'action' => $nextstageurl->out_omit_querystring(),
 267              'class' => 'mform'));
 268          foreach ($nextstageurl->params() as $key => $value) {
 269              $form .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => $key, 'value' => $value));
 270          }
 271  
 272          $hasrestoreoption = false;
 273  
 274          $html  = html_writer::start_tag('div', array('class' => 'backup-course-selector backup-restore'));
 275          if ($wholecourse && !empty($categories) && ($categories->get_count() > 0 || $categories->get_search())) {
 276              // New course.
 277              $hasrestoreoption = true;
 278              $html .= $form;
 279              $html .= html_writer::start_tag('div', array('class' => 'bcs-new-course backup-section'));
 280              $html .= $this->output->heading(get_string('restoretonewcourse', 'backup'), 2, array('class' => 'header'));
 281              $html .= $this->backup_detail_input(get_string('restoretonewcourse', 'backup'), 'radio', 'target',
 282                  backup::TARGET_NEW_COURSE, array('checked' => 'checked'));
 283              $selectacategoryhtml = $this->backup_detail_pair(get_string('selectacategory', 'backup'), $this->render($categories));
 284              // Display the category selection as required if the form was submitted but this data was not supplied.
 285              if ($missingdata && $target == backup::TARGET_NEW_COURSE) {
 286                  $html .= html_writer::span(get_string('required'), 'error');
 287                  $html .= html_writer::start_tag('fieldset', array('class' => 'error'));
 288                  $html .= $selectacategoryhtml;
 289                  $html .= html_writer::end_tag('fieldset');
 290              } else {
 291                  $html .= $selectacategoryhtml;
 292              }
 293              $html .= $this->backup_detail_pair('', html_writer::empty_tag('input', array('type' => 'submit', 'value' => get_string('continue'))));
 294              $html .= html_writer::end_tag('div');
 295              $html .= html_writer::end_tag('form');
 296          }
 297  
 298          if ($wholecourse && !empty($currentcourse)) {
 299              // Current course.
 300              $hasrestoreoption = true;
 301              $html .= $form;
 302              $html .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => 'targetid', 'value' => $currentcourse));
 303              $html .= html_writer::start_tag('div', array('class' => 'bcs-current-course backup-section'));
 304              $html .= $this->output->heading(get_string('restoretocurrentcourse', 'backup'), 2, array('class' => 'header'));
 305              $html .= $this->backup_detail_input(get_string('restoretocurrentcourseadding', 'backup'), 'radio', 'target',
 306                  backup::TARGET_CURRENT_ADDING, array('checked' => 'checked'));
 307              $html .= $this->backup_detail_input(get_string('restoretocurrentcoursedeleting', 'backup'), 'radio', 'target',
 308                  backup::TARGET_CURRENT_DELETING);
 309              $html .= $this->backup_detail_pair('', html_writer::empty_tag('input', array('type' => 'submit', 'value' => get_string('continue'))));
 310              $html .= html_writer::end_tag('div');
 311              $html .= html_writer::end_tag('form');
 312          }
 313  
 314          // If we are restoring an activity, then include the current course.
 315          if (!$wholecourse) {
 316              $courses->invalidate_results(); // Clean list of courses.
 317              $courses->set_include_currentcourse();
 318          }
 319          if (!empty($courses) && ($courses->get_count() > 0 || $courses->get_search())) {
 320              // Existing course.
 321              $hasrestoreoption = true;
 322              $html .= $form;
 323              $html .= html_writer::start_tag('div', array('class' => 'bcs-existing-course backup-section'));
 324              $html .= $this->output->heading(get_string('restoretoexistingcourse', 'backup'), 2, array('class' => 'header'));
 325              if ($wholecourse) {
 326                  $html .= $this->backup_detail_input(get_string('restoretoexistingcourseadding', 'backup'), 'radio', 'target',
 327                      backup::TARGET_EXISTING_ADDING, array('checked' => 'checked'));
 328                  $html .= $this->backup_detail_input(get_string('restoretoexistingcoursedeleting', 'backup'), 'radio', 'target',
 329                      backup::TARGET_EXISTING_DELETING);
 330              } else {
 331                  $html .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => 'target', 'value' => backup::TARGET_EXISTING_ADDING));
 332              }
 333              $selectacoursehtml = $this->backup_detail_pair(get_string('selectacourse', 'backup'), $this->render($courses));
 334              // Display the course selection as required if the form was submitted but this data was not supplied.
 335              if ($missingdata && $target == backup::TARGET_EXISTING_ADDING) {
 336                  $html .= html_writer::span(get_string('required'), 'error');
 337                  $html .= html_writer::start_tag('fieldset', array('class' => 'error'));
 338                  $html .= $selectacoursehtml;
 339                  $html .= html_writer::end_tag('fieldset');
 340              } else {
 341                  $html .= $selectacoursehtml;
 342              }
 343              $html .= $this->backup_detail_pair('', html_writer::empty_tag('input', array('type' => 'submit', 'value' => get_string('continue'))));
 344              $html .= html_writer::end_tag('div');
 345              $html .= html_writer::end_tag('form');
 346          }
 347  
 348          if (!$hasrestoreoption) {
 349              echo $this->output->notification(get_string('norestoreoptions', 'backup'));
 350          }
 351  
 352          $html .= html_writer::end_tag('div');
 353          return $html;
 354      }
 355  
 356      /**
 357       * Displays the import course selector
 358       *
 359       * @param moodle_url $nextstageurl
 360       * @param import_course_search $courses
 361       * @return string
 362       */
 363      public function import_course_selector(moodle_url $nextstageurl, import_course_search $courses = null) {
 364          $html  = html_writer::start_tag('div', array('class' => 'import-course-selector backup-restore'));
 365          $html .= html_writer::start_tag('form', array('method' => 'post', 'action' => $nextstageurl->out_omit_querystring()));
 366          foreach ($nextstageurl->params() as $key => $value) {
 367              $html .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => $key, 'value' => $value));
 368          }
 369          // We only allow import adding for now. Enforce it here.
 370          $html .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => 'target', 'value' => backup::TARGET_CURRENT_ADDING));
 371          $html .= html_writer::start_tag('div', array('class' => 'ics-existing-course backup-section'));
 372          $html .= $this->output->heading(get_string('importdatafrom'), 2, array('class' => 'header'));
 373          $html .= $this->backup_detail_pair(get_string('selectacourse', 'backup'), $this->render($courses));
 374          $html .= $this->backup_detail_pair('', html_writer::empty_tag('input', array('type' => 'submit', 'value' => get_string('continue'))));
 375          $html .= html_writer::end_tag('div');
 376          $html .= html_writer::end_tag('form');
 377          $html .= html_writer::end_tag('div');
 378          return $html;
 379      }
 380  
 381      /**
 382       * Creates a detailed pairing (key + value)
 383       *
 384       * @staticvar int $count
 385       * @param string $label
 386       * @param string $value
 387       * @return string
 388       */
 389      protected function backup_detail_pair($label, $value) {
 390          static $count = 0;
 391          $count ++;
 392          $html  = html_writer::start_tag('div', array('class' => 'detail-pair'));
 393          $html .= html_writer::tag('label', $label, array('class' => 'detail-pair-label', 'for' => 'detail-pair-value-'.$count));
 394          $html .= html_writer::tag('div', $value, array('class' => 'detail-pair-value', 'name' => 'detail-pair-value-'.$count));
 395          $html .= html_writer::end_tag('div');
 396          return $html;
 397      }
 398  
 399      /**
 400       * Created a detailed pairing with an input
 401       *
 402       * @param string $label
 403       * @param string $type
 404       * @param string $name
 405       * @param string $value
 406       * @param array $attributes
 407       * @param string|null $description
 408       * @return string
 409       */
 410      protected function backup_detail_input($label, $type, $name, $value, array $attributes = array(), $description = null) {
 411          if (!empty($description)) {
 412              $description = html_writer::tag('span', $description, array('class' => 'description'));
 413          } else {
 414              $description = '';
 415          }
 416          return $this->backup_detail_pair(
 417              $label,
 418              html_writer::empty_tag('input', $attributes + array('name' => $name, 'type' => $type, 'value' => $value)) . $description
 419          );
 420      }
 421  
 422      /**
 423       * Creates a detailed pairing with a select
 424       *
 425       * @param string $label
 426       * @param string $name
 427       * @param array $options
 428       * @param string $selected
 429       * @param bool $nothing
 430       * @param array $attributes
 431       * @param string|null $description
 432       * @return string
 433       */
 434      protected function backup_detail_select($label, $name, $options, $selected = '', $nothing = false, array $attributes = array(), $description = null) {
 435          if (!empty ($description)) {
 436              $description = html_writer::tag('span', $description, array('class' => 'description'));
 437          } else {
 438              $description = '';
 439          }
 440          return $this->backup_detail_pair($label, html_writer::select($options, $name, $selected, false, $attributes).$description);
 441      }
 442  
 443      /**
 444       * Displays precheck notices
 445       *
 446       * @param array $results
 447       * @return string
 448       */
 449      public function precheck_notices($results) {
 450          $output = html_writer::start_tag('div', array('class' => 'restore-precheck-notices'));
 451          if (array_key_exists('errors', $results)) {
 452              foreach ($results['errors'] as $error) {
 453                  $output .= $this->output->notification($error);
 454              }
 455          }
 456          if (array_key_exists('warnings', $results)) {
 457              foreach ($results['warnings'] as $warning) {
 458                  $output .= $this->output->notification($warning, 'notifyproblem');
 459              }
 460          }
 461          return $output.html_writer::end_tag('div');
 462      }
 463  
 464      /**
 465       * Displays substage buttons
 466       *
 467       * @param bool $haserrors
 468       * @return string
 469       */
 470      public function substage_buttons($haserrors) {
 471          $output  = html_writer::start_tag('div', array('continuebutton'));
 472          if (!$haserrors) {
 473              $output .= html_writer::empty_tag('input', array('type' => 'submit', 'value' => get_string('continue')));
 474          }
 475          $output .= html_writer::empty_tag('input', array('type' => 'submit', 'name' => 'cancel', 'value' => get_string('cancel')));
 476          $output .= html_writer::end_tag('div');
 477          return $output;
 478      }
 479  
 480      /**
 481       * Displays a role mapping interface
 482       *
 483       * @param array $rolemappings
 484       * @param array $roles
 485       * @return string
 486       */
 487      public function role_mappings($rolemappings, $roles) {
 488          $roles[0] = get_string('none');
 489          $output  = html_writer::start_tag('div', array('class' => 'restore-rolemappings'));
 490          $output .= $this->output->heading(get_string('restorerolemappings', 'backup'), 2);
 491          foreach ($rolemappings as $id => $mapping) {
 492              $label = $mapping->name;
 493              $name = 'mapping'.$id;
 494              $selected = $mapping->targetroleid;
 495              $output .= $this->backup_detail_select($label, $name, $roles, $mapping->targetroleid, false, array(), $mapping->description);
 496          }
 497          $output .= html_writer::end_tag('div');
 498          return $output;
 499      }
 500  
 501      /**
 502       * Displays a continue button
 503       *
 504       * @param string|moodle_url $url
 505       * @param string $method
 506       * @return string
 507       */
 508      public function continue_button($url, $method = 'post') {
 509          if (!($url instanceof moodle_url)) {
 510              $url = new moodle_url($url);
 511          }
 512          if ($method != 'post') {
 513              $method = 'get';
 514          }
 515          $url->param('sesskey', sesskey());
 516          $button = new single_button($url, get_string('continue'), $method);
 517          $button->class = 'continuebutton';
 518          return $this->render($button);
 519      }
 520      /**
 521       * Print a backup files tree
 522       * @param array $options
 523       * @return string
 524       */
 525      public function backup_files_viewer(array $options = null) {
 526          $files = new backup_files_viewer($options);
 527          return $this->render($files);
 528      }
 529  
 530      /**
 531       * Displays a backup files viewer
 532       *
 533       * @global stdClass $USER
 534       * @param backup_files_viewer $viewer
 535       * @return string
 536       */
 537      public function render_backup_files_viewer(backup_files_viewer $viewer) {
 538          global $CFG;
 539          $files = $viewer->files;
 540  
 541          $table = new html_table();
 542          $table->attributes['class'] = 'backup-files-table generaltable';
 543          $table->head = array(get_string('filename', 'backup'), get_string('time'), get_string('size'), get_string('download'), get_string('restore'));
 544          $table->width = '100%';
 545          $table->data = array();
 546  
 547          foreach ($files as $file) {
 548              if ($file->is_directory()) {
 549                  continue;
 550              }
 551              $fileurl = moodle_url::make_pluginfile_url(
 552                  $file->get_contextid(),
 553                  $file->get_component(),
 554                  $file->get_filearea(),
 555                  null,
 556                  $file->get_filepath(),
 557                  $file->get_filename(),
 558                  true
 559              );
 560              $params = array();
 561              $params['action'] = 'choosebackupfile';
 562              $params['filename'] = $file->get_filename();
 563              $params['filepath'] = $file->get_filepath();
 564              $params['component'] = $file->get_component();
 565              $params['filearea'] = $file->get_filearea();
 566              $params['filecontextid'] = $file->get_contextid();
 567              $params['contextid'] = $viewer->currentcontext->id;
 568              $params['itemid'] = $file->get_itemid();
 569              $restoreurl = new moodle_url('/backup/restorefile.php', $params);
 570              $table->data[] = array(
 571                  $file->get_filename(),
 572                  userdate($file->get_timemodified()),
 573                  display_size($file->get_filesize()),
 574                  html_writer::link($fileurl, get_string('download')),
 575                  html_writer::link($restoreurl, get_string('restore')),
 576                  );
 577          }
 578  
 579          $html = html_writer::table($table);
 580          $html .= $this->output->single_button(
 581              new moodle_url('/backup/backupfilesedit.php', array(
 582                  'currentcontext' => $viewer->currentcontext->id,
 583                  'contextid' => $viewer->filecontext->id,
 584                  'filearea' => $viewer->filearea,
 585                  'component' => $viewer->component,
 586                  'returnurl' => $this->page->url->out())
 587              ),
 588              get_string('managefiles', 'backup'),
 589              'post'
 590          );
 591  
 592          return $html;
 593      }
 594  
 595      /**
 596       * Renders a restore course search object
 597       *
 598       * @param restore_course_search $component
 599       * @return string
 600       */
 601      public function render_restore_course_search(restore_course_search $component) {
 602          $url = $component->get_url();
 603  
 604          $output = html_writer::start_tag('div', array('class' => 'restore-course-search'));
 605          $output .= html_writer::start_tag('div', array('class' => 'rcs-results'));
 606  
 607          $table = new html_table();
 608          $table->head = array('', get_string('shortnamecourse'), get_string('fullnamecourse'));
 609          $table->data = array();
 610          if ($component->get_count() !== 0) {
 611              foreach ($component->get_results() as $course) {
 612                  $row = new html_table_row();
 613                  $row->attributes['class'] = 'rcs-course';
 614                  if (!$course->visible) {
 615                      $row->attributes['class'] .= ' dimmed';
 616                  }
 617                  $row->cells = array(
 618                      html_writer::empty_tag('input', array('type' => 'radio', 'name' => 'targetid', 'value' => $course->id)),
 619                      format_string($course->shortname, true, array('context' => context_course::instance($course->id))),
 620                      format_string($course->fullname, true, array('context' => context_course::instance($course->id)))
 621                  );
 622                  $table->data[] = $row;
 623              }
 624              if ($component->has_more_results()) {
 625                  $cell = new html_table_cell(get_string('moreresults', 'backup'));
 626                  $cell->colspan = 3;
 627                  $cell->attributes['class'] = 'notifyproblem';
 628                  $row = new html_table_row(array($cell));
 629                  $row->attributes['class'] = 'rcs-course';
 630                  $table->data[] = $row;
 631              }
 632          } else {
 633              $cell = new html_table_cell(get_string('nomatchingcourses', 'backup'));
 634              $cell->colspan = 3;
 635              $cell->attributes['class'] = 'notifyproblem';
 636              $row = new html_table_row(array($cell));
 637              $row->attributes['class'] = 'rcs-course';
 638              $table->data[] = $row;
 639          }
 640          $output .= html_writer::table($table);
 641          $output .= html_writer::end_tag('div');
 642  
 643          $output .= html_writer::start_tag('div', array('class' => 'rcs-search'));
 644          $output .= html_writer::empty_tag('input', array('type' => 'text', 'name' => restore_course_search::$VAR_SEARCH, 'value' => $component->get_search()));
 645          $output .= html_writer::empty_tag('input', array('type' => 'submit', 'name' => 'searchcourses', 'value' => get_string('search')));
 646          $output .= html_writer::end_tag('div');
 647  
 648          $output .= html_writer::end_tag('div');
 649          return $output;
 650      }
 651  
 652      /**
 653       * Renders an import course search object
 654       *
 655       * @param import_course_search $component
 656       * @return string
 657       */
 658      public function render_import_course_search(import_course_search $component) {
 659          $url = $component->get_url();
 660  
 661          $output = html_writer::start_tag('div', array('class' => 'import-course-search'));
 662          if ($component->get_count() === 0) {
 663              $output .= $this->output->notification(get_string('nomatchingcourses', 'backup'));
 664  
 665              $output .= html_writer::start_tag('div', array('class' => 'ics-search'));
 666              $output .= html_writer::empty_tag('input', array('type' => 'text', 'name' => restore_course_search::$VAR_SEARCH, 'value' => $component->get_search()));
 667              $output .= html_writer::empty_tag('input', array('type' => 'submit', 'name' => 'searchcourses', 'value' => get_string('search')));
 668              $output .= html_writer::end_tag('div');
 669  
 670              $output .= html_writer::end_tag('div');
 671              return $output;
 672          }
 673  
 674          $countstr = '';
 675          if ($component->has_more_results()) {
 676              $countstr = get_string('morecoursesearchresults', 'backup', $component->get_count());
 677          } else {
 678              $countstr = get_string('totalcoursesearchresults', 'backup', $component->get_count());
 679          }
 680  
 681          $output .= html_writer::tag('div', $countstr, array('class' => 'ics-totalresults'));
 682          $output .= html_writer::start_tag('div', array('class' => 'ics-results'));
 683  
 684          $table = new html_table();
 685          $table->head = array('', get_string('shortnamecourse'), get_string('fullnamecourse'));
 686          $table->data = array();
 687          foreach ($component->get_results() as $course) {
 688              $row = new html_table_row();
 689              $row->attributes['class'] = 'ics-course';
 690              if (!$course->visible) {
 691                  $row->attributes['class'] .= ' dimmed';
 692              }
 693              $row->cells = array(
 694                  html_writer::empty_tag('input', array('type' => 'radio', 'name' => 'importid', 'value' => $course->id)),
 695                  format_string($course->shortname, true, array('context' => context_course::instance($course->id))),
 696                  format_string($course->fullname, true, array('context' => context_course::instance($course->id)))
 697              );
 698              $table->data[] = $row;
 699          }
 700          if ($component->has_more_results()) {
 701              $cell = new html_table_cell(get_string('moreresults', 'backup'));
 702              $cell->colspan = 3;
 703              $cell->attributes['class'] = 'notifyproblem';
 704              $row = new html_table_row(array($cell));
 705              $row->attributes['class'] = 'rcs-course';
 706              $table->data[] = $row;
 707          }
 708          $output .= html_writer::table($table);
 709          $output .= html_writer::end_tag('div');
 710  
 711          $output .= html_writer::start_tag('div', array('class' => 'ics-search'));
 712          $output .= html_writer::empty_tag('input', array('type' => 'text', 'name' => restore_course_search::$VAR_SEARCH, 'value' => $component->get_search()));
 713          $output .= html_writer::empty_tag('input', array('type' => 'submit', 'name' => 'searchcourses', 'value' => get_string('search')));
 714          $output .= html_writer::end_tag('div');
 715  
 716          $output .= html_writer::end_tag('div');
 717          return $output;
 718      }
 719  
 720      /**
 721       * Renders a restore category search object
 722       *
 723       * @param restore_category_search $component
 724       * @return string
 725       */
 726      public function render_restore_category_search(restore_category_search $component) {
 727          $url = $component->get_url();
 728  
 729          $output = html_writer::start_tag('div', array('class' => 'restore-course-search'));
 730          $output .= html_writer::start_tag('div', array('class' => 'rcs-results'));
 731  
 732          $table = new html_table();
 733          $table->head = array('', get_string('name'), get_string('description'));
 734          $table->data = array();
 735  
 736          if ($component->get_count() !== 0) {
 737              foreach ($component->get_results() as $category) {
 738                  $row = new html_table_row();
 739                  $row->attributes['class'] = 'rcs-course';
 740                  if (!$category->visible) {
 741                      $row->attributes['class'] .= ' dimmed';
 742                  }
 743                  $row->cells = array(
 744                      html_writer::empty_tag('input', array('type' => 'radio', 'name' => 'targetid', 'value' => $category->id)),
 745                      format_string($category->name, true, array('context' => context_coursecat::instance($category->id))),
 746                      format_text($category->description, $category->descriptionformat, array('overflowdiv' => true))
 747                  );
 748                  $table->data[] = $row;
 749              }
 750              if ($component->has_more_results()) {
 751                  $cell = new html_table_cell(get_string('moreresults', 'backup'));
 752                  $cell->attributes['class'] = 'notifyproblem';
 753                  $cell->colspan = 3;
 754                  $row = new html_table_row(array($cell));
 755                  $row->attributes['class'] = 'rcs-course';
 756                  $table->data[] = $row;
 757              }
 758          } else {
 759              $cell = new html_table_cell(get_string('nomatchingcourses', 'backup'));
 760              $cell->colspan = 3;
 761              $cell->attributes['class'] = 'notifyproblem';
 762              $row = new html_table_row(array($cell));
 763              $row->attributes['class'] = 'rcs-course';
 764              $table->data[] = $row;
 765          }
 766          $output .= html_writer::table($table);
 767          $output .= html_writer::end_tag('div');
 768  
 769          $output .= html_writer::start_tag('div', array('class' => 'rcs-search'));
 770          $output .= html_writer::empty_tag('input', array('type' => 'text', 'name' => restore_category_search::$VAR_SEARCH, 'value' => $component->get_search()));
 771          $output .= html_writer::empty_tag('input', array('type' => 'submit', 'name' => 'searchcourses', 'value' => get_string('search')));
 772          $output .= html_writer::end_tag('div');
 773  
 774          $output .= html_writer::end_tag('div');
 775          return $output;
 776      }
 777  }
 778  
 779  /**
 780   * Data structure representing backup files viewer
 781   *
 782   * @copyright 2010 Dongsheng Cai
 783   * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 784   * @since     Moodle 2.0
 785   */
 786  class backup_files_viewer implements renderable {
 787  
 788      /**
 789       * @var array
 790       */
 791      public $files;
 792  
 793      /**
 794       * @var context
 795       */
 796      public $filecontext;
 797  
 798      /**
 799       * @var string
 800       */
 801      public $component;
 802  
 803      /**
 804       * @var string
 805       */
 806      public $filearea;
 807  
 808      /**
 809       * @var context
 810       */
 811      public $currentcontext;
 812  
 813      /**
 814       * Constructor of backup_files_viewer class
 815       * @param array $options
 816       */
 817      public function __construct(array $options = null) {
 818          global $CFG, $USER;
 819          $fs = get_file_storage();
 820          $this->currentcontext = $options['currentcontext'];
 821          $this->filecontext    = $options['filecontext'];
 822          $this->component      = $options['component'];
 823          $this->filearea       = $options['filearea'];
 824          $files = $fs->get_area_files($this->filecontext->id, $this->component, $this->filearea, false, 'timecreated');
 825          $this->files = array_reverse($files);
 826      }
 827  }