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/>.

/**

 * Contains the import_backup_helper class.

 *

 * @package tool_moodlenet

 * @copyright 2020 Adrian Greeve <adrian@moodle.com>

 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

namespace tool_moodlenet\local;

/**

 * The import_backup_helper class.

 *

 * The import_backup_helper objects provide a means to prepare a backup for for restoration of a course or activity backup file.

 *

 * @copyright 2020 Adrian Greeve <adrian@moodle.com>

 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

class import_backup_helper {

    /** @var remote_resource $remoteresource A file resource to be restored. */

    protected $remoteresource;

    /** @var user $user The user trying to restore a file. */

    protected $user;

    /** @var context $context The context we are trying to restore this file into. */

    protected $context;

    /** @var int $useruploadlimit The size limit that this user can upload in this context. */

    protected $useruploadlimit;

    /**

     * Constructor for the import backup helper.

     *

     * @param remote_resource $remoteresource A remote file resource

     * @param \stdClass       $user           The user importing a file.

     * @param \context        $context        Context to restore into.

     */

    public function __construct(remote_resource $remoteresource, \stdClass $user, \context $context) {

        $this->remoteresource = $remoteresource;

        $this->user = $user;

        $this->context = $context;

        $maxbytes = 0;

        if ($this->context->contextlevel == CONTEXT_COURSE) {

            $course = get_course($this->context->instanceid);

            $maxbytes = $course->maxbytes;

        }

        $this->useruploadlimit = get_user_max_upload_file_size($this->context, get_config('core', 'maxbytes'),

                $maxbytes, 0, $this->user);

    }

    /**

     * Return a stored user draft file for processing.

     *

     * @return \stored_file The imported file to ultimately be restored.

     */

    public function get_stored_file(): \stored_file {

        // Check if the user can upload a backup to this context.

        require_capability('moodle/restore:uploadfile', $this->context, $this->user->id);

        // Before starting a potentially lengthy download, try to ensure the file size does not exceed the upload size restrictions

        // for the user. This is a time saving measure.

        // This is a naive check, that serves only to catch files if they provide the content length header.

        // Because of potential content encoding (compression), the stored file will be checked again after download as well.

        $size = $this->remoteresource->get_download_size() ?? -1;

        if ($this->size_exceeds_upload_limit($size)) {

            throw new \moodle_exception('uploadlimitexceeded', 'tool_moodlenet', '', ['filesize' => $size,

                'uploadlimit' => $this->useruploadlimit]);

        }

        [$filepath, $filename] = $this->remoteresource->download_to_requestdir();

        \core\antivirus\manager::scan_file($filepath, $filename, true);

        // Check the final size of file against the user upload limits.

        $localsize = filesize(sprintf('%s/%s', $filepath, $filename));

        if ($this->size_exceeds_upload_limit($localsize)) {

            throw new \moodle_exception('uploadlimitexceeded', 'tool_moodlenet', '', ['filesize' => $localsize,

                'uploadlimit' => $this->useruploadlimit]);

        }

        return $this->create_user_draft_stored_file($filename, $filepath);

    }

    /**

     * Does the size exceed the upload limit for the current import, taking into account user and core settings.

     *

     * @param int $sizeinbytes

     * @return bool true if exceeded, false otherwise.

     */

    protected function size_exceeds_upload_limit(int $sizeinbytes): bool {

        $maxbytes = 0;

        if ($this->context->contextlevel == CONTEXT_COURSE) {

            $course = get_course($this->context->instanceid);

            $maxbytes = $course->maxbytes;

        }

        $maxbytes = get_user_max_upload_file_size($this->context, get_config('core', 'maxbytes'), $maxbytes, 0,

            $this->user);

        if ($maxbytes != USER_CAN_IGNORE_FILE_SIZE_LIMITS && $sizeinbytes > $maxbytes) {

            return true;

        }

        return false;

    }

    /**

     * Create a file in the user drafts ready for use by plugins implementing dndupload_handle().

     *

     * @param string $filename the name of the file on disk

     * @param string $path the path where the file is stored on disk

     * @return \stored_file

     */

    protected function create_user_draft_stored_file(string $filename, string $path): \stored_file {

        global $CFG;

        $record = new \stdClass();

        $record->filearea = 'draft';

        $record->component = 'user';

        $record->filepath = '/';

        $record->itemid   = file_get_unused_draft_itemid();

        $record->license  = $CFG->sitedefaultlicense;

        $record->author   = '';

        $record->filename = clean_param($filename, PARAM_FILE);

        $record->contextid = \context_user::instance($this->user->id)->id;

        $record->userid = $this->user->id;

        $fullpathwithname = sprintf('%s/%s', $path, $filename);

        $fs = get_file_storage();

        return  $fs->create_file_from_pathname($record, $fullpathwithname);

    }

    /**

     * Looks for a context that this user has permission to upload backup files to.

     * This gets a list of roles that the user has, checks for the restore:uploadfile capability and then sends back a context

     * that has this permission if available.

     *

     * This starts with the highest context level and moves down i.e. system -> category -> course.

     *

     * @param  int $userid The user ID that we are looking for a working context for.

     * @return \context A context that allows the upload of backup files.

     */

    public static function get_context_for_user(int $userid): ?\context {

        global $DB;

        if (is_siteadmin()) {

            return \context_system::instance();

        }

        $sql = "SELECT ctx.id, ctx.contextlevel, ctx.instanceid, ctx.path, ctx.depth, ctx.locked

                  FROM {context} ctx

                  JOIN {role_assignments} r ON ctx.id = r.contextid

                 WHERE r.userid = :userid AND ctx.contextlevel IN (:contextsystem, :contextcategory, :contextcourse)

              ORDER BY ctx.contextlevel ASC";

        $params = [

            'userid' => $userid,

            'contextsystem' => CONTEXT_SYSTEM,

            'contextcategory' => CONTEXT_COURSECAT,

            'contextcourse' => CONTEXT_COURSE

        ];

        $records = $DB->get_records_sql($sql, $params);

        foreach ($records as $record) {

            \context_helper::preload_from_record($record);

            if ($record->contextlevel == CONTEXT_COURSECAT) {

                $context = \context_coursecat::instance($record->instanceid);

            } else if ($record->contextlevel == CONTEXT_COURSE) {

                $context = \context_course::instance($record->instanceid);

            } else {

                $context = \context_system::instance();

            }

            if (has_capability('moodle/restore:uploadfile', $context, $userid)) {

                return $context;

            }

        }

        return null;

    }

}