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

namespace mod_data;

use core_component;

use invalid_parameter_exception;

use data_field_base;

use moodle_exception;

use SimpleXMLElement;

use stdClass;

use stored_file;

/**

 * Class preset for database activity.

 *

 * @package    mod_data

 * @copyright  2022 Sara Arjona <sara@moodle.com>

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

 */

class preset {

    /** @var manager manager instance. */

    private $manager;

    /** @var bool whether the preset is a plugin or has been saved by the user. */

    public $isplugin;

    /** @var string The preset name. */

    public $name;

    /** @var string The preset shortname. For datapreset plugins that is the folder; for saved presets, that's the preset name. */

    public $shortname;

    /** @var string The preset description. */

    public $description;

    /** @var stored_file For saved presets that's the file object for the root folder. It's null for plugins or for presets that

     *  haven't been saved yet. */

    public $storedfile;

    /** @var array|null the field sample instances. */

    private $fields = null;

    /** @var stdClass|null the preset.xml parsed information. */

    protected $xmlinfo = null;

    /**

     * Class constructor.

     *

     * @param manager|null $manager the current instance manager

     * @param bool $isplugin whether the preset is a plugin or has been saved by the user

     * @param string $name the preset name

     * @param string $shortname the preset shortname

     * @param string|null $description the preset description

     * @param stored_file|null $storedfile for saved presets, that's the file for the root folder

     * @throws invalid_parameter_exception

     */

    protected function __construct(

        ?manager $manager,

        bool $isplugin,

        string $name,

        string $shortname,

        ?string $description = '',

        ?stored_file $storedfile = null

    ) {

        if (!$isplugin && is_null($manager)) {

            throw new invalid_parameter_exception('The $manager parameter can only be null for plugin presets.');

        }

        $this->manager = $manager;

        $this->isplugin = $isplugin;

        $this->name = $name;

        $this->shortname = $shortname;

        $this->description = $description;

        $this->storedfile = $storedfile;

    }

    /**

     * Create a preset instance from a stored file.

     *

     * @param manager $manager the current instance manager

     * @param stored_file $file the preset root folder

     * @return preset|null If the given file doesn't belong to the expected component/filearea/context, null will be returned

     */

    public static function create_from_storedfile(manager $manager, stored_file $file): ?self {

        if ($file->get_component() != DATA_PRESET_COMPONENT

                || $file->get_filearea() != DATA_PRESET_FILEAREA

                || $file->get_contextid() != DATA_PRESET_CONTEXT) {

            return null;

        }

        $isplugin = false;

        $name = trim($file->get_filepath(), '/');

        $description = static::get_attribute_value($file->get_filepath(), 'description');

        return new self($manager, $isplugin, $name, $name, $description, $file);

    }

    /**

     * Create a preset instance from a plugin.

     *

     * @param manager|null $manager the current instance manager

     * @param string $pluginname the datapreset plugin name

     * @return preset|null The plugin preset or null if there is no datapreset plugin with the given name.

     */

    public static function create_from_plugin(?manager $manager, string $pluginname): ?self {

        $found = false;

        $plugins = array_keys(core_component::get_plugin_list('datapreset'));

        foreach ($plugins as $plugin) {

            if ($plugin == $pluginname) {

                $found = true;

                break;

            }

        }

        if (!$found) {

            // If there is no datapreset plugin with this name, return null.

            return null;

        }

        $name = static::get_name_from_plugin($pluginname);

        $description = static::get_description_from_plugin($pluginname);

        return new self($manager, true, $name, $pluginname, $description);

    }

    /**

     * Create a preset instance from a data_record entry, a preset name and a description.

     *

     * @param manager $manager the current instance manager

     * @param string $presetname the preset name

     * @param string|null $description the preset description

     * @return preset

     */

    public static function create_from_instance(manager $manager, string $presetname, ?string $description = ''): self {

        $isplugin = false;

        $path = '/' . $presetname . '/';

        $file = static::get_file($path, '.');

        if (!is_null($file)) {

            // If the file is not empty, create the instance based on the storedfile.

            return self::create_from_storedfile($manager, $file);

        }

        return new self($manager, $isplugin, $presetname, $presetname, $description, $file);

    }

    /**

     * Create a preset instance from the preset fullname.

     *

     * The preset fullname is a concatenation of userid and pluginname|presetname used by most

     * preset pages. Plugins uses userid zero while preset instances has the owner as identifier.

     *

     * This method will throw an exception if the preset instance has a different userid thant the one

     * from the $fullname. However, it won't check the current user capabilities.

     *

     * @param manager $manager the current instance manager

     * @param string $fullname the preset full name

     * @return preset

     */

    public static function create_from_fullname(manager $manager, string $fullname): self {

        $parts = explode('/', $fullname, 2);

        $userid = empty($parts[0]) ? 0 : (int)$parts[0];

        $shortname = empty($parts[1]) ? '' : $parts[1];

        // Shortnames with userid zero are plugins.

        if ($userid == 0) {

            return static::create_from_plugin($manager, $shortname);

        }

        $path = '/' . $shortname . '/';

        $file = static::get_file($path, '.');

        $result = static::create_from_storedfile($manager, $file);

        if ($result->get_userid() != $userid) {

            throw new moodle_exception('invalidpreset', manager::PLUGINNAME);

        }

        return $result;

    }

    /**

     * Save this preset.

     *

     * @return bool true if the preset has been saved; false otherwise.

     */

    public function save(): bool {

        global $USER;

        if ($this->isplugin) {

            // Plugin presets can't be saved.

            return false;

        }

        if (!is_null($this->storedfile)) {

            // It's a pre-existing preset, so it needs to be updated.

            return $this->update_user_preset();

        }

        // The preset hasn't been saved before.

        $fs = get_file_storage();

        // Create and save the preset.xml file, with the description, settings, fields...

        $filerecord = static::get_filerecord('preset.xml', $this->get_path(), $USER->id);

        $fs->create_file_from_string($filerecord, $this->generate_preset_xml());

        // Create and save the template files.

        $instance = $this->manager->get_instance();

        foreach (manager::TEMPLATES_LIST as $templatename => $templatefile) {

            $filerecord->filename = $templatefile;

            $fs->create_file_from_string($filerecord, $instance->{$templatename});

        }

        // Update the storedfile with the one we've just saved.

        $this->storedfile = static::get_file($this->get_path(), '.');

        return true;

    }

    /**

     * Update the stored user preset.

     * This method is used internally by the save method.

     *

     * @return bool true if the preset has been saved; false otherwise.

     */

    private function update_user_preset(): bool {

        global $USER;

        $result = false;

        $shouldbesaved = false;

        // Update description (if required).

        $oldpresetfile = static::get_file($this->storedfile->get_filepath(), 'preset.xml');

        $presetxml = $oldpresetfile->get_content();

        $parsedxml = simplexml_load_string($presetxml);

        if (property_exists($parsedxml, 'description')) {

            if ($parsedxml->description != $this->description) {

                $parsedxml->description = $this->description;

                $shouldbesaved = true;

            }

        } else {

            if (!is_null($this->description)) {

                $parsedxml->addChild('description', $this->description);

                $shouldbesaved = true;

            }

        }

        // Update name (if required).

        $oldname = trim($this->storedfile->get_filepath(), '/');

        $newpath = '/' . $this->name . '/';

        if ($oldname != $this->name) {

            // Preset name has changed, so files need to be updated too because the preset name is saved in the filepath.

            foreach (manager::TEMPLATES_LIST as $templatename => $templatefile) {

                $oldfile = static::get_file($this->storedfile->get_filepath(), $templatefile);

                $oldfile->rename($newpath, $templatefile);

            }

            // The root folder should also be renamed.

            $this->storedfile->rename($newpath, $this->storedfile->get_filename());

            $shouldbesaved = true;

        }

        // Only save the new preset.xml if there are changes.

        if ($shouldbesaved) {

            // Before saving preset.xml, the old preset.xml file should be removed.

            $oldpresetfile->delete();

            // Create the new file with the new content.

            $filerecord = static::get_filerecord('preset.xml', $newpath, $USER->id);

            $presetcontent = $parsedxml->asXML();

            $fs = get_file_storage();

            $fs->create_file_from_string($filerecord, $presetcontent);

            $result = true;

        }

        return $result;

    }

    /**

     * Export this preset.

     *

     * @return string the full path to the exported preset file.

     */

    public function export(): string {

        if ($this->isplugin) {

            // For now, only saved presets can be exported.

            return '';

        }

        $presetname = clean_filename($this->name) . '-preset-' . gmdate("Ymd_Hi");

        $exportsubdir = "mod_data/presetexport/$presetname";

        $exportdir = make_temp_directory($exportsubdir);

        // Generate and write the preset.xml file.

        $presetxmldata = static::generate_preset_xml();

        $presetxmlfile = fopen($exportdir . '/preset.xml', 'w');

        fwrite($presetxmlfile, $presetxmldata);

        fclose($presetxmlfile);

        // Write the template files.

        $instance = $this->manager->get_instance();

        foreach (manager::TEMPLATES_LIST as $templatename => $templatefilename) {

            $templatefile = fopen("$exportdir/$templatefilename", 'w');

            fwrite($templatefile, $instance->{$templatename} ?? '');

            fclose($templatefile);

        }

        // Check if all files have been generated.

        if (! static::is_directory_a_preset($exportdir)) {

            throw new \moodle_exception('generateerror', 'data');

        }

        $presetfilenames = array_merge(array_values(manager::TEMPLATES_LIST), ['preset.xml']);

        $filelist = [];

        foreach ($presetfilenames as $filename) {

            $filelist[$filename] = $exportdir . '/' . $filename;

        }

        $exportfile = $exportdir.'.zip';

        file_exists($exportfile) && unlink($exportfile);

        $fp = get_file_packer('application/zip');

        $fp->archive_to_pathname($filelist, $exportfile);

        foreach ($filelist as $file) {

            unlink($file);

        }

        rmdir($exportdir);

        return $exportfile;

    }

    /**

     * Return the preset author.

     *

     * Preset plugins do not have any user id.

     *

     * @return int|null the userid or null if it is a plugin

     */

    public function get_userid(): ?int {

        if (!empty($this->storedfile)) {

            return $this->storedfile->get_userid();

        }

        return null;

    }

    /**

     * Return the preset fullname.

     *

     * Preset fullname is used mostly for urls.

     *

     * @return string the preset fullname

     */

    public function get_fullname(): string {

        $userid = $this->get_userid() ?? '0';

        return "{$userid}/{$this->shortname}";

    }

    /**

     * Returns the preset path.

     *

     * @return string|null the preset path is null for plugins and /presetname/ for saved presets.

     */

    public function get_path(): ?string {

        if ($this->isplugin) {

            return null;

        }

        if (!empty($this->storedfile)) {

            return $this->storedfile->get_filepath();

        }

        return '/' . $this->name . '/';

    }

    /**

     * Return the field instances of the preset.

     *

     * @param bool $forpreview if the fields are only for preview

     * @return data_field_base[]  and array with field objects

     */

    public function get_fields(bool $forpreview = false): array {

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

            return $this->fields;

        }

        // Parse the preset.xml file.

        $this->load_preset_xml();

        if (empty($this->xmlinfo) || empty($this->xmlinfo->field)) {

            $this->fields = [];

            return $this->fields;

        }

        // Generate field instances.

        $result = [];

        foreach ($this->xmlinfo->field as $fieldinfo) {

            $result[(string) $fieldinfo->name] = $this->get_field_instance($fieldinfo, count($result), $forpreview);

        }

        $this->fields = $result;

        return $result;

    }

    /**

     * Convert a preset.xml field data into field instance.

     *

     * @param SimpleXMLElement $fieldinfo the field xml information

     * @param int $id the field id to use

     * @param bool $forpreview if the field should support preview

     * @return data_field_base the field instance

     */

    private function get_field_instance(

        SimpleXMLElement $fieldinfo,

        int $id = 0,

        bool $forpreview = false

    ): data_field_base {

        global $CFG; // Some old field plugins require $CFG to be in the  scope.

        $fieldrecord = $this->get_fake_field_record($fieldinfo, $id);

        $instance = $this->manager->get_instance();

        $cm = $this->manager->get_coursemodule();

        // Include the plugin.

        $filepath = "{$this->manager->path}/field/{$fieldrecord->type}/field.class.php";

        if (file_exists($filepath)) {

            require_once($filepath);

        }

        $classname = "data_field_{$fieldrecord->type}";

        $newfield = null;

        if (class_exists($classname)) {

            $newfield = new $classname($fieldrecord, $instance, $cm);

            if ($forpreview && !$newfield->supports_preview()) {

                $newfield = new data_field_base($fieldrecord, $instance, $cm);

            }

        } else {

            $newfield = new data_field_base($fieldrecord, $instance, $cm);

        }

        if ($forpreview) {

            $newfield->set_preview(true);

        }

        return $newfield;

    }

    /**

     * Generate a fake field record fomr the preset.xml field data.

     *

     * @param SimpleXMLElement $fieldinfo the field xml information

     * @param int $id the field id to use

     * @return stdClass the fake record

     */

    private function get_fake_field_record(SimpleXMLElement $fieldinfo, int $id = 0): stdClass {

        $instance = $this->manager->get_instance();

        // Generate stub record.

        $fieldrecord = (object)[

            'id' => $id,

            'dataid' => $instance->id,

            'type' => (string) $fieldinfo->type,

            'name' => (string) $fieldinfo->name,

            'description' => (string) $fieldinfo->description ?? '',

            'required' => (int) $fieldinfo->required ?? 0,

        ];

        for ($i = 1; $i < 11; $i++) {

            $name = "param{$i}";

            $fieldrecord->{$name} = null;

            if (property_exists($fieldinfo, $name)) {

                $fieldrecord->{$name} = (string) $fieldinfo->{$name};

            }

        }

        return $fieldrecord;

    }

    /**

     * Return sample entries to preview this preset.

     *

     * @param int $count the number of entries to generate.

     * @return array of sample entries

     */

    public function get_sample_entries(int $count = 1): array {

        global $USER;

        $fields = $this->get_fields();

        $instance = $this->manager->get_instance();

        $entries = [];

        for ($current = 1; $current <= $count; $current++) {

            $entry = (object)[

                'id' => $current,

                'userid' => $USER->id,

                'groupid' => 0,

                'dataid' => $instance->id,

                'timecreated' => time(),

                'timemodified' => time(),

                'approved' => 1,

            ];

            // Add all necessary user fields.

            $userfieldsapi = \core_user\fields::for_userpic()->excluding('id');

            $fields = $userfieldsapi->get_required_fields();

            foreach ($fields as $field) {

                $entry->{$field} = $USER->{$field};

            }

            $entries[$current] = $entry;

        }

        return $entries;

    }

    /**

     * Load all the information from the preset.xml.

     */

    protected function load_preset_xml() {

        if (!empty($this->xmlinfo)) {

            return;

        }

        // Load everything from the XML.

        $presetxml = null;

        if ($this->isplugin) {

            $path = $this->manager->path . '/preset/' . $this->shortname . '/preset.xml';

            $presetxml = file_get_contents($path);

        } else {

            $presetxml = static::get_content_from_file($this->storedfile->get_filepath(), 'preset.xml');

        }

        $this->xmlinfo = simplexml_load_string($presetxml);

    }

    /**

     * Return the template content from the preset.

     *

     * @param string $templatename the template name

     * @return string the template content

     */

    public function get_template_content(string $templatename): string {

        $filename = "{$templatename}.html";

        if ($templatename == 'csstemplate') {

            $filename = "{$templatename}.css";

        }

        if ($templatename == 'jstemplate') {

            $filename = "{$templatename}.js";

        }

        if ($this->isplugin) {

            $path = $this->manager->path . '/preset/' . $this->shortname . '/' . $filename;

            $result = file_get_contents($path);

        } else {

            $result = static::get_content_from_file($this->storedfile->get_filepath(), $filename);

        }

        if (empty($result)) {

            return '';

        }

        return $result;

    }

    /**

     * Checks if a directory contains all the required files to define a preset.

     *

     * @param string $directory The patch to check if it contains the preset files or not.

     * @return bool True if the directory contains all the preset files; false otherwise.

     */

    public static function is_directory_a_preset(string $directory): bool {

        $status = true;

        $directory = rtrim($directory, '/\\') . '/';

        $presetfilenames = array_merge(array_values(manager::TEMPLATES_LIST), ['preset.xml']);

        foreach ($presetfilenames as $filename) {

            $status &= file_exists($directory.$filename);

        }

        return $status;

    }

    /**

     * Returns the best name to show for a datapreset plugin.

     *

     * @param string $pluginname The datapreset plugin name.

     * @return string The plugin preset name to display.

     */

    public static function get_name_from_plugin(string $pluginname): string {

        $pos = strpos($pluginname, '/');

        if ($pos !== false) {

             $pluginname = substr($pluginname, $pos + 1);

        }

        if (!strpos(trim($pluginname), ' ') && get_string_manager()->string_exists('modulename', 'datapreset_'.$pluginname)) {

            return get_string('modulename', 'datapreset_'.$pluginname);

        } else {

            return $pluginname;

        }

    }

    /**

     * Returns the description to show for a datapreset plugin.

     *

     * @param string $pluginname The datapreset plugin name.

     * @return string The plugin preset description to display.

     */

    public static function get_description_from_plugin(string $pluginname): string {

        if (get_string_manager()->string_exists('modulename_help', 'datapreset_'.$pluginname)) {

            return get_string('modulename_help', 'datapreset_'.$pluginname);

        } else {

            return '';

        }

    }

    /**

     * Helper to get the value of one of the elements in the presets.xml file.

     *

     * @param string $filepath The preset filepath.

     * @param string $name Attribute name to return.

     * @return string|null The attribute value; null if the it doesn't exist or the file is not a valid XML.

     */

    protected static function get_attribute_value(string $filepath, string $name): ?string {

        $value = null;

        $presetxml = static::get_content_from_file($filepath, 'preset.xml');

        $parsedxml = simplexml_load_string($presetxml);

        if ($parsedxml) {

            switch ($name) {

                case 'description':

                    if (property_exists($parsedxml, 'description')) {

                        $value = $parsedxml->description;

                    }

                    break;

            }

        }

        return $value;

    }

    /**

     * Helper method to get a file record given a filename, a filepath and a userid, for any of the preset files.

     *

     * @param string $filename The filename for the filerecord that will be returned.

     * @param string $filepath The filepath for the filerecord that will be returned.

     * @param int $userid The userid for the filerecord that will be returned.

     * @return stdClass A filerecord object with the datapreset context, component and filearea and the given information.

     */

    protected static function get_filerecord(string $filename, string $filepath, int $userid): stdClass {

        $filerecord = new stdClass;

        $filerecord->contextid = DATA_PRESET_CONTEXT;

        $filerecord->component = DATA_PRESET_COMPONENT;

        $filerecord->filearea = DATA_PRESET_FILEAREA;

        $filerecord->itemid = 0;

        $filerecord->filepath = $filepath;

        $filerecord->userid = $userid;

        $filerecord->filename = $filename;

        return $filerecord;

    }

    /**

     * Helper method to retrieve a file.

     *

     * @param string $filepath the directory to look in

     * @param string $filename the name of the file we want

     * @return stored_file|null the file or null if the file doesn't exist.

     */

    public static function get_file(string $filepath, string $filename): ?stored_file {

        $file = null;

        $fs = get_file_storage();

        $fileexists = $fs->file_exists(

            DATA_PRESET_CONTEXT,

            DATA_PRESET_COMPONENT,

            DATA_PRESET_FILEAREA,

            0,

            $filepath,

            $filename

        );

        if ($fileexists) {

            $file = $fs->get_file(

                DATA_PRESET_CONTEXT,

                DATA_PRESET_COMPONENT,

                DATA_PRESET_FILEAREA,

                0,

                $filepath,

                $filename

            );

        }

        return $file;

    }

    /**

     * Helper method to retrieve the contents of a file.

     *

     * @param string $filepath the directory to look in

     * @param string $filename the name of the file we want

     * @return string|null the contents of the file or null if the file doesn't exist.

     */

    protected static function get_content_from_file(string $filepath, string $filename): ?string {

        $templatefile = static::get_file($filepath, $filename);

        if ($templatefile) {

            return $templatefile->get_content();

        }

        return null;

    }

    /**

     * Helper method to generate the XML for this preset.

     *

     * @return string The XML for the preset

     */

    protected function generate_preset_xml(): string {

        global $DB;

        if ($this->isplugin) {

            // Only saved presets can generate the preset.xml file.

            return '';

        }

        $presetxmldata = "<preset>\n\n";

        // Add description.

        $presetxmldata .= '<description>' . htmlspecialchars($this->description ?? '', ENT_COMPAT) . "</description>\n\n";

        // Add settings.

        // Raw settings are not preprocessed during saving of presets.

        $rawsettings = [

            'intro',

            'comments',

            'requiredentries',

            'requiredentriestoview',

            'maxentries',

            'rssarticles',

            'approval',

            'manageapproved',

            'defaultsortdir',

        ];

        $presetxmldata .= "<settings>\n";

        $instance = $this->manager->get_instance();

        // First, settings that do not require any conversion.

        foreach ($rawsettings as $setting) {

            $presetxmldata .= "<$setting>" . htmlspecialchars($instance->$setting, ENT_COMPAT) . "</$setting>\n";

        }

        // Now specific settings.

        if ($instance->defaultsort > 0 && $sortfield = data_get_field_from_id($instance->defaultsort, $instance)) {

            $presetxmldata .= '<defaultsort>' . htmlspecialchars($sortfield->field->name, ENT_COMPAT) . "</defaultsort>\n";

        } else {

            $presetxmldata .= "<defaultsort>0</defaultsort>\n";

        }

        $presetxmldata .= "</settings>\n\n";

        // Add fields. Grab all that are non-empty.

        $fields = $DB->get_records('data_fields', ['dataid' => $instance->id]);

        ksort($fields);

        if (!empty($fields)) {

            foreach ($fields as $field) {

                $presetxmldata .= "<field>\n";

                foreach ($field as $key => $value) {

                    if ($value != '' && $key != 'id' && $key != 'dataid') {

                        $presetxmldata .= "<$key>" . htmlspecialchars($value, ENT_COMPAT) . "</$key>\n";

                    }

                }

                $presetxmldata .= "</field>\n\n";

            }

        }

        $presetxmldata .= '</preset>';

        // Check this content is a valid XML.

        $preset = new SimpleXMLElement($presetxmldata);

        return $preset->asXML();

    }

    /**

     * Checks to see if the user has permission to manage the preset.

     *

     * @return bool  Returns true if the user can manage this preset, false otherwise.

     */

    public function can_manage(): bool {

        global $USER;

        if ($this->isplugin) {

            // Plugin presets can't be removed or edited.

            return false;

        }

        $context = $this->manager->get_context();

        if (has_capability('mod/data:manageuserpresets', $context)) {

            return true;

        } else {

            if ($this->get_userid() == $USER->id) {

                return true;

            }

        }

        return false;

    }

    /**

     * Deletes all files related to a saved preset.

     *

     * @return bool True if the preset is a saved preset and the file exists in the file system; false otherwise.

     */

    public function delete(): bool {

        if ($this->isplugin) {

            // Plugin presets can't be removed.

            return false;

        }

        $exists = false;

        $filepath = $this->get_path();

        $dir = self::get_file($filepath, '.');

        if (!empty($dir)) {

            $exists = true;

            $fs = get_file_storage();

            $files = $fs->get_directory_files(

                $dir->get_contextid(),

                $dir->get_component(),

                $dir->get_filearea(),

                $dir->get_itemid(),

                $filepath

            );

            if (!empty($files)) {

                foreach ($files as $file) {

                    $file->delete();

                }

            }

            $dir->delete();

            // Reseting storedfile property because the file has been removed.

            $this->storedfile = null;

        }

        return $exists;

    }

}