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

/**

 * Internal API of local listcoursefiles.

 *

 * @package    local_listcoursefiles

 * @copyright  2017 Martin Gauk (@innoCampus, TU Berlin)

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

 */

namespace local_listcoursefiles;

/**

 * Class course_files

 * @package local_listcoursefiles

 */

class course_files {

    /** @var int maximum number of files per page. */

    const MAX_FILES = 500;

    /**

     * @var \context

     */

    protected $context;

    /**

     * @var int

     */

    protected $filescount = -1;

    /**

     * @var array

     */

    protected $components = null;

    /**

     * @var array

     */

    protected $filelist = null;

    /**

     * @var string

     */

    protected $filtercomponent;

    /**

     * @var string

     */

    protected $filterfiletype;

    /**

     * @var \course_modinfo

     */

    protected $coursemodinfo;

    /**

     * @var int

     */

    protected $courseid;

    /**

     * course_files constructor.

     * @param integer $courseid

     * @param \context $context

     * @param string $component

     * @param string $filetype

     * @throws \moodle_exception

     */

    public function __construct($courseid, \context $context, $component, $filetype) {

        $this->courseid = $courseid;

        $this->context = $context;

        $this->filtercomponent = $component;

        $this->filterfiletype = $filetype;

        $this->coursemodinfo = get_fast_modinfo($courseid);

    }

    /**

     * Get course id.

     *

     * @return int

     */

    public function get_course_id(): int {

        return $this->courseid;

    }

    /**

     * Get filter component name.

     *

     * @return string

     */

    public function get_filter_component(): string {

        return $this->filtercomponent;

    }

    /**

     * Get filter file type name.

     *

     * @return string

     */

    public function get_filter_file_type(): string {

        return $this->filterfiletype;

    }

    /**

     * Retrieve the files within a course/context.

     *

     * @param int $offset

     * @param int $limit

     * @return array

     */

    public function get_file_list($offset, $limit) {

        global $DB;

        if ($this->filelist !== null) {

            return $this->filelist;

        }

        $availcomponents = $this->get_components();

        $sqlwhere = '';

        $sqlwherecomponent = '';

        if ($this->filtercomponent === 'all_wo_submissions') {

            $sqlwhere .= 'AND f.component NOT LIKE :component';

            $sqlwherecomponent = 'assign%';

        } else if ($this->filtercomponent !== 'all' && isset($availcomponents[$this->filtercomponent])) {

            $sqlwhere .= 'AND f.component LIKE :component';

            $sqlwherecomponent = $this->filtercomponent;

        }

        if ($this->filterfiletype === 'other') {

            $sqlwhere .= ' AND ' . $this->get_sql_mimetype(array_keys(mimetypes::get_mime_types()), false);

        } else if (isset(mimetypes::get_mime_types()[$this->filterfiletype])) {

            $sqlwhere .= ' AND ' . $this->get_sql_mimetype($this->filterfiletype, true);

        }

        $usernameselect = implode(', ', array_map(function($field) {

            return 'u.' . $field;

        }, \core_user\fields::get_name_fields()));

        $sql = "FROM {files} f

           LEFT JOIN {context} c ON (c.id = f.contextid)

           LEFT JOIN {user} u ON (u.id = f.userid)

               WHERE f.filename NOT LIKE '.'

                     AND (c.path LIKE :path OR c.id = :cid) $sqlwhere";

        $sqlselectfiles = "SELECT f.*, c.contextlevel, c.instanceid, $usernameselect $sql

                         ORDER BY f.component, f.filename";

        $params = [

            'path' => $this->context->path . '/%',

            'cid' => $this->context->id,

            'component' => $sqlwherecomponent,

        ];

        $this->filelist = $DB->get_records_sql($sqlselectfiles, $params, $offset, $limit);

        // Determine number of all files.

        if (count($this->filelist) < $limit) {

            $this->filescount = count($this->filelist) + $offset;

        } else {

            $sqlcount = "SELECT COUNT(*) $sql";

            $this->filescount = $DB->count_records_sql($sqlcount, $params);

        }

        return $this->filelist;

    }

    /**

     * Creates an SQL snippet

     *

     * @param mixed $types

     * @param boolean $in

     * @return string

     */

    protected function get_sql_mimetype($types, $in) {

        if (is_array($types)) {

            $list = [];

            foreach ($types as $type) {

                $list = array_merge($list, mimetypes::get_mime_types()[$type]);

            }

        } else {

            $list = &mimetypes::get_mime_types()[$types];

        }

        if ($in) {

            $first = "(f.mimetype LIKE '";

            $glue = "' OR f.mimetype LIKE '";

        } else {

            $first = "(f.mimetype NOT LIKE '";

            $glue = "' AND f.mimetype NOT LIKE '";

        }

        return $first . implode($glue, $list) . "')";

    }

    /**

     * Returns the number of files in a component and with a specific file type.

     * May only be called after get_file_list.

     */

    public function get_file_list_total_size() {

        return $this->filescount;

    }

    /**

     * Get all available components with files.

     * @return array

     */

    public function get_components() {

        global $DB;

        if ($this->components !== null) {

            return $this->components;

        }

        $sql = "SELECT f.component

                  FROM {files} f

             LEFT JOIN {context} c ON (c.id = f.contextid)

                 WHERE f.filename NOT LIKE '.'

                       AND (c.path LIKE :path OR c.id = :cid)

              GROUP BY f.component";

        $params = ['path' => $this->context->path . '/%', 'cid' => $this->context->id];

        $ret = $DB->get_fieldset_sql($sql, $params);

        $this->components = [];

        foreach ($ret as $r) {

            $this->components[$r] = self::get_component_translation($r);

        }

        asort($this->components, SORT_STRING | SORT_FLAG_CASE);

        $componentsall = [

            'all' => \get_string('all_files', 'local_listcoursefiles'),

            'all_wo_submissions' => \get_string('all_wo_submissions', 'local_listcoursefiles'),

        ];

        $this->components = $componentsall + $this->components;

        return $this->components;

    }

    /**

     * Change the license of multiple files.

     *

     * @param array $fileids keys are the file IDs

     * @param string $license shortname of the license

     * @throws \moodle_exception

     */

    public function set_files_license($fileids, $license) {

        global $DB;

        $licenses = licences::get_available_licenses();

        if (!isset($licenses[$license])) {

            throw new \moodle_exception('invalid_license', 'local_listcoursefiles');

        }

        if (count($fileids) > self::MAX_FILES) {

            throw new \moodle_exception('too_many_files', 'local_listcoursefiles');

        }

        if (count($fileids) == 0) {

            return;

        }

        // Check if the given files really belong to the context.

        list($sqlin, $paramfids) = $DB->get_in_or_equal(array_keys($fileids), SQL_PARAMS_QM);

        $sql = "SELECT f.id, f.contextid, c.path

                  FROM {files} f

                  JOIN {context} c ON (c.id = f.contextid)

                 WHERE f.id $sqlin";

        $res = $DB->get_records_sql($sql, $paramfids);

        $checkedfileids = array_column($this->check_files_context($res), 'id');

        if (count($checkedfileids) == 0) {

            return;

        }

        list($sqlin, $paramfids) = $DB->get_in_or_equal($checkedfileids, SQL_PARAMS_QM);

        $transaction = $DB->start_delegated_transaction();

        $sql = "UPDATE {files} SET license = ? WHERE id $sqlin";

        $DB->execute($sql, array_merge([$license], $paramfids));

        foreach ($checkedfileids as $fid) {

            $event = event\license_changed::create([

                'context' => $this->context,

                'objectid' => $fid,

                'other' => ['license' => $license],

            ]);

            $event->trigger();

        }

        $transaction->allow_commit();

    }

    /**

     * Check given files whether they belong to the context.

     *

     * The file objects need to have the contextid and the context path.

     *

     * @param array $files array of stdClass as retrieved from the files and context table

     * @return array file ids that belong to the context

     */

    protected function check_files_context(&$files) {

        $thiscontextpath = $this->context->path . '/';

        $thiscontextpathlen = strlen($thiscontextpath);

        $thiscontextid = $this->context->id;

        $checkedfiles = [];

        foreach ($files as &$f) {

            if ($f->contextid == $thiscontextid || substr($f->path, 0, $thiscontextpathlen) === $thiscontextpath) {

                $checkedfiles[] = $f;

            }

        }

        return $checkedfiles;

    }

    /**

     * Download a zip file of the files with the given ids.

     *

     * This function does not return if the zip archive could be created.

     *

     * @param array $fileids file ids

     * @throws \moodle_exception

     */

    public function download_files(&$fileids) {

        global $DB, $CFG;

        if (count($fileids) > self::MAX_FILES) {

            throw new \moodle_exception('too_many_files', 'local_listcoursefiles');

        }

        if (count($fileids) == 0) {

            throw new \moodle_exception('no_file_selected', 'local_listcoursefiles');

        }

        list($sqlin, $paramfids) = $DB->get_in_or_equal(array_keys($fileids), SQL_PARAMS_QM);

        $sql = "SELECT f.*, c.path, r.repositoryid, r.reference, r.lastsync AS referencelastsync

                  FROM {files} f

             LEFT JOIN {context} c ON (c.id = f.contextid)

             LEFT JOIN {files_reference} r ON (f.referencefileid = r.id)

                 WHERE f.id $sqlin";

        $res = $DB->get_records_sql($sql, $paramfids);

        $checkedfiles = $this->check_files_context($res);

        $fs = get_file_storage();

        $filesforzipping = [];

        foreach ($checkedfiles as $file) {

            $fname = $this->download_get_unique_file_name($file->filename, $filesforzipping);

            $filesforzipping[$fname] = $fs->get_file_instance($file);

        }

        $filename = clean_filename($this->coursemodinfo->get_course()->fullname . '.zip');

        $tmpfile = tempnam($CFG->tempdir . '/', 'local_listcoursefiles');

        $zip = new \zip_packer();

        if ($zip->archive_to_pathname($filesforzipping, $tmpfile)) {

            send_temp_file($tmpfile, $filename);

        }

    }

    /**

     * Generate a unique file name for storage.

     *

     * If a file does already exist with $filename in $existingfiles as key,

     * a number in parentheses is appended to the file name.

     *

     * @param string $filename

     * @param array $existingfiles

     * @return string unique file name

     */

    protected function download_get_unique_file_name($filename, &$existingfiles) {

        $name = clean_filename($filename);

        $lastdot = strrpos($name, '.');

        if ($lastdot === false) {

            $filename = $name;

            $extension = '';

        } else {

            $filename = substr($name, 0, $lastdot);

            $extension = substr($name, $lastdot);

        }

        $i = 1;

        while (isset($existingfiles[$name])) {

            $name = $filename . '(' . $i++ . ')' . $extension;

        }

        return $name;

    }

    /**

     * Collate an array of available file types

     *

     * @return array

     * @throws \coding_exception

     */

    public static function get_file_types() {

        $types = ['all' => \get_string('filetype_all', 'local_listcoursefiles')];

        foreach (array_keys(mimetypes::get_mime_types()) as $type) {

            $types[$type] = \get_string('filetype_' . $type, 'local_listcoursefiles');

        }

        $types['other'] = \get_string('filetype_other', 'local_listcoursefiles');

        return $types;

    }

    /**

     * Try to get the name of the file component in the user's lang.

     *

     * @param string $name

     * @return \lang_string|string

     * @throws \coding_exception

     */

    public static function get_component_translation($name) {

        if (get_string_manager()->string_exists('pluginname', $name)) {

            return get_string('pluginname', $name);

        } else if (get_string_manager()->string_exists($name, '')) {

            return get_string($name, '');

        }

        return $name;

    }

}