backup/util/ui/renderer.php

   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 defined('MOODLE_INTERNAL') || die;
  26
  27 global $CFG;
  28 require_once($CFG->dirroot . '/backup/util/includes/backup_includes.php');
  29 require_once($CFG->dirroot . '/backup/util/includes/restore_includes.php');
  30 require_once($CFG->dirroot . '/backup/moodle2/backup_plan_builder.class.php');
  31
  32 /**
  33  * The primary renderer for the backup.
  34  *
  35  * Can be retrieved with the following code:
  36  * <?php
  37  * $renderer = $PAGE->get_renderer('core', 'backup');
  38  * ?>
  39  *
  40  * @package   core_backup
  41  * @copyright 2010 Sam Hemelryk
  42  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  43  */
  44 class core_backup_renderer extends plugin_renderer_base {
  45
  46     /**
  47      * Same site notification display.
  48      *
  49      * @var string
  50      */
  51     private $samesitenotification = '';
  52
  53     /**
  54      * Renderers a progress bar for the backup or restore given the items that make it up.
  55      *
  56      * @param array $items An array of items
  57      * @return string
  58      */
  59     public function progress_bar(array $items) {
  60         foreach ($items as &$item) {
  61             $text = $item['text'];
  62             unset($item['text']);
  63             if (array_key_exists('link', $item)) {
  64                 $link = $item['link'];
  65                 unset($item['link']);
  66                 $item = html_writer::link($link, $text, $item);
  67             } else {
  68                 $item = html_writer::tag('span', $text, $item);
  69             }
  70         }
  71         return html_writer::tag('div', join(get_separator(), $items), array('class' => 'backup_progress clearfix'));
  72     }
  73
  74     /**
  75      * The backup and restore pages may display a log (if any) in a scrolling box.
  76      *
  77      * @param string $loghtml Log content in HTML format
  78      * @return string HTML content that shows the log
  79      */
  80     public function log_display($loghtml) {
  81         $out = html_writer::start_div('backup_log');
  82         $out .= $this->output->heading(get_string('backuplog', 'backup'));
  83         $out .= html_writer::start_div('backup_log_contents');
  84         $out .= $loghtml;
  85         $out .= html_writer::end_div();
  86         $out .= html_writer::end_div();
  87         return $out;
  88     }
  89
  90     /**
  91      * Set the same site backup notification.
  92      *
  93      */
  94     public function set_samesite_notification() {
  95         $this->samesitenotification = $this->output->notification(get_string('samesitenotification', 'backup'), 'info');
  96     }
  97
  98     /**
  99      * Get the same site backup notification.
 100      *
 101      */
 102     public function get_samesite_notification() {
 103         return $this->samesitenotification;
 104     }
 105
 106     /**
 107      * Prints a dependency notification
 108      *
 109      * @param string $message
 110      * @return string
 111      */
 112     public function dependency_notification($message) {
 113         return html_writer::tag('div', $message, array('class' => 'notification dependencies_enforced'));
 114     }
 115
 116     /**
 117      * Displays the details of a backup file
 118      *
 119      * @param stdClass $details
 120      * @param moodle_url $nextstageurl
 121      * @return string
 122      */
 123     public function backup_details($details, $nextstageurl) {
 124         $yestick = $this->output->pix_icon('i/valid', get_string('yes'));
 125         $notick = $this->output->pix_icon('i/invalid', get_string('no'));
 126
 127         $html  = html_writer::start_tag('div', array('class' => 'backup-restore'));
 128
 129         $html .= html_writer::start_tag('div', array('class' => 'backup-section'));
 130         $html .= $this->output->heading(get_string('backupdetails', 'backup'), 2, array('class' => 'header'));
 131         $html .= $this->backup_detail_pair(get_string('backuptype', 'backup'), get_string('backuptype'.$details->type, 'backup'));
 132         $html .= $this->backup_detail_pair(get_string('backupformat', 'backup'), get_string('backupformat'.$details->format, 'backup'));
 133         $html .= $this->backup_detail_pair(get_string('backupmode', 'backup'), get_string('backupmode'.$details->mode, 'backup'));
 134         $html .= $this->backup_detail_pair(get_string('backupdate', 'backup'), userdate($details->backup_date));
 135         $html .= $this->backup_detail_pair(get_string('moodleversion', 'backup'),
 136                 html_writer::tag('span', $details->moodle_release, array('class' => 'moodle_release')).
 137                 html_writer::tag('span', '['.$details->moodle_version.']', array('class' => 'moodle_version sub-detail')));
 138         $html .= $this->backup_detail_pair(get_string('backupversion', 'backup'),
 139                 html_writer::tag('span', $details->backup_release, array('class' => 'moodle_release')).
 140                 html_writer::tag('span', '['.$details->backup_version.']', array('class' => 'moodle_version sub-detail')));
 141         $html .= $this->backup_detail_pair(get_string('originalwwwroot', 'backup'),
 142                 html_writer::tag('span', $details->original_wwwroot, array('class' => 'originalwwwroot')).
 143                 html_writer::tag('span', '['.$details->original_site_identifier_hash.']', array('class' => 'sitehash sub-detail')));
 144         if (!empty($details->include_file_references_to_external_content)) {
 145             $message = '';
 146             if (backup_general_helper::backup_is_samesite($details)) {
 147                 $message = $yestick . ' ' . get_string('filereferencessamesite', 'backup');
 148             } else {
 149                 $message = $notick . ' ' . get_string('filereferencesnotsamesite', 'backup');
 150             }
 151             $html .= $this->backup_detail_pair(get_string('includefilereferences', 'backup'), $message);
 152         }
 153
 154         $html .= html_writer::end_tag('div');
 155
 156         $html .= html_writer::start_tag('div', array('class' => 'backup-section settings-section'));
 157         $html .= $this->output->heading(get_string('backupsettings', 'backup'), 2, array('class' => 'header'));
 158         foreach ($details->root_settings as $label => $value) {
 159             if ($label == 'filename' or $label == 'user_files') {
 160                 continue;
 161             }
 162             $html .= $this->backup_detail_pair(get_string('rootsetting'.str_replace('_', '', $label), 'backup'), $value ? $yestick : $notick);
 163         }
 164         $html .= html_writer::end_tag('div');
 165
 166         if ($details->type === 'course') {
 167             $html .= html_writer::start_tag('div', array('class' => 'backup-section'));
 168             $html .= $this->output->heading(get_string('backupcoursedetails', 'backup'), 2, array('class' => 'header'));
 169             $html .= $this->backup_detail_pair(get_string('coursetitle', 'backup'), $details->course->title);
 170             $html .= $this->backup_detail_pair(get_string('courseid', 'backup'), $details->course->courseid);
 171
 172             // Warning users about front page backups.
 173             if ($details->original_course_format === 'site') {
 174                 $html .= $this->backup_detail_pair(get_string('type_format', 'plugin'), get_string('sitecourseformatwarning', 'backup'));
 175             }
 176             $html .= html_writer::start_tag('div', array('class' => 'backup-sub-section'));
 177             $html .= $this->output->heading(get_string('backupcoursesections', 'backup'), 3, array('class' => 'subheader'));
 178             foreach ($details->sections as $key => $section) {
 179                 $included = $key.'_included';
 180                 $userinfo = $key.'_userinfo';
 181                 if ($section->settings[$included] && $section->settings[$userinfo]) {
 182                     $value = get_string('sectionincanduser', 'backup');
 183                 } else if ($section->settings[$included]) {
 184                     $value = get_string('sectioninc', 'backup');
 185                 } else {
 186                     continue;
 187                 }
 188                 $html .= $this->backup_detail_pair(get_string('backupcoursesection', 'backup', $section->title), $value);
 189                 $table = null;
 190                 foreach ($details->activities as $activitykey => $activity) {
 191                     if ($activity->sectionid != $section->sectionid) {
 192                         continue;
 193                     }
 194                     if (empty($table)) {
 195                         $table = new html_table();
 196                         $table->head = array(get_string('module', 'backup'), get_string('title', 'backup'), get_string('userinfo', 'backup'));
 197                         $table->colclasses = array('modulename', 'moduletitle', 'userinfoincluded');
 198                         $table->align = array('left', 'left', 'center');
 199                         $table->attributes = array('class' => 'activitytable generaltable');
 200                         $table->data = array();
 201                     }
 202                     $name = get_string('pluginname', $activity->modulename);
 203                     $icon = new image_icon('icon', $name, $activity->modulename, array('class' => 'iconlarge icon-pre'));
 204                     $table->data[] = array(
 205                         $this->output->render($icon).$name,
 206                         $activity->title,
 207                         ($activity->settings[$activitykey.'_userinfo']) ? $yestick : $notick,
 208                     );
 209                 }
 210                 if (!empty($table)) {
 211                     $html .= $this->backup_detail_pair(get_string('sectionactivities', 'backup'), html_writer::table($table));
 212                 }
 213
 214             }
 215             $html .= html_writer::end_tag('div');
 216             $html .= html_writer::end_tag('div');
 217         }
 218
 219         $html .= $this->continue_button($nextstageurl, 'post');
 220         $html .= html_writer::end_tag('div');
 221
 222         return $html;
 223     }
 224
 225     /**
 226      * Displays the general information about a backup file with non-standard format
 227      *
 228      * @param moodle_url $nextstageurl URL to send user to
 229      * @param array $details basic info about the file (format, type)
 230      * @return string HTML code to display
 231      */
 232     public function backup_details_nonstandard($nextstageurl, array $details) {
 233
 234         $html  = html_writer::start_tag('div', array('class' => 'backup-restore nonstandardformat'));
 235         $html .= html_writer::start_tag('div', array('class' => 'backup-section'));
 236         $html .= $this->output->heading(get_string('backupdetails', 'backup'), 2, 'header');
 237         $html .= $this->output->box(get_string('backupdetailsnonstandardinfo', 'backup'), 'noticebox');
 238         $html .= $this->backup_detail_pair(
 239             get_string('backupformat', 'backup'),
 240             get_string('backupformat'.$details['format'], 'backup'));
 241         $html .= $this->backup_detail_pair(
 242             get_string('backuptype', 'backup'),
 243             get_string('backuptype'.$details['type'], 'backup'));
 244         $html .= html_writer::end_tag('div');
 245         $html .= $this->continue_button($nextstageurl, 'post');
 246         $html .= html_writer::end_tag('div');
 247
 248         return $html;
 249     }
 250
 251     /**
 252      * Displays the general information about a backup file with unknown format
 253      *
 254      * @param moodle_url $nextstageurl URL to send user to
 255      * @return string HTML code to display
 256      */
 257     public function backup_details_unknown(moodle_url $nextstageurl) {
 258
 259         $html  = html_writer::start_div('unknownformat');
 260         $html .= $this->output->heading(get_string('errorinvalidformat', 'backup'), 2);
 261         $html .= $this->output->notification(get_string('errorinvalidformatinfo', 'backup'), 'notifyproblem');
 262         $html .= $this->continue_button($nextstageurl, 'post');
 263         $html .= html_writer::end_div();
 264
 265         return $html;
 266     }
 267
 268     /**
 269      * Displays a course selector for restore
 270      *
 271      * @param moodle_url $nextstageurl
 272      * @param bool $wholecourse true if we are restoring whole course (as with backup::TYPE_1COURSE), false otherwise
 273      * @param restore_category_search $categories
 274      * @param restore_course_search $courses
 275      * @param int $currentcourse
 276      * @return string
 277      */
 278     public function course_selector(moodle_url $nextstageurl, $wholecourse = true, restore_category_search $categories = null,
 279                                     restore_course_search $courses = null, $currentcourse = null) {
 280         global $CFG;
 281         require_once($CFG->dirroot.'/course/lib.php');
 282
 283         // These variables are used to check if the form using this function was submitted.
 284         $target = optional_param('target', false, PARAM_INT);
 285         $targetid = optional_param('targetid', null, PARAM_INT);
 286
 287         // Check if they submitted the form but did not provide all the data we need.
 288         $missingdata = false;
 289         if ($target and is_null($targetid)) {
 290             $missingdata = true;
 291         }
 292
 293         $nextstageurl->param('sesskey', sesskey());
 294
 295         $form = html_writer::start_tag('form', array('method' => 'post', 'action' => $nextstageurl->out_omit_querystring(),
 296             'class' => 'mform'));
 297         foreach ($nextstageurl->params() as $key => $value) {
 298             $form .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => $key, 'value' => $value));
 299         }
 300
 301         $hasrestoreoption = false;
 302
 303         $html  = html_writer::start_tag('div', array('class' => 'backup-course-selector backup-restore'));
 304         if ($wholecourse && !empty($categories) && ($categories->get_count() > 0 || $categories->get_search())) {
 305             // New course.
 306             $hasrestoreoption = true;
 307             $html .= $form;
 308             $html .= html_writer::start_tag('div', array('class' => 'bcs-new-course backup-section'));
 309             $html .= $this->output->heading(get_string('restoretonewcourse', 'backup'), 2, array('class' => 'header'));
 310             $html .= $this->backup_detail_input(get_string('restoretonewcourse', 'backup'), 'radio', 'target',
 311                 backup::TARGET_NEW_COURSE, array('checked' => 'checked'));
 312             $selectacategoryhtml = $this->backup_detail_pair(get_string('selectacategory', 'backup'), $this->render($categories));
 313             // Display the category selection as required if the form was submitted but this data was not supplied.
 314             if ($missingdata && $target == backup::TARGET_NEW_COURSE) {
 315                 $html .= html_writer::span(get_string('required'), 'error');
 316                 $html .= html_writer::start_tag('fieldset', array('class' => 'error'));
 317                 $html .= $selectacategoryhtml;
 318                 $html .= html_writer::end_tag('fieldset');
 319             } else {
 320                 $html .= $selectacategoryhtml;
 321             }
 322             $attrs = array('type' => 'submit', 'value' => get_string('continue'), 'class' => 'btn btn-primary');
 323             $html .= $this->backup_detail_pair('', html_writer::empty_tag('input', $attrs));
 324             $html .= html_writer::end_tag('div');
 325             $html .= html_writer::end_tag('form');
 326         }
 327
 328         if ($wholecourse && !empty($currentcourse)) {
 329             // Current course.
 330             $hasrestoreoption = true;
 331             $html .= $form;
 332             $html .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => 'targetid', 'value' => $currentcourse));
 333             $html .= html_writer::start_tag('div', array('class' => 'bcs-current-course backup-section'));
 334             $html .= $this->output->heading(get_string('restoretocurrentcourse', 'backup'), 2, array('class' => 'header'));
 335             $html .= $this->backup_detail_input(get_string('restoretocurrentcourseadding', 'backup'), 'radio', 'target',
 336                 backup::TARGET_CURRENT_ADDING, array('checked' => 'checked'));
 337             $html .= $this->backup_detail_input(get_string('restoretocurrentcoursedeleting', 'backup'), 'radio', 'target',
 338                 backup::TARGET_CURRENT_DELETING);
 339             $attrs = array('type' => 'submit', 'value' => get_string('continue'), 'class' => 'btn btn-primary');
 340             $html .= $this->backup_detail_pair('', html_writer::empty_tag('input', $attrs));
 341             $html .= html_writer::end_tag('div');
 342             $html .= html_writer::end_tag('form');
 343         }
 344
 345         // If we are restoring an activity, then include the current course.
 346         if (!$wholecourse) {
 347             $courses->invalidate_results(); // Clean list of courses.
 348             $courses->set_include_currentcourse();
 349         }
 350         if (!empty($courses) && ($courses->get_count() > 0 || $courses->get_search())) {
 351             // Existing course.
 352             $hasrestoreoption = true;
 353             $html .= $form;
 354             $html .= html_writer::start_tag('div', array('class' => 'bcs-existing-course backup-section'));
 355             $html .= $this->output->heading(get_string('restoretoexistingcourse', 'backup'), 2, array('class' => 'header'));
 356             if ($wholecourse) {
 357                 $html .= $this->backup_detail_input(get_string('restoretoexistingcourseadding', 'backup'), 'radio', 'target',
 358                     backup::TARGET_EXISTING_ADDING, array('checked' => 'checked'));
 359                 $html .= $this->backup_detail_input(get_string('restoretoexistingcoursedeleting', 'backup'), 'radio', 'target',
 360                     backup::TARGET_EXISTING_DELETING);
 361             } else {
 362                 $html .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => 'target', 'value' => backup::TARGET_EXISTING_ADDING));
 363             }
 364             $selectacoursehtml = $this->backup_detail_pair(get_string('selectacourse', 'backup'), $this->render($courses));
 365             // Display the course selection as required if the form was submitted but this data was not supplied.
 366             if ($missingdata && $target == backup::TARGET_EXISTING_ADDING) {
 367                 $html .= html_writer::span(get_string('required'), 'error');
 368                 $html .= html_writer::start_tag('fieldset', array('class' => 'error'));
 369                 $html .= $selectacoursehtml;
 370                 $html .= html_writer::end_tag('fieldset');
 371             } else {
 372                 $html .= $selectacoursehtml;
 373             }
 374             $attrs = array('type' => 'submit', 'value' => get_string('continue'), 'class' => 'btn btn-primary');
 375             $html .= $this->backup_detail_pair('', html_writer::empty_tag('input', $attrs));
 376             $html .= html_writer::end_tag('div');
 377             $html .= html_writer::end_tag('form');
 378         }
 379
 380         if (!$hasrestoreoption) {
 381             echo $this->output->notification(get_string('norestoreoptions', 'backup'));
 382         }
 383
 384         $html .= html_writer::end_tag('div');
 385         return $html;
 386     }
 387
 388     /**
 389      * Displays the import course selector
 390      *
 391      * @param moodle_url $nextstageurl
 392      * @param import_course_search $courses
 393      * @return string
 394      */
 395     public function import_course_selector(moodle_url $nextstageurl, import_course_search $courses = null) {
 396         $html  = html_writer::start_tag('div', array('class' => 'import-course-selector backup-restore'));
 397         $html .= html_writer::start_tag('form', array('method' => 'post', 'action' => $nextstageurl->out_omit_querystring()));
 398         foreach ($nextstageurl->params() as $key => $value) {
 399             $html .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => $key, 'value' => $value));
 400         }
 401         // We only allow import adding for now. Enforce it here.
 402         $html .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => 'target', 'value' => backup::TARGET_CURRENT_ADDING));
 403         $html .= html_writer::start_tag('div', array('class' => 'ics-existing-course backup-section'));
 404         $html .= $this->output->heading(get_string('importdatafrom'), 2, array('class' => 'header'));
 405         $html .= $this->backup_detail_pair(get_string('selectacourse', 'backup'), $this->render($courses));
 406         $attrs = array('type' => 'submit', 'value' => get_string('continue'), 'class' => 'btn btn-primary');
 407         $html .= html_writer::start_tag('div', array('class' => 'mt-3'));
 408         $html .= $this->backup_detail_pair('', html_writer::empty_tag('input', $attrs));
 409         $html .= html_writer::end_tag('div');
 410         $html .= html_writer::end_tag('div');
 411         $html .= html_writer::end_tag('form');
 412         $html .= html_writer::end_tag('div');
 413         return $html;
 414     }
 415
 416     /**
 417      * Creates a detailed pairing (key + value)
 418      *
 419      * @staticvar int $count
 420      * @param string $label
 421      * @param string $value
 422      * @return string
 423      */
 424     protected function backup_detail_pair($label, $value) {
 425         static $count = 0;
 426         $count ++;
 427         $html  = html_writer::start_tag('div', array('class' => 'detail-pair'));
 428         $html .= html_writer::tag('label', $label, array('class' => 'detail-pair-label', 'for' => 'detail-pair-value-'.$count));
 429         $html .= html_writer::tag('div', $value, array('class' => 'detail-pair-value pl-2', 'name' => 'detail-pair-value-'.$count));
 430         $html .= html_writer::end_tag('div');
 431         return $html;
 432     }
 433
 434     /**
 435      * Created a detailed pairing with an input
 436      *
 437      * @param string $label
 438      * @param string $type
 439      * @param string $name
 440      * @param string $value
 441      * @param array $attributes
 442      * @param string|null $description
 443      * @return string
 444      */
 445     protected function backup_detail_input($label, $type, $name, $value, array $attributes = array(), $description = null) {
 446         if (!empty($description)) {
 447             $description = html_writer::tag('span', $description, array('class' => 'description'));
 448         } else {
 449             $description = '';
 450         }
 451         return $this->backup_detail_pair(
 452             $label,
 453             html_writer::empty_tag('input', $attributes + array('name' => $name, 'type' => $type, 'value' => $value)) . $description
 454         );
 455     }
 456
 457     /**
 458      * Creates a detailed pairing with a select
 459      *
 460      * @param string $label
 461      * @param string $name
 462      * @param array $options
 463      * @param string $selected
 464      * @param bool $nothing
 465      * @param array $attributes
 466      * @param string|null $description
 467      * @return string
 468      */
 469     protected function backup_detail_select($label, $name, $options, $selected = '', $nothing = false, array $attributes = array(), $description = null) {
 470         if (!empty ($description)) {
 471             $description = html_writer::tag('span', $description, array('class' => 'description'));
 472         } else {
 473             $description = '';
 474         }
 475         return $this->backup_detail_pair($label, html_writer::select($options, $name, $selected, false, $attributes).$description);
 476     }
 477
 478     /**
 479      * Displays precheck notices
 480      *
 481      * @param array $results
 482      * @return string
 483      */
 484     public function precheck_notices($results) {
 485         $output = html_writer::start_tag('div', array('class' => 'restore-precheck-notices'));
 486         if (array_key_exists('errors', $results)) {
 487             foreach ($results['errors'] as $error) {
 488                 $output .= $this->output->notification($error);
 489             }
 490         }
 491         if (array_key_exists('warnings', $results)) {
 492             foreach ($results['warnings'] as $warning) {
 493                 $output .= $this->output->notification($warning, 'notifyproblem');
 494             }
 495         }
 496         return $output.html_writer::end_tag('div');
 497     }
 498
 499     /**
 500      * Displays substage buttons
 501      *
 502      * @param bool $haserrors
 503      * @return string
 504      */
 505     public function substage_buttons($haserrors) {
 506         $output  = html_writer::start_tag('div', array('continuebutton'));
 507         if (!$haserrors) {
 508             $attrs = array('type' => 'submit', 'value' => get_string('continue'), 'class' => 'btn btn-primary');
 509             $output .= html_writer::empty_tag('input', $attrs);
 510         }
 511         $attrs = array('type' => 'submit', 'name' => 'cancel', 'value' => get_string('cancel'), 'class' => 'btn btn-secondary');
 512         $output .= html_writer::empty_tag('input', $attrs);
 513         $output .= html_writer::end_tag('div');
 514         return $output;
 515     }
 516
 517     /**
 518      * Displays a role mapping interface
 519      *
 520      * @param array $rolemappings
 521      * @param array $roles
 522      * @return string
 523      */
 524     public function role_mappings($rolemappings, $roles) {
 525         $roles[0] = get_string('none');
 526         $output  = html_writer::start_tag('div', array('class' => 'restore-rolemappings'));
 527         $output .= $this->output->heading(get_string('restorerolemappings', 'backup'), 2);
 528         foreach ($rolemappings as $id => $mapping) {
 529             $label = $mapping->name;
 530             $name = 'mapping'.$id;
 531             $selected = $mapping->targetroleid;
 532             $output .= $this->backup_detail_select($label, $name, $roles, $mapping->targetroleid, false, array(), $mapping->description);
 533         }
 534         $output .= html_writer::end_tag('div');
 535         return $output;
 536     }
 537
 538     /**
 539      * Displays a continue button
 540      *
 541      * @param string|moodle_url $url
 542      * @param string $method
 543      * @return string
 544      */
 545     public function continue_button($url, $method = 'post') {
 546         if (!($url instanceof moodle_url)) {
 547             $url = new moodle_url($url);
 548         }
 549         if ($method != 'post') {
 550             $method = 'get';
 551         }
 552         $url->param('sesskey', sesskey());
 553         $button = new single_button($url, get_string('continue'), $method, true);
 554         $button->class = 'continuebutton';
 555         return $this->render($button);
 556     }
 557     /**
 558      * Print a backup files tree
 559      * @param array $options
 560      * @return string
 561      */
 562     public function backup_files_viewer(array $options = null) {
 563         $files = new backup_files_viewer($options);
 564         return $this->render($files);
 565     }
 566
 567     /**
 568      * Generate the status indicator markup for display in the
 569      * backup restore file area UI.
 570      *
 571      * @param int $statuscode The status code of the backup.
 572      * @param string $backupid The backup record id.
 573      * @return string|boolean $status The status indicator for the operation.
 574      */
 575     public function get_status_display($statuscode, $backupid, $restoreid=null, $operation='backup') {
 576         if ($statuscode == backup::STATUS_AWAITING
 577             || $statuscode == backup::STATUS_EXECUTING
 578             || $statuscode == backup::STATUS_REQUIRE_CONV) {  // In progress.
 579             $progresssetup = array(
 580                 'backupid' => $backupid,
 581                 'restoreid' => $restoreid,
 582                 'operation' => $operation,
 583                 'width' => '100'
 584             );
 585             $status = $this->render_from_template('core/async_backup_progress', $progresssetup);
 586         } else if ($statuscode == backup::STATUS_FINISHED_ERR) { // Error.
 587             $icon = $this->output->render(new \pix_icon('i/delete', get_string('failed', 'backup')));
 588             $status = \html_writer::span($icon, 'action-icon');
 589         } else if ($statuscode == backup::STATUS_FINISHED_OK) { // Complete.
 590             $icon = $this->output->render(new \pix_icon('i/checked', get_string('successful', 'backup')));
 591             $status = \html_writer::span($icon, 'action-icon');
 592         }
 593
 594         return $status;
 595     }
 596
 597     /**
 598      * Displays a backup files viewer
 599      *
 600      * @global stdClass $USER
 601      * @param backup_files_viewer $viewer
 602      * @return string
 603      */
 604     public function render_backup_files_viewer(backup_files_viewer $viewer) {
 605         global $CFG;
 606         $files = $viewer->files;
 607
 608         $async = async_helper::is_async_enabled();
 609
 610         $tablehead = array(
 611                 get_string('filename', 'backup'),
 612                 get_string('time'),
 613                 get_string('size'),
 614                 get_string('download'),
 615                 get_string('restore'));
 616         if ($async) {
 617             $tablehead[] = get_string('status', 'backup');
 618         }
 619
 620         $table = new html_table();
 621         $table->attributes['class'] = 'backup-files-table generaltable';
 622         $table->head = $tablehead;
 623         $table->width = '100%';
 624         $table->data = array();
 625
 626         // First add in progress asynchronous backups.
 627         // Only if asynchronous backups are enabled.
 628         // Also only render async status in correct area. Courese OR activity (not both).
 629         if ($async
 630                 && (($viewer->filearea == 'course' && $viewer->currentcontext->contextlevel == CONTEXT_COURSE)
 631                 || ($viewer->filearea == 'activity' && $viewer->currentcontext->contextlevel == CONTEXT_MODULE))
 632                 ) {
 633                     $table->data = \async_helper::get_async_backups($this, $viewer->currentcontext->instanceid);
 634         }
 635
 636         // Add completed backups.
 637         foreach ($files as $file) {
 638             if ($file->is_directory()) {
 639                 continue;
 640             }
 641             $fileurl = moodle_url::make_pluginfile_url(
 642                 $file->get_contextid(),
 643                 $file->get_component(),
 644                 $file->get_filearea(),
 645                 null,
 646                 $file->get_filepath(),
 647                 $file->get_filename(),
 648                 true
 649             );
 650             $params = array();
 651             $params['action'] = 'choosebackupfile';
 652             $params['filename'] = $file->get_filename();
 653             $params['filepath'] = $file->get_filepath();
 654             $params['component'] = $file->get_component();
 655             $params['filearea'] = $file->get_filearea();
 656             $params['filecontextid'] = $file->get_contextid();
 657             $params['contextid'] = $viewer->currentcontext->id;
 658             $params['itemid'] = $file->get_itemid();
 659             $restoreurl = new moodle_url('/backup/restorefile.php', $params);
 660             $restorelink = html_writer::link($restoreurl, get_string('restore'));
 661             $downloadlink = html_writer::link($fileurl, get_string('download'));
 662
 663             // Conditional display of the restore and download links, initially only for the 'automated' filearea.
 664             if ($params['filearea'] == 'automated') {
 665                 if (!has_capability('moodle/restore:viewautomatedfilearea', $viewer->currentcontext)) {
 666                     $restorelink = '';
 667                 }
 668                 if (!can_download_from_backup_filearea($params['filearea'], $viewer->currentcontext)) {
 669                     $downloadlink = '';
 670                 }
 671             }
 672             $tabledata = array(
 673                 $file->get_filename(),
 674                 userdate ($file->get_timemodified()),
 675                 display_size ($file->get_filesize()),
 676                 $downloadlink,
 677                 $restorelink
 678             );
 679             if ($async) {
 680                 $tabledata[] = $this->get_status_display(backup::STATUS_FINISHED_OK, null);
 681             }
 682
 683             $table->data[] = $tabledata;
 684         }
 685
 686         $html = html_writer::table($table);
 687
 688         // For automated backups, the ability to manage backup files is controlled by the ability to download them.
 689         // All files must be from the same file area in a backup_files_viewer.
 690         $canmanagebackups = true;
 691         if ($viewer->filearea == 'automated') {
 692             if (!can_download_from_backup_filearea($viewer->filearea, $viewer->currentcontext)) {
 693                 $canmanagebackups = false;
 694             }
 695         }
 696
 697         if ($canmanagebackups) {
 698             $html .= $this->output->single_button(
 699                 new moodle_url('/backup/backupfilesedit.php', array(
 700                         'currentcontext' => $viewer->currentcontext->id,
 701                         'contextid' => $viewer->filecontext->id,
 702                         'filearea' => $viewer->filearea,
 703                         'component' => $viewer->component,
 704                         'returnurl' => $this->page->url->out())
 705                 ),
 706                 get_string('managefiles', 'backup'),
 707                 'post'
 708             );
 709         }
 710
 711         return $html;
 712     }
 713
 714     /**
 715      * Renders a restore course search object
 716      *
 717      * @param restore_course_search $component
 718      * @return string
 719      */
 720     public function render_restore_course_search(restore_course_search $component) {
 721         $url = $component->get_url();
 722
 723         $output = html_writer::start_tag('div', array('class' => 'restore-course-search form-inline mb-1'));
 724         $output .= html_writer::start_tag('div', array('class' => 'rcs-results table-sm w-75'));
 725
 726         $table = new html_table();
 727         $table->head = array('', get_string('shortnamecourse'), get_string('fullnamecourse'));
 728         $table->data = array();
 729         if ($component->get_count() !== 0) {
 730             foreach ($component->get_results() as $course) {
 731                 $row = new html_table_row();
 732                 $row->attributes['class'] = 'rcs-course';
 733                 if (!$course->visible) {
 734                     $row->attributes['class'] .= ' dimmed';
 735                 }
 736                 $row->cells = array(
 737                     html_writer::empty_tag('input', array('type' => 'radio', 'name' => 'targetid', 'value' => $course->id)),
 738                     format_string($course->shortname, true, array('context' => context_course::instance($course->id))),
 739                     format_string($course->fullname, true, array('context' => context_course::instance($course->id)))
 740                 );
 741                 $table->data[] = $row;
 742             }
 743             if ($component->has_more_results()) {
 744                 $cell = new html_table_cell(get_string('moreresults', 'backup'));
 745                 $cell->colspan = 3;
 746                 $cell->attributes['class'] = 'notifyproblem';
 747                 $row = new html_table_row(array($cell));
 748                 $row->attributes['class'] = 'rcs-course';
 749                 $table->data[] = $row;
 750             }
 751         } else {
 752             $cell = new html_table_cell(get_string('nomatchingcourses', 'backup'));
 753             $cell->colspan = 3;
 754             $cell->attributes['class'] = 'notifyproblem';
 755             $row = new html_table_row(array($cell));
 756             $row->attributes['class'] = 'rcs-course';
 757             $table->data[] = $row;
 758         }
 759         $output .= html_writer::table($table);
 760         $output .= html_writer::end_tag('div');
 761
 762         $output .= html_writer::start_tag('div', array('class' => 'rcs-search'));
 763         $attrs = array(
 764             'type' => 'text',
 765             'name' => restore_course_search::$VAR_SEARCH,
 766             'value' => $component->get_search(),
 767             'class' => 'form-control'
 768         );
 769         $output .= html_writer::empty_tag('input', $attrs);
 770         $attrs = array(
 771             'type' => 'submit',
 772             'name' => 'searchcourses',
 773             'value' => get_string('search'),
 774             'class' => 'btn btn-secondary'
 775         );
 776         $output .= html_writer::empty_tag('input', $attrs);
 777         $output .= html_writer::end_tag('div');
 778
 779         $output .= html_writer::end_tag('div');
 780         return $output;
 781     }
 782
 783     /**
 784      * Renders an import course search object
 785      *
 786      * @param import_course_search $component
 787      * @return string
 788      */
 789     public function render_import_course_search(import_course_search $component) {
 790         $url = $component->get_url();
 791
 792         $output = html_writer::start_tag('div', array('class' => 'import-course-search'));
 793         if ($component->get_count() === 0) {
 794             $output .= $this->output->notification(get_string('nomatchingcourses', 'backup'));
 795
 796             $output .= html_writer::start_tag('div', array('class' => 'ics-search form-inline'));
 797             $attrs = array(
 798                 'type' => 'text',
 799                 'name' => restore_course_search::$VAR_SEARCH,
 800                 'value' => $component->get_search(),
 801                 'class' => 'form-control'
 802             );
 803             $output .= html_writer::empty_tag('input', $attrs);
 804             $attrs = array(
 805                 'type' => 'submit',
 806                 'name' => 'searchcourses',
 807                 'value' => get_string('search'),
 808                 'class' => 'btn btn-secondary ml-1'
 809             );
 810             $output .= html_writer::empty_tag('input', $attrs);
 811             $output .= html_writer::end_tag('div');
 812
 813             $output .= html_writer::end_tag('div');
 814             return $output;
 815         }
 816
 817         $countstr = '';
 818         if ($component->has_more_results()) {
 819             $countstr = get_string('morecoursesearchresults', 'backup', $component->get_count());
 820         } else {
 821             $countstr = get_string('totalcoursesearchresults', 'backup', $component->get_count());
 822         }
 823
 824         $output .= html_writer::tag('div', $countstr, array('class' => 'ics-totalresults'));
 825         $output .= html_writer::start_tag('div', array('class' => 'ics-results'));
 826
 827         $table = new html_table();
 828         $table->head = array('', get_string('shortnamecourse'), get_string('fullnamecourse'));
 829         $table->data = array();
 830         foreach ($component->get_results() as $course) {
 831             $row = new html_table_row();
 832             $row->attributes['class'] = 'ics-course';
 833             if (!$course->visible) {
 834                 $row->attributes['class'] .= ' dimmed';
 835             }
 836             $row->cells = array(
 837                 html_writer::empty_tag('input', array('type' => 'radio', 'name' => 'importid', 'value' => $course->id)),
 838                 format_string($course->shortname, true, array('context' => context_course::instance($course->id))),
 839                 format_string($course->fullname, true, array('context' => context_course::instance($course->id)))
 840             );
 841             $table->data[] = $row;
 842         }
 843         if ($component->has_more_results()) {
 844             $cell = new html_table_cell(get_string('moreresults', 'backup'));
 845             $cell->colspan = 3;
 846             $cell->attributes['class'] = 'notifyproblem';
 847             $row = new html_table_row(array($cell));
 848             $row->attributes['class'] = 'rcs-course';
 849             $table->data[] = $row;
 850         }
 851         $output .= html_writer::table($table);
 852         $output .= html_writer::end_tag('div');
 853
 854         $output .= html_writer::start_tag('div', array('class' => 'ics-search form-inline'));
 855         $attrs = array(
 856             'type' => 'text',
 857             'name' => restore_course_search::$VAR_SEARCH,
 858             'value' => $component->get_search(),
 859             'class' => 'form-control');
 860         $output .= html_writer::empty_tag('input', $attrs);
 861         $attrs = array(
 862             'type' => 'submit',
 863             'name' => 'searchcourses',
 864             'value' => get_string('search'),
 865             'class' => 'btn btn-secondary ml-1'
 866         );
 867         $output .= html_writer::empty_tag('input', $attrs);
 868         $output .= html_writer::end_tag('div');
 869
 870         $output .= html_writer::end_tag('div');
 871         return $output;
 872     }
 873
 874     /**
 875      * Renders a restore category search object
 876      *
 877      * @param restore_category_search $component
 878      * @return string
 879      */
 880     public function render_restore_category_search(restore_category_search $component) {
 881         $url = $component->get_url();
 882
 883         $output = html_writer::start_tag('div', array('class' => 'restore-course-search form-inline mb-1'));
 884         $output .= html_writer::start_tag('div', array('class' => 'rcs-results table-sm w-75'));
 885
 886         $table = new html_table();
 887         $table->head = array('', get_string('name'), get_string('description'));
 888         $table->data = array();
 889
 890         if ($component->get_count() !== 0) {
 891             foreach ($component->get_results() as $category) {
 892                 $row = new html_table_row();
 893                 $row->attributes['class'] = 'rcs-course';
 894                 if (!$category->visible) {
 895                     $row->attributes['class'] .= ' dimmed';
 896                 }
 897                 $context = context_coursecat::instance($category->id);
 898                 $row->cells = array(
 899                     html_writer::empty_tag('input', array('type' => 'radio', 'name' => 'targetid', 'value' => $category->id)),
 900                     format_string($category->name, true, array('context' => context_coursecat::instance($category->id))),
 901                     format_text(file_rewrite_pluginfile_urls($category->description, 'pluginfile.php', $context->id,
 902                         'coursecat', 'description', null), $category->descriptionformat, array('overflowdiv' => true))
 903                 );
 904                 $table->data[] = $row;
 905             }
 906             if ($component->has_more_results()) {
 907                 $cell = new html_table_cell(get_string('moreresults', 'backup'));
 908                 $cell->attributes['class'] = 'notifyproblem';
 909                 $cell->colspan = 3;
 910                 $row = new html_table_row(array($cell));
 911                 $row->attributes['class'] = 'rcs-course';
 912                 $table->data[] = $row;
 913             }
 914         } else {
 915             $cell = new html_table_cell(get_string('nomatchingcourses', 'backup'));
 916             $cell->colspan = 3;
 917             $cell->attributes['class'] = 'notifyproblem';
 918             $row = new html_table_row(array($cell));
 919             $row->attributes['class'] = 'rcs-course';
 920             $table->data[] = $row;
 921         }
 922         $output .= html_writer::table($table);
 923         $output .= html_writer::end_tag('div');
 924
 925         $output .= html_writer::start_tag('div', array('class' => 'rcs-search'));
 926         $attrs = array(
 927             'type' => 'text',
 928             'name' => restore_category_search::$VAR_SEARCH,
 929             'value' => $component->get_search(),
 930             'class' => 'form-control'
 931         );
 932         $output .= html_writer::empty_tag('input', $attrs);
 933         $attrs = array(
 934             'type' => 'submit',
 935             'name' => 'searchcourses',
 936             'value' => get_string('search'),
 937             'class' => 'btn btn-secondary'
 938         );
 939         $output .= html_writer::empty_tag('input', $attrs);
 940         $output .= html_writer::end_tag('div');
 941
 942         $output .= html_writer::end_tag('div');
 943         return $output;
 944     }
 945
 946     /**
 947      * Get markup to render table for all of a users async
 948      * in progress restores.
 949      *
 950      * @param int $userid The Moodle user id.
 951      * @param \context $context The Moodle context for these restores.
 952      * @return string $html The table HTML.
 953      */
 954     public function restore_progress_viewer ($userid, $context) {
 955         $tablehead = array(get_string('course'), get_string('time'), get_string('status', 'backup'));
 956
 957         $table = new html_table();
 958         $table->attributes['class'] = 'backup-files-table generaltable';
 959         $table->head = $tablehead;
 960         $tabledata = array();
 961
 962         // Get all in progress async restores for this user.
 963         $restores = \async_helper::get_async_restores($userid);
 964
 965         // For each backup get, new item name, time restore created and progress.
 966         foreach ($restores as $restore) {
 967
 968             $restorename = \async_helper::get_restore_name($context);
 969             $timecreated = $restore->timecreated;
 970             $status = $this->get_status_display($restore->status, $restore->backupid, $restore->backupid, null, 'restore');
 971
 972             $tablerow = array($restorename, userdate($timecreated), $status);
 973             $tabledata[] = $tablerow;
 974         }
 975
 976         $table->data = $tabledata;
 977         $html = html_writer::table($table);
 978
 979         return $html;
 980     }
 981
 982     /**
 983      * Get markup to render table for all of a users course copies.
 984      *
 985      * @param int $userid The Moodle user id.
 986      * @param int $courseid The id of the course to get the backups for.
 987      * @return string $html The table HTML.
 988      */
 989     public function copy_progress_viewer(int $userid, int $courseid): string {
 990         $tablehead = array(
 991             get_string('copysource', 'backup'),
 992             get_string('copydest', 'backup'),
 993             get_string('time'),
 994             get_string('copyop', 'backup'),
 995             get_string('status', 'backup')
 996         );
 997
 998         $table = new html_table();
 999         $table->attributes['class'] = 'backup-files-table generaltable';
1000         $table->head = $tablehead;
1001
1002         $tabledata = array();
1003
1004         // Get all in progress course copies for this user.
1005         $copies = \core_backup\copy\copy::get_copies($userid, $courseid);
1006
1007         foreach ($copies as $copy) {
1008             $sourceurl = new \moodle_url('/course/view.php', array('id' => $copy->sourceid));
1009
1010             $tablerow = array(
1011                 html_writer::link($sourceurl, $copy->source),
1012                 $copy->destination,
1013                 userdate($copy->time),
1014                 get_string($copy->operation),
1015                 $this->get_status_display($copy->status, $copy->backupid, $copy->restoreid, $copy->operation)
1016             );
1017             $tabledata[] = $tablerow;
1018         }
1019
1020         $table->data = $tabledata;
1021         $html = html_writer::table($table);
1022
1023         return $html;
1024     }
1025 }
1026
1027 /**
1028  * Data structure representing backup files viewer
1029  *
1030  * @copyright 2010 Dongsheng Cai
1031  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
1032  * @since     Moodle 2.0
1033  */
1034 class backup_files_viewer implements renderable {
1035
1036     /**
1037      * @var array
1038      */
1039     public $files;
1040
1041     /**
1042      * @var context
1043      */
1044     public $filecontext;
1045
1046     /**
1047      * @var string
1048      */
1049     public $component;
1050
1051     /**
1052      * @var string
1053      */
1054     public $filearea;
1055
1056     /**
1057      * @var context
1058      */
1059     public $currentcontext;
1060
1061     /**
1062      * Constructor of backup_files_viewer class
1063      * @param array $options
1064      */
1065     public function __construct(array $options = null) {
1066         global $CFG, $USER;
1067         $fs = get_file_storage();
1068         $this->currentcontext = $options['currentcontext'];
1069         $this->filecontext    = $options['filecontext'];
1070         $this->component      = $options['component'];
1071         $this->filearea       = $options['filearea'];
1072         $files = $fs->get_area_files($this->filecontext->id, $this->component, $this->filearea, false, 'timecreated');
1073         $this->files = array_reverse($files);
1074     }
1075 }