Proyectos de Subversion Moodle

<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

/**
 * Auto backups table.
 *
 * @package    report_allbackups
 * @copyright  2020 Catalyst IT
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */

namespace report_allbackups\output;

defined('MOODLE_INTERNAL') || die();

use moodle_url, html_writer, context_system, RecursiveDirectoryIterator, RecursiveIteratorIterator;

require_once($CFG->libdir . '/tablelib.php');

/**
 * Table to display automated backups stored on disk.
 *
 * @package    report_allbackups
 * @copyright  2020 Catalyst IT
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class autobackups_table extends \flexible_table {
    /**
     * autobackups_table constructor.
     *
     * @param string $uniqueid
     * @throws \coding_exception
     */
    public function __construct($uniqueid) {
        global $PAGE, $OUTPUT;
        parent::__construct($uniqueid);
        $url = $PAGE->url;
        $url->param('tab', 'autobackup');
        $this->define_baseurl($url);
        $this->pageable(true);
        if (!optional_param('downloadallselectedfiles', 0, PARAM_ALPHA)) {
            // Set Download flag so we can check it before defining columns/headers to show.
            // Don't set if downloading files.
            $this->is_downloading(optional_param('download', '', PARAM_ALPHA), 'allbackups');
        }

        // Define the list of columns to show.
        $columns = array();
        $headers = array();

        // Add selector column if not downloading report.
        if (!$this->is_downloading()) {
            // Add selector column to report.
            $columns[] = 'selector';

            $options = [
                'id' => 'check-items',
                'name' => 'check-items',
                'value' => 1,
            ];
            $mastercheckbox = new \core\output\checkbox_toggleall('items', true, $options);

            $headers[] = $OUTPUT->render($mastercheckbox);
        }
        $columns = array_merge($columns, array('filename', 'size', 'timemodified'));
        $headers = array_merge($headers, array(get_string('name'), get_string('size'), get_string('date')));

        // Add actions column if not downloading this report.
        if (!$this->is_downloading()) {
            array_push($columns, 'action');
            array_push($headers, get_string('action'));
        }

        $this->define_columns($columns);
        $this->define_headers($headers);
        $this->sortable(true);
        $this->no_sorting('action');
        $this->no_sorting('selector');
        $this->setup();
    }

    /**
     * Helper function to add data to table.
     * Implements custom sort/pagination as we don't use sql to build this table.
     *
     * @throws \dml_exception
     */
    public function adddata() {
        global $SESSION;

        $rows = array();
        $backupdest = get_config('backup', 'backup_auto_destination');
        $directory = new RecursiveDirectoryIterator($backupdest);
        $iterator = new RecursiveIteratorIterator($directory);

        foreach ($iterator as $file) {
            // Sanity check and only include .mbz files.
            if ($file->isFile() && $file->getExtension() == 'mbz') {
                $filename = $file->getFilename();

                // Check against filename filters.
                if (!$this->filter_filename($filename)) {
                    continue;
                }
                $row = new \stdClass();
                $row->filename = $filename;
                $row->timemodified = $file->getMTime();
                $row->size = $file->getSize();

                // Check against timemodified filters.
                if (!$this->filter_timemodified($row->timemodified)) {
                    continue;
                }

                $rows[] = $row;
            }
        }
        // Sort based on fields.
        $tsort = optional_param('tsort', '', PARAM_TEXT);
        $tdir = optional_param('tdir', 0, PARAM_INT);
        if (!empty($tsort) && array_key_exists($tsort, $this->get_sort_columns())) {
            $sort = array_column($rows, $tsort);
            array_multisort($sort, $tdir, $rows);
        }

        $this->totalrows = count($rows);

        if (!$this->is_downloading()) {
            // Only add rows that we want based on page.
            $rowstoprint = array_slice($rows, $this->get_page_start(), $this->get_page_size());
        } else {
            $rowstoprint = $rows;
        }
        $this->format_and_add_array_of_rows($rowstoprint);
    }

    /**
     * Display action row.
     *
     * @param \stdClass $row
     * @return string
     */
    public function col_action($row) {
        global $USER;
        $context = \context_system::instance();
        $fileurl = moodle_url::make_pluginfile_url(
            $context->id,
            'report_allbackups',
            'autobackups',
            null,
            '/',
            $row->filename,
            true
        );
        $output = \html_writer::link($fileurl, get_string('download'));

        if (has_capability('moodle/restore:restorecourse', $context)) {
            $params = array();
            $params['filename'] = $row->filename;
            $restoreurl = new moodle_url('/report/allbackups/restorehandler.php', $params);

            $output .= ' | '. html_writer::link($restoreurl, get_string('restore'));
        }

        if (has_capability('report/allbackups:delete', $context)) {
            $params = array('delete' => $row->filename, 'filename' => $row->filename, 'tab' => 'autobackup');
            $deleteurl = new moodle_url('/report/allbackups/index.php', $params);
            $output .= ' | '. html_writer::link($deleteurl, get_string('delete'));
        }
        return $output;

    }

    /**
     * Display size row.
     *
     * @param \stdClass $row
     * @return \lang_string|string
     */
    public function col_size($row) {
        return display_size($row->size);
    }

    /**
     * Display timemodified.
     *
     * @param \stdClass $row
     * @return string
     */
    public function col_timemodified($row) {
        return userdate($row->timemodified);
    }

    /**
     * Function to display the checkbox for bulk actions.
     *
     * @param \stdClass $row the data from the db containing all fields from the current row.
     * @return string
     */
    public function col_selector($row) {
        global $OUTPUT;
        if ($this->is_downloading()) {
            return '';
        }
        $options = [
            'id' => 'item'.$row->filename,
            'name' => 'item'.$row->filename,
            'value' => $row->filename,
        ];
        $itemcheckbox = new \core\output\checkbox_toggleall('items', false, $options);
        return $OUTPUT->render($itemcheckbox);
    }


    /**
     * Function to filter results using the filename.
     *
     * @param string $filename
     * @return bool|int
     */
    private function filter_filename($filename) {
        global $SESSION;
        $found = true;

        if (!empty($SESSION->user_filtering['filename'])) {
            foreach ($SESSION->user_filtering['filename'] as $filter) {
                $found = $this->filter_filename_helper($filter['operator'], $filter['value'], $filename);
            }
        }
        return $found;
    }

    /**
     * Helper function to select appropriate regex for filter.
     *
     * @param string $operator
     * @param string $value
     * @param string $filename
     * @return false|int
     */
    private function filter_filename_helper($operator, $value, $filename) {
        // Filter rows based on any filters set.
        switch ($operator) {
            case 0: // Contains.
                $regex = "/" . $value . "/";
                break;
            case 1: // Does not contain.
                $regex = "/^((?!" . $value . ").)*$/";
                break;
            case 2: // Equal to.
                $regex = "/^" . $value . "$/";
                break;
            case 3: // Starts with.
                $regex = "/^" . $value . "/";
                break;
            case 4: // Ends with.
                $regex = "/" . $value . "$/";
                break;
            case 5: // Empty.
                $regex = "/^$/";
                break;
        }
        return preg_match($regex, $filename);
    }

    /**
     * Filter for timemodified.
     *
     * @param int $timemodified
     * @return bool
     */
    private function filter_timemodified($timemodified) {
        global $SESSION;
        $found = true;
        if (!empty($SESSION->user_filtering['timecreated'])) {
            foreach ($SESSION->user_filtering['timecreated'] as $filter) {
                $found = $this->filter_timemodified_helper($filter['before'], $filter['after'], $timemodified);
            }
        }

        return $found;
    }

    /**
     * Helper function for filter_timemodified.
     *
     * @param int $before
     * @param int $after
     * @param int $timemodified
     * @return bool
     */
    private function filter_timemodified_helper($before, $after, $timemodified) {
        $found = true;
        if (!empty($before)) { // Only if the before value is not empty.
            if ($before < $timemodified) {
                $found = false;
            }
        }
        if (!empty($after)) {
            if ($after > $timemodified) {
                $found = false;
            }
        }
        return $found;
    }
}