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 core_adminpresets;

use memory_xml_output;

use moodle_exception;

use stdClass;

use xml_writer;

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

global $CFG;

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

/**

 * Admin tool presets manager class.

 *

 * @package          core_adminpresets

 * @copyright        2021 Pimenko <support@pimenko.com><pimenko.com>

 * @author           Jordan Kesraoui | Sylvain Revenu | Pimenko based on David Monllaó <david.monllao@urv.cat> code

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

 */

class manager {

    /** @var \admin_root The admin root tree with the settings. **/

    private $adminroot;

    /** @var array Setting classes mapping, to associated the local/setting class that should be used when there is

     * no specific class. */

    protected static $settingclassesmap = [

            'adminpresets_admin_setting_agedigitalconsentmap' => 'adminpresets_admin_setting_configtext',

            'adminpresets_admin_setting_configcolourpicker' => 'adminpresets_admin_setting_configtext',

            'adminpresets_admin_setting_configdirectory' => 'adminpresets_admin_setting_configtext',

            'adminpresets_admin_setting_configduration_with_advanced' => 'adminpresets_admin_setting_configtext_with_advanced',

            'adminpresets_admin_setting_configduration' => 'adminpresets_admin_setting_configtext',

            'adminpresets_admin_setting_configempty' => 'adminpresets_admin_setting_configtext',

            'adminpresets_admin_setting_configexecutable' => 'adminpresets_admin_setting_configtext',

            'adminpresets_admin_setting_configfile' => 'adminpresets_admin_setting_configtext',

            'adminpresets_admin_setting_confightmleditor' => 'adminpresets_admin_setting_configtext',

            'adminpresets_admin_setting_configmixedhostiplist' => 'adminpresets_admin_setting_configtext',

            'adminpresets_admin_setting_configmultiselect_modules' => 'adminpresets_admin_setting_configmultiselect_with_loader',

            'adminpresets_admin_setting_configpasswordunmask' => 'adminpresets_admin_setting_configtext',

            'adminpresets_admin_setting_configportlist' => 'adminpresets_admin_setting_configtext',

            'adminpresets_admin_setting_configselect_with_lock' => 'adminpresets_admin_setting_configselect',

            'adminpresets_admin_setting_configtext_trim_lower' => 'adminpresets_admin_setting_configtext',

            'adminpresets_admin_setting_configtext_with_maxlength' => 'adminpresets_admin_setting_configtext',

            'adminpresets_admin_setting_configtextarea' => 'adminpresets_admin_setting_configtext',

            'adminpresets_admin_setting_configthemepreset' => 'adminpresets_admin_setting_configselect',

            'adminpresets_admin_setting_countrycodes' => 'adminpresets_admin_setting_configtext',

            'adminpresets_admin_setting_courselist_frontpage' => 'adminpresets_admin_setting_configmultiselect_with_loader',

            'adminpresets_admin_setting_description' => 'adminpresets_admin_setting_configtext',

            'adminpresets_admin_setting_enablemobileservice' => 'adminpresets_admin_setting_configcheckbox',

            'adminpresets_admin_setting_filetypes' => 'adminpresets_admin_setting_configtext',

            'adminpresets_admin_setting_forcetimezone' => 'adminpresets_admin_setting_configselect',

            'adminpresets_admin_setting_grade_profilereport' => 'adminpresets_admin_setting_configmultiselect_with_loader',

            'adminpresets_admin_setting_langlist' => 'adminpresets_admin_setting_configtext',

            'adminpresets_admin_setting_my_grades_report' => 'adminpresets_admin_setting_configselect',

            'adminpresets_admin_setting_pickroles' => 'adminpresets_admin_setting_configmulticheckbox',

            'adminpresets_admin_setting_question_behaviour' => 'adminpresets_admin_setting_configmultiselect_with_loader',

            'adminpresets_admin_setting_regradingcheckbox' => 'adminpresets_admin_setting_configcheckbox',

            'adminpresets_admin_setting_scsscode' => 'adminpresets_admin_setting_configtext',

            'adminpresets_admin_setting_servertimezone' => 'adminpresets_admin_setting_configselect',

            'adminpresets_admin_setting_sitesetcheckbox' => 'adminpresets_admin_setting_configcheckbox',

            'adminpresets_admin_setting_sitesetselect' => 'adminpresets_admin_setting_configselect',

            'adminpresets_admin_setting_special_adminseesall' => 'adminpresets_admin_setting_configcheckbox',

            'adminpresets_admin_setting_special_backup_auto_destination' => 'adminpresets_admin_setting_configtext',

            'adminpresets_admin_setting_special_coursecontact' => 'adminpresets_admin_setting_configmulticheckbox',

            'adminpresets_admin_setting_special_coursemanager' => 'adminpresets_admin_setting_configmulticheckbox',

            'adminpresets_admin_setting_special_debug' => 'adminpresets_admin_setting_configmultiselect_with_loader',

            'adminpresets_admin_setting_special_frontpagedesc' => 'adminpresets_admin_setting_sitesettext',

            'adminpresets_admin_setting_special_gradebookroles' => 'adminpresets_admin_setting_configmulticheckbox',

            'adminpresets_admin_setting_special_gradeexport' => 'adminpresets_admin_setting_configmulticheckbox',

            'adminpresets_admin_setting_special_gradelimiting' => 'adminpresets_admin_setting_configcheckbox',

            'adminpresets_admin_setting_special_grademinmaxtouse' => 'adminpresets_admin_setting_configselect',

            'adminpresets_admin_setting_special_gradepointdefault' => 'adminpresets_admin_setting_configtext',

            'adminpresets_admin_setting_special_gradepointmax' => 'adminpresets_admin_setting_configtext',

            'adminpresets_admin_setting_special_registerauth' => 'adminpresets_admin_setting_configmultiselect_with_loader',

            'adminpresets_admin_setting_special_selectsetup' => 'adminpresets_admin_setting_configselect',

            'adminpresets_admin_settings_country_select' => 'adminpresets_admin_setting_configmultiselect_with_loader',

            'adminpresets_admin_settings_coursecat_select' => 'adminpresets_admin_setting_configmultiselect_with_loader',

            'adminpresets_admin_settings_h5plib_handler_select' => 'adminpresets_admin_setting_configselect',

            'adminpresets_admin_settings_num_course_sections' => 'adminpresets_admin_setting_configmultiselect_with_loader',

            'adminpresets_admin_settings_sitepolicy_handler_select' => 'adminpresets_admin_setting_configselect',

            'adminpresets_antivirus_clamav_pathtounixsocket_setting' => 'adminpresets_admin_setting_configtext',

            'adminpresets_antivirus_clamav_runningmethod_setting' => 'adminpresets_admin_setting_configselect',

            'adminpresets_antivirus_clamav_tcpsockethost_setting' => 'adminpresets_admin_setting_configtext',

            'adminpresets_auth_db_admin_setting_special_auth_configtext' => 'adminpresets_admin_setting_configtext',

            'adminpresets_auth_ldap_admin_setting_special_lowercase_configtext' => 'adminpresets_admin_setting_configtext',

            'adminpresets_auth_ldap_admin_setting_special_ntlm_configtext' => 'adminpresets_admin_setting_configtext',

            'adminpresets_auth_shibboleth_admin_setting_convert_data' => 'adminpresets_admin_setting_configtext',

            'adminpresets_auth_shibboleth_admin_setting_special_idp_configtextarea' => 'adminpresets_admin_setting_configtext',

            'adminpresets_auth_shibboleth_admin_setting_special_wayf_select' => 'adminpresets_admin_setting_configselect',

            'adminpresets_editor_atto_toolbar_setting' => 'adminpresets_admin_setting_configtext',

            'adminpresets_enrol_database_admin_setting_category' => 'adminpresets_admin_setting_configselect',

            'adminpresets_enrol_flatfile_role_setting' => 'adminpresets_admin_setting_configtext',

            'adminpresets_enrol_ldap_admin_setting_category' => 'adminpresets_admin_setting_configselect',

            'adminpresets_format_singleactivity_admin_setting_activitytype' => 'adminpresets_admin_setting_configselect',

            'adminpresets_qtype_multichoice_admin_setting_answernumbering' => 'adminpresets_admin_setting_configselect',

    ];

    /** @var array Relation between database fields and XML files. **/

    protected static $dbxmlrelations = [

        'name' => 'NAME',

        'comments' => 'COMMENTS',

        'timecreated' => 'PRESET_DATE',

        'site' => 'SITE_URL',

        'author' => 'AUTHOR',

        'moodleversion' => 'MOODLE_VERSION',

        'moodlerelease' => 'MOODLE_RELEASE'

    ];

    /** @var int Non-core preset */

    public const NONCORE_PRESET = 0;

    /** @var int Starter preset */

    public const STARTER_PRESET = 1;

    /** @var int Full preset */

    public const FULL_PRESET = 2;

    /**

     * Gets the system settings

     *

     * Loads the DB $CFG->prefix.'config' values and the

     * $CFG->prefix.'config_plugins' values and redirects

     * the flow through $this->get_settings()

     *

     * @return array $settings Array format $array['plugin']['settingname'] = settings_types child class

     */

    public function get_site_settings(): array {

        global $DB;

        // Db configs (to avoid multiple queries).

        $dbconfig = $DB->get_records_select('config', '', [], '', 'name, value');

        // Adding site settings in course table.

        $frontpagevalues = $DB->get_record_select('course', 'id = 1',

                [], 'fullname, shortname, summary');

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

            $dbconfig[$field] = new stdClass();

            $dbconfig[$field]->name = $field;

            $dbconfig[$field]->value = $value;

        }

        $sitedbsettings['none'] = $dbconfig;

        // Config plugins.

        $configplugins = $DB->get_records('config_plugins');

        foreach ($configplugins as $configplugin) {

            $sitedbsettings[$configplugin->plugin][$configplugin->name] = new stdClass();

            $sitedbsettings[$configplugin->plugin][$configplugin->name]->name = $configplugin->name;

            $sitedbsettings[$configplugin->plugin][$configplugin->name]->value = $configplugin->value;

        }

        // Get an array with the common format.

        return $this->get_settings($sitedbsettings, true, []);

    }

    /**

     * Constructs an array with all the system settings

     *

     * If a setting value can't be found on the DB it considers

     * the default value as the setting value

     *

     * Settings without plugin are marked as 'none' in the plugin field

     *

     * Returns an standarized settings array format.

     *

     * @param array $dbsettings Standarized array,

     * format $array['plugin']['name'] = obj('name'=>'settingname', 'value'=>'settingvalue')

     * @param boolean $sitedbvalues Indicates if $dbsettings comes from the site db or not

     * @param array $settings Array format $array['plugin']['settingname'] = settings_types child class

     * @param array|false $children Array of admin_category children or false

     * @return \core_adminpresets\local\setting\adminpresets_setting[][] Array format

     *    $array['plugin']['settingname'] = adminpresets_setting child class

     */

    public function get_settings(array $dbsettings, bool $sitedbvalues = false, array $settings = [], $children = false): array {

        global $DB;

        // If there are no children, load admin tree and iterate through.

        if (!$children) {

            $this->adminroot = admin_get_root(false, true);

            $children = $this->adminroot->children;

        }

        // Iteates through children.

        foreach ($children as $key => $child) {

            // We must search category children.

            if (is_a($child, 'admin_category')) {

                if ($child->children) {

                    $settings = $this->get_settings($dbsettings, $sitedbvalues, $settings, $child->children);

                }

                // Settings page.

            } else if (is_a($child, 'admin_settingpage')) {

                if (property_exists($child, 'settings')) {

                    foreach ($child->settings as $values) {

                        $settingname = $values->name;

                        unset($settingvalue);

                        // Look for his config value.

                        if ($values->plugin == '') {

                            $values->plugin = 'none';

                        }

                        if (!empty($dbsettings[$values->plugin][$settingname])) {

                            $settingvalue = $dbsettings[$values->plugin][$settingname]->value;

                        }

                        // If no db value found default value.

                        if ($sitedbvalues && !isset($settingvalue)) {

                            // For settings with multiple values.

                            if (is_array($values->defaultsetting)) {

                                if (isset($values->defaultsetting['value'])) {

                                    $settingvalue = $values->defaultsetting['value'];

                                    // Configtime case, does not have a 'value' default setting.

                                } else {

                                    $settingvalue = 0;

                                }

                            } else {

                                $settingvalue = $values->defaultsetting;

                            }

                        }

                        // If there aren't any value loaded, skip that setting.

                        if (!isset($settingvalue)) {

                            continue;

                        }

                        // If there is no setting class defined continue.

                        if (!$setting = $this->get_setting($values, $settingvalue)) {

                            continue;

                        }

                        // Settings_types childs with.

                        // attributes provides an attributes array.

                        if ($attributes = $setting->get_attributes()) {

                            // Look for settings attributes if it is a presets.

                            if (!$sitedbvalues) {

                                $itemid = $dbsettings[$values->plugin][$settingname]->itemid;

                                $attrs = $DB->get_records('adminpresets_it_a',

                                        ['itemid' => $itemid], '', 'name, value');

                            }

                            foreach ($attributes as $defaultvarname => $varname) {

                                unset($attributevalue);

                                // Settings from site.

                                if ($sitedbvalues) {

                                    if (!empty($dbsettings[$values->plugin][$varname])) {

                                        $attributevalue = $dbsettings[$values->plugin][$varname]->value;

                                    }

                                    // Settings from a preset.

                                } else if (!$sitedbvalues && isset($attrs[$varname])) {

                                    $attributevalue = $attrs[$varname]->value;

                                }

                                // If no value found, default value,

                                // But we may not have a default value for the attribute.

                                if (!isset($attributevalue) && !empty($values->defaultsetting[$defaultvarname])) {

                                    $attributevalue = $values->defaultsetting[$defaultvarname];

                                }

                                // If there is no even a default for this setting will be empty.

                                // So we do nothing in this case.

                                if (isset($attributevalue)) {

                                    $setting->set_attribute_value($varname, $attributevalue);

                                }

                            }

                        }

                        // Adding to general settings array.

                        $settings[$values->plugin][$settingname] = $setting;

                    }

                }

            }

        }

        return $settings;

    }

    /**

     * Returns the class type object

     *

     * @param object $settingdata Setting data

     * @param mixed $currentvalue

     * @return mixed

     */

    public function get_setting($settingdata, $currentvalue) {

        $classname = null;

        // Getting the appropriate class to get the correct setting value.

        $settingtype = get_class($settingdata);

        // Check if it is a setting from a plugin.

        $namespacedata = explode('\\', $settingtype);

        if (count($namespacedata) > 1) {

            $plugindata = explode('_', $namespacedata[0]);

            $settingtype = end($namespacedata);

        } else {

            $plugindata = explode('_', $settingtype, 2);

        }

        $types = \core_component::get_plugin_types();

        if (array_key_exists($plugindata[0], $types)) {

            $plugins = \core_component::get_plugin_list($plugindata[0]);

            if (array_key_exists($plugindata[1], $plugins)) {

                // Check if there is a specific class for this plugin admin setting.

                $settingname = 'adminpresets_' . $settingtype;

                $classname = "\\$plugindata[0]_$plugindata[1]\\adminpresets\\$settingname";

                if (!class_exists($classname)) {

                    $classname = null;

                }

            }

        } else {

            $settingname = 'adminpresets_' . $settingtype;

            $classname = '\\core_adminpresets\\local\\setting\\' . $settingname;

            if (!class_exists($classname)) {

                // Check if there is some mapped class that should be used for this setting.

                $classname = self::get_settings_class($settingname);

            }

        }

        if (is_null($classname)) {

            // Return the default setting class if there is no specific class for this setting.

            $classname = '\\core_adminpresets\\local\\setting\\adminpresets_setting';

        }

        return new $classname($settingdata, $currentvalue);

    }

    /**

     * Returns the settings class mapped to the defined $classname or null if it doesn't exist any associated class.

     *

     * @param string $classname The classname to get the mapped class.

     * @return string|null

     */

    public static function get_settings_class(string $classname): ?string {

        if (array_key_exists($classname, self::$settingclassesmap)) {

            return '\\core_adminpresets\\local\\setting\\' . self::$settingclassesmap[$classname];

        }

        return null;

    }

    /**

     * Gets the standarized settings array from DB records

     *

     * @param array $dbsettings Array of objects

     * @return   array Standarized array,

     * format $array['plugin']['name'] = obj('name'=>'settingname', 'value'=>'settingvalue')

     */

    public function get_settings_from_db(array $dbsettings): array {

        $settings = [];

        if (!$dbsettings) {

            return $settings;

        }

        foreach ($dbsettings as $dbsetting) {

            $settings[$dbsetting->plugin][$dbsetting->name] = new stdClass();

            $settings[$dbsetting->plugin][$dbsetting->name]->itemid = $dbsetting->id;

            $settings[$dbsetting->plugin][$dbsetting->name]->name = $dbsetting->name;

            $settings[$dbsetting->plugin][$dbsetting->name]->value = $dbsetting->value;

        }

        return $settings;

    }

    /**

     * Apply a given preset.

     *

     * @param int $presetid The preset identifier to apply.

     * @param bool $simulate Whether this is a simulation or not.

     * @return array List with an array with the applied settings and another with the skipped ones.

     */

    public function apply_preset(int $presetid, bool $simulate = false): array {

        global $DB;

        if (!$DB->get_record('adminpresets', ['id' => $presetid])) {

            throw new moodle_exception('errornopreset', 'core_adminpresets');

        }

        // Apply preset settings.

        [$settingsapplied, $settingsskipped, $appid] = $this->apply_settings($presetid, $simulate);

        // Set plugins visibility.

        [$pluginsapplied, $pluginsskipped] = $this->apply_plugins($presetid, $simulate, $appid);

        $applied = array_merge($settingsapplied, $pluginsapplied);

        $skipped = array_merge($settingsskipped, $pluginsskipped);

        if (!$simulate) {

            // Store it in a config setting as the last preset applied.

            set_config('lastpresetapplied', $presetid, 'adminpresets');

        }

        return [$applied, $skipped];

    }

    /**

     * Create a preset with the current settings and plugins information.

     *

     * @param \stdClass $data Preset info, such as name or description, to be used when creating the preset with the current

     *                 settings and plugins.

     * @return array List with an the presetid created (int), a boolean to define if any setting has been found and

     *               another boolean to specify if any plugin has been found.

     */

    public function export_preset(stdClass $data): array {

        global $DB;

        // Admin_preset record.

        $presetdata = [

            'name' => $data->name ?? '',

            'comments' => !empty($data->comments) ? $data->comments['text'] : '',

            'author' => $data->author ?? '',

        ];

        if (!$presetid = helper::create_preset($presetdata)) {

            throw new moodle_exception('errorinserting', 'core_adminpresets');

        }

        // Store settings.

        $settingsfound = false;

        // Site settings.

        $sitesettings = $this->get_site_settings();

        // Sensible settings.

        $sensiblesettings = explode(',', str_replace(' ', '', get_config('adminpresets', 'sensiblesettings')));

        $sensiblesettings = array_combine($sensiblesettings, $sensiblesettings);

        foreach ($sitesettings as $plugin => $pluginsettings) {

            foreach ($pluginsettings as $settingname => $sitesetting) {

                // Avoid sensible data.

                if (empty($data->includesensiblesettings) && !empty($sensiblesettings["$settingname@@$plugin"])) {

                    continue;

                }

                $setting = new stdClass();

                $setting->adminpresetid = $presetid;

                $setting->plugin = $plugin;

                $setting->name = $settingname;

                $setting->value = $sitesetting->get_value();

                if (!$setting->id = $DB->insert_record('adminpresets_it', $setting)) {

                    throw new moodle_exception('errorinserting', 'core_adminpresets');

                }

                // Setting attributes must also be exported.

                if ($attributes = $sitesetting->get_attributes_values()) {

                    foreach ($attributes as $attname => $attvalue) {

                        $attr = new stdClass();

                        $attr->itemid = $setting->id;

                        $attr->name = $attname;

                        $attr->value = $attvalue;

                        $DB->insert_record('adminpresets_it_a', $attr);

                    }

                }

                $settingsfound = true;

            }

        }

        // Store plugins visibility (enabled/disabled).

        $pluginsfound = false;

        $pluginmanager = \core_plugin_manager::instance();

        $types = $pluginmanager->get_plugin_types();

        foreach ($types as $plugintype => $notused) {

            $plugins = $pluginmanager->get_present_plugins($plugintype);

            $pluginclass = \core_plugin_manager::resolve_plugininfo_class($plugintype);

            if (!empty($plugins)) {

                foreach ($plugins as $pluginname => $plugin) {

                    $entry = new stdClass();

                    $entry->adminpresetid = $presetid;

                    $entry->plugin = $plugintype;

                    $entry->name = $pluginname;

                    $entry->enabled = $pluginclass::get_enabled_plugin($pluginname);

                    $DB->insert_record('adminpresets_plug', $entry);

                    $pluginsfound = true;

                }

            }

        }

        // If there are no settings nor plugins, the admin preset record should be removed.

        if (!$settingsfound && !$pluginsfound) {

            $DB->delete_records('adminpresets', ['id' => $presetid]);

            $presetid = null;

        }

        return [$presetid, $settingsfound, $pluginsfound];

    }

    /**

     * Create the XML content for a given preset.

     *

     * @param int $presetid The preset to download.

     * @return array List with the XML content (string) and a filename proposal based on the preset name (string).

     */

    public function download_preset(int $presetid): array {

        global $DB;

        if (!$preset = $DB->get_record('adminpresets', ['id' => $presetid])) {

            throw new moodle_exception('errornopreset', 'core_adminpresets');

        }

        // Start.

        $xmloutput = new memory_xml_output();

        $xmlwriter = new xml_writer($xmloutput);

        $xmlwriter->start();

        // Preset data.

        $xmlwriter->begin_tag('PRESET');

        foreach (static::$dbxmlrelations as $dbname => $xmlname) {

            $xmlwriter->full_tag($xmlname, $preset->$dbname);

        }

        // We ride through the settings array.

        $items = $DB->get_records('adminpresets_it', ['adminpresetid' => $preset->id]);

        $allsettings = $this->get_settings_from_db($items);

        if ($allsettings) {

            $xmlwriter->begin_tag('ADMIN_SETTINGS');

            foreach ($allsettings as $plugin => $settings) {

                $tagname = strtoupper($plugin);

                // To aviod xml slash problems.

                if (strstr($tagname, '/') != false) {

                    $tagname = str_replace('/', '__', $tagname);

                }

                $xmlwriter->begin_tag($tagname);

                // One tag for each plugin setting.

                if (!empty($settings)) {

                    $xmlwriter->begin_tag('SETTINGS');

                    foreach ($settings as $setting) {

                        // Unset the tag attributes string.

                        $attributes = [];

                        // Getting setting attributes, if present.

                        $attrs = $DB->get_records('adminpresets_it_a', ['itemid' => $setting->itemid]);

                        if ($attrs) {

                            foreach ($attrs as $attr) {

                                $attributes[$attr->name] = $attr->value;

                            }

                        }

                        $xmlwriter->full_tag(strtoupper($setting->name), $setting->value, $attributes);

                    }

                    $xmlwriter->end_tag('SETTINGS');

                }

                $xmlwriter->end_tag(strtoupper($tagname));

            }

            $xmlwriter->end_tag('ADMIN_SETTINGS');

        }

        // We ride through the plugins array.

        $data = $DB->get_records('adminpresets_plug', ['adminpresetid' => $preset->id]);

        if ($data) {

            $plugins = [];

            foreach ($data as $plugin) {

                $plugins[$plugin->plugin][] = $plugin;

            }

            $xmlwriter->begin_tag('PLUGINS');

            foreach ($plugins as $plugintype => $plugintypes) {

                $tagname = strtoupper($plugintype);

                $xmlwriter->begin_tag($tagname);

                foreach ($plugintypes as $plugin) {

                    $xmlwriter->full_tag(strtoupper($plugin->name), $plugin->enabled);

                }

                $xmlwriter->end_tag(strtoupper($tagname));

            }

            $xmlwriter->end_tag('PLUGINS');

        }

        // End.

        $xmlwriter->end_tag('PRESET');

        $xmlwriter->stop();

        $xmlstr = $xmloutput->get_allcontents();

        $filename = addcslashes($preset->name, '"') . '.xml';

        return [$xmlstr, $filename];

    }

    /**

     * Import a given XML preset.

     *

     * @param string $xmlcontent The XML context with the preset to be imported.

     * @param string|null $presetname The preset name that will overwrite the one given in the XML file.

     * @return array List with an the XML element (SimpleXMLElement|null), the imported preset (stdClass|null), a boolean

     *               to define if any setting has been found and another boolean to specify if any plugin has been found.

     */

    public function import_preset(string $xmlcontent, ?string $presetname = null): array {

        global $DB, $USER;

        $settingsfound = false;

        $pluginsfound = false;

        try {

            $xml = simplexml_load_string($xmlcontent);

        } catch (\Exception $exception) {

            $xml = false;

        }

        if (!$xml) {

            return [null, null, $settingsfound, $pluginsfound];

        }

        // Prepare the preset info.

        $preset = new stdClass();

        foreach (static::$dbxmlrelations as $dbname => $xmlname) {

            $preset->$dbname = (String) $xml->$xmlname;

        }

        $preset->userid = $USER->id;

        $preset->timeimported = time();

        // Overwrite preset name.

        if (!empty($presetname)) {

            $preset->name = $presetname;

        }

        // Create the preset.

        if (!$preset->id = $DB->insert_record('adminpresets', $preset)) {

            throw new moodle_exception('errorinserting', 'core_adminpresets');

        }

        // Process settings.

        $sitesettings = $this->get_site_settings();

        $xmladminsettings = $xml->ADMIN_SETTINGS[0];

        foreach ($xmladminsettings as $plugin => $settings) {

            $plugin = strtolower($plugin);

            if (strstr($plugin, '__') != false) {

                $plugin = str_replace('__', '/', $plugin);

            }

            $pluginsettings = $settings->SETTINGS[0];

            if ($pluginsettings) {

                foreach ($pluginsettings->children() as $name => $setting) {

                    $name = strtolower($name);

                    // Default to ''.

                    if ($setting->__toString() === false) {

                        $value = '';

                    } else {

                        $value = $setting->__toString();

                    }

                    if (empty($sitesettings[$plugin][$name])) {

                        debugging('Setting ' . $plugin . '/' . $name . ' not supported by this Moodle version', DEBUG_DEVELOPER);

                        continue;

                    }

                    // Cleaning the setting value.

                    if (!$presetsetting = $this->get_setting($sitesettings[$plugin][$name]->get_settingdata(), $value)) {

                        debugging('Setting ' . $plugin . '/' . $name . ' not implemented', DEBUG_DEVELOPER);

                        continue;

                    }

                    $settingsfound = true;

                    // New item.

                    $item = new stdClass();

                    $item->adminpresetid = $preset->id;

                    $item->plugin = $plugin;

                    $item->name = $name;

                    $item->value = $presetsetting->get_value();

                    // Insert preset item.

                    if (!$item->id = $DB->insert_record('adminpresets_it', $item)) {

                        throw new moodle_exception('errorinserting', 'core_adminpresets');

                    }

                    // Add setting attributes.

                    if ($setting->attributes() && ($itemattributes = $presetsetting->get_attributes())) {

                        foreach ($setting->attributes() as $attrname => $attrvalue) {

                            $itemattributenames = array_flip($itemattributes);

                            // Check the attribute existence.

                            if (!isset($itemattributenames[$attrname])) {

                                debugging('The ' . $plugin . '/' . $name . ' attribute ' . $attrname .

                                        ' is not supported by this Moodle version', DEBUG_DEVELOPER);

                                continue;

                            }

                            $attr = new stdClass();

                            $attr->itemid = $item->id;

                            $attr->name = $attrname;

                            $attr->value = $attrvalue->__toString();

                            $DB->insert_record('adminpresets_it_a', $attr);

                        }

                    }

                }

            }

        }

        // Process plugins.

        if ($xml->PLUGINS) {

            $xmlplugins = $xml->PLUGINS[0];

            foreach ($xmlplugins as $plugin => $plugins) {

                $pluginname = strtolower($plugin);

                foreach ($plugins->children() as $name => $plugin) {

                    $pluginsfound = true;

                    // New plugin.

                    $entry = new stdClass();

                    $entry->adminpresetid = $preset->id;

                    $entry->plugin = $pluginname;

                    $entry->name = strtolower($name);

                    $entry->enabled = $plugin->__toString();

                    // Insert plugin.

                    if (!$entry->id = $DB->insert_record('adminpresets_plug', $entry)) {

                        throw new moodle_exception('errorinserting', 'core_adminpresets');

                    }

                }

            }

        }

        // If there are no valid or selected settings we should delete the admin preset record.

        if (!$settingsfound && !$pluginsfound) {

            $DB->delete_records('adminpresets', ['id' => $preset->id]);

            $preset = null;

        }

        return [$xml, $preset, $settingsfound, $pluginsfound];

    }

    /**

     * Delete given preset.

     *

     * @param int $presetid Preset identifier to delete.

     * @return void

     */

    public function delete_preset(int $presetid): void {

        global $DB;

        // Check the preset exists (cannot delete the pre-installed core "Starter" and "Full" presets).

        $preset = $DB->get_record('adminpresets', ['id' => $presetid, 'iscore' => self::NONCORE_PRESET]);

        if (!$preset) {

            throw new moodle_exception('errordeleting', 'core_adminpresets');

        }

        // Deleting the preset applications.

        if ($previouslyapplied = $DB->get_records('adminpresets_app', ['adminpresetid' => $presetid], 'id')) {

            $appids = array_keys($previouslyapplied);

            list($insql, $inparams) = $DB->get_in_or_equal($appids);

            $DB->delete_records_select('adminpresets_app_it', "adminpresetapplyid $insql", $inparams);

            $DB->delete_records_select('adminpresets_app_it_a', "adminpresetapplyid $insql", $inparams);

            $DB->delete_records_select('adminpresets_app_plug', "adminpresetapplyid $insql", $inparams);

            if (!$DB->delete_records('adminpresets_app', ['adminpresetid' => $presetid])) {

                throw new moodle_exception('errordeleting', 'core_adminpresets');

            }

        }

        // Getting items ids and remove advanced items associated to them.

        $items = $DB->get_records('adminpresets_it', ['adminpresetid' => $presetid], 'id');

        if (!empty($items)) {

            $itemsid = array_keys($items);

            list($insql, $inparams) = $DB->get_in_or_equal($itemsid);

            $DB->delete_records_select('adminpresets_it_a', "itemid $insql", $inparams);

        }

        if (!$DB->delete_records('adminpresets_it', ['adminpresetid' => $presetid])) {

            throw new moodle_exception('errordeleting', 'core_adminpresets');

        }

        // Delete plugins.

        if (!$DB->delete_records('adminpresets_plug', ['adminpresetid' => $presetid])) {

            throw new moodle_exception('errordeleting', 'core_adminpresets');

        }

        // Delete preset.

        if (!$DB->delete_records('adminpresets', ['id' => $presetid])) {

            throw new moodle_exception('errordeleting', 'core_adminpresets');

        }

    }

    /**

     * Revert a given preset applied previously.

     * It backs settings and plugins to their original state before applying the presset and removes

     * the applied preset information from DB.

     *

     * @param int $presetappid The appplied preset identifier to be reverted.

     * @return array List with the presetapp removed (or null if there was some error), an array with the rollback settings/plugins

     *               changed and an array with the failures.

     */

    public function revert_preset(int $presetappid): array {

        global $DB;

        // To store rollback results.

        $presetapp = null;

        $rollback = [];

        $failures = [];

        // Actual settings.

        $sitesettings = $this->get_site_settings();

        if (!$DB->get_record('adminpresets_app', ['id' => $presetappid])) {

            throw new moodle_exception('wrongid', 'core_adminpresets');

        }

        // Items.

        $itemsql = "SELECT cl.id, cl.plugin, cl.name, cl.value, cl.oldvalue, ap.adminpresetapplyid

                      FROM {adminpresets_app_it} ap

                      JOIN {config_log} cl ON cl.id = ap.configlogid

                     WHERE ap.adminpresetapplyid = :presetid";

        $itemchanges = $DB->get_records_sql($itemsql, ['presetid' => $presetappid]);

        if ($itemchanges) {

            foreach ($itemchanges as $change) {

                if ($change->plugin == '') {

                    $change->plugin = 'none';

                }

                // Admin setting.

                if (!empty($sitesettings[$change->plugin][$change->name])) {

                    $actualsetting = $sitesettings[$change->plugin][$change->name];

                    $oldsetting = $this->get_setting($actualsetting->get_settingdata(), $change->oldvalue);

                    $visiblepluginname = $oldsetting->get_settingdata()->plugin;

                    if ($visiblepluginname == 'none') {

                        $visiblepluginname = 'core';

                    }

                    $contextdata = [

                        'plugin' => $visiblepluginname,

                        'visiblename' => $oldsetting->get_settingdata()->visiblename,

                        'oldvisiblevalue' => $actualsetting->get_visiblevalue(),

                        'visiblevalue' => $oldsetting->get_visiblevalue()

                    ];

                    // Check if the actual value is the same set by the preset.

                    if ($change->value == $actualsetting->get_value()) {

                        $oldsetting->save_value();

                        // Output table.

                        $rollback[] = $contextdata;

                        // Deleting the adminpreset applied item instance.

                        $deletewhere = [

                            'adminpresetapplyid' => $change->adminpresetapplyid,

                            'configlogid' => $change->id,

                        ];

                        $DB->delete_records('adminpresets_app_it', $deletewhere);

                    } else {

                        $failures[] = $contextdata;

                    }

                }

            }

        }

        // Attributes.

        $attrsql = "SELECT cl.id, cl.plugin, cl.name, cl.value, cl.oldvalue, ap.itemname, ap.adminpresetapplyid

                      FROM {adminpresets_app_it_a} ap

                      JOIN {config_log} cl ON cl.id = ap.configlogid

                     WHERE ap.adminpresetapplyid = :presetid";

        $attrchanges = $DB->get_records_sql($attrsql, ['presetid' => $presetappid]);

        if ($attrchanges) {

            foreach ($attrchanges as $change) {

                if ($change->plugin == '') {

                    $change->plugin = 'none';

                }

                // Admin setting of the attribute item.

                if (!empty($sitesettings[$change->plugin][$change->itemname])) {

                    // Getting the attribute item.

                    $actualsetting = $sitesettings[$change->plugin][$change->itemname];

                    $oldsetting = $this->get_setting($actualsetting->get_settingdata(), $actualsetting->get_value());

                    $oldsetting->set_attribute_value($change->name, $change->oldvalue);

                    $varname = $change->plugin . '_' . $change->name;

                    // Check if the actual value is the same set by the preset.

                    $actualattributes = $actualsetting->get_attributes_values();

                    if ($change->value == $actualattributes[$change->name]) {

                        $oldsetting->save_attributes_values();

                        // Output table.

                        $visiblepluginname = $oldsetting->get_settingdata()->plugin;

                        if ($visiblepluginname == 'none') {

                            $visiblepluginname = 'core';

                        }

                        $rollback[] = [

                            'plugin' => $visiblepluginname,

                            'visiblename' => $oldsetting->get_settingdata()->visiblename,

                            'oldvisiblevalue' => $actualsetting->get_visiblevalue(),

                            'visiblevalue' => $oldsetting->get_visiblevalue()

                        ];

                        // Deleting the adminpreset applied item attribute instance.

                        $deletewhere = [

                            'adminpresetapplyid' => $change->adminpresetapplyid,

                            'configlogid' => $change->id,

                        ];

                        $DB->delete_records('adminpresets_app_it_a', $deletewhere);

                    } else {

                        $visiblepluginname = $oldsetting->get_settingdata()->plugin;

                        if ($visiblepluginname == 'none') {

                            $visiblepluginname = 'core';

                        }

                        $failures[] = [

                            'plugin' => $visiblepluginname,

                            'visiblename' => $oldsetting->get_settingdata()->visiblename,

                            'oldvisiblevalue' => $actualsetting->get_visiblevalue(),

                            'visiblevalue' => $oldsetting->get_visiblevalue()

                        ];

                    }

                }

            }

        }

        // Plugins.

        $plugins = $DB->get_records('adminpresets_app_plug', ['adminpresetapplyid' => $presetappid]);

        if ($plugins) {

            $pluginmanager = \core_plugin_manager::instance();

            foreach ($plugins as $plugin) {

                $pluginclass = \core_plugin_manager::resolve_plugininfo_class($plugin->plugin);

                $pluginclass::enable_plugin($plugin->name, (int) $plugin->oldvalue);

                // Get the plugininfo object for this plugin, to get its proper visible name.

                $plugininfo = $pluginmanager->get_plugin_info($plugin->plugin . '_' . $plugin->name);

                if ($plugininfo != null) {

                    $visiblename = $plugininfo->displayname;

                } else {

                    $visiblename = $plugin->plugin . '_' . $plugin->name;

                }

                // Output table.

                $rollback[] = [

                    'plugin' => $plugin->plugin,

                    'visiblename' => $visiblename,

                    'oldvisiblevalue' => $plugin->value,

                    'visiblevalue' => $plugin->oldvalue,

                ];

            }

            $DB->delete_records('adminpresets_app_plug', ['adminpresetapplyid' => $presetappid]);

        }

        // Delete application if no items nor attributes nor plugins of the application remains.

        if (!$DB->get_records('adminpresets_app_it', ['adminpresetapplyid' => $presetappid]) &&

                !$DB->get_records('adminpresets_app_it_a', ['adminpresetapplyid' => $presetappid]) &&

                !$DB->get_records('adminpresets_app_plug', ['adminpresetapplyid' => $presetappid])) {

            $presetapp = $DB->get_record('adminpresets_app', ['id' => $presetappid]);

            $DB->delete_records('adminpresets_app', ['id' => $presetappid]);

        }

        return [$presetapp, $rollback, $failures];

    }

    /**

     * Apply settings from a preset.

     *

     * @param int $presetid The preset identifier to apply.

     * @param bool $simulate Whether this is a simulation or not.

     * @param int|null $adminpresetapplyid The identifier of the adminpresetapply or null if it hasn't been created previously.

     * @return array List with an array with the applied settings, another with the skipped ones and the adminpresetapplyid.

     */

    protected function apply_settings(int $presetid, bool $simulate = false, ?int $adminpresetapplyid = null): array {

        global $DB, $USER;

        $applied = [];

        $skipped = [];

        if (!$items = $DB->get_records('adminpresets_it', ['adminpresetid' => $presetid])) {

            return [$applied, $skipped, $adminpresetapplyid];

        }

        $presetdbsettings = $this->get_settings_from_db($items);

        // Standarized format: $array['plugin']['settingname'] = child class.

        $presetsettings = $this->get_settings($presetdbsettings, false, []);

        // Standarized format: $array['plugin']['settingname'] = child class.

        $siteavailablesettings = $this->get_site_settings();

        // Set settings values.

        foreach ($presetsettings as $plugin => $pluginsettings) {

            foreach ($pluginsettings as $settingname => $presetsetting) {