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\local\importer;

use core\notification;

use mod_data\manager;

use mod_data\preset;

use stdClass;

use html_writer;

/**

 * Abstract class used for data preset importers

 *

 * @package    mod_data

 * @copyright  2022 Amaia Anabitarte <amaia@moodle.com>

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

 */

abstract class preset_importer {

    /** @var manager manager instance. */

    private $manager;

    /** @var string directory where to find the preset. */

    protected $directory;

    /** @var array fields to remove. */

    public $fieldstoremove;

    /** @var array fields to update. */

    public $fieldstoupdate;

    /** @var array fields to create. */

    public $fieldstocreate;

    /** @var array settings to be imported. */

    public $settings;

    /**

     * Constructor

     *

     * @param manager $manager

     * @param string $directory

     */

    public function __construct(manager $manager, string $directory) {

        $this->manager = $manager;

        $this->directory = $directory;

        // Read the preset and saved result.

        $this->settings = $this->get_preset_settings();

    }

    /**

     * Returns the name of the directory the preset is located in

     *

     * @return string

     */

    public function get_directory(): string {

        return basename($this->directory);

    }

    /**

     * Retreive the contents of a file. That file may either be in a conventional directory of the Moodle file storage

     *

     * @param \file_storage|null $filestorage . Should be null if using a conventional directory

     * @param \stored_file|null $fileobj the directory to look in. null if using a conventional directory

     * @param string|null $dir the directory to look in. null if using the Moodle file storage

     * @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.

     */

    public function get_file_contents(

        ?\file_storage &$filestorage,

        ?\stored_file &$fileobj,

        ?string $dir,

        string $filename

    ): ?string {

        if (empty($filestorage) || empty($fileobj)) {

            if (substr($dir, -1) != '/') {

                $dir .= '/';

            }

            if (file_exists($dir.$filename)) {

                return file_get_contents($dir.$filename);

            } else {

                return null;

            }

        } else {

            if ($filestorage->file_exists(

                DATA_PRESET_CONTEXT,

                DATA_PRESET_COMPONENT,

                DATA_PRESET_FILEAREA,

                0,

                $fileobj->get_filepath(),

                $filename)

            ) {

                $file = $filestorage->get_file(

                    DATA_PRESET_CONTEXT,

                    DATA_PRESET_COMPONENT,

                    DATA_PRESET_FILEAREA,

                    0,

                    $fileobj->get_filepath(),

                    $filename

                );

                return $file->get_content();

            } else {

                return null;

            }

        }

    }

    /**

     * Gets the preset settings

     *

     * @return stdClass Settings to be imported.

     */

    public function get_preset_settings(): stdClass {

        global $CFG;

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

        $fs = null;

        $fileobj = null;

        if (!preset::is_directory_a_preset($this->directory)) {

            // Maybe the user requested a preset stored in the Moodle file storage.

            $fs = get_file_storage();

            $files = $fs->get_area_files(DATA_PRESET_CONTEXT, DATA_PRESET_COMPONENT, DATA_PRESET_FILEAREA);

            // Preset name to find will be the final element of the directory.

            $explodeddirectory = explode('/', $this->directory);

            $presettofind = end($explodeddirectory);

            // Now go through the available files available and see if we can find it.

            foreach ($files as $file) {

                if (($file->is_directory() && $file->get_filepath() == '/') || !$file->is_directory()) {

                    continue;

                }

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

                if ($presetname == $presettofind) {

                    $this->directory = $presetname;

                    $fileobj = $file;

                }

            }

            if (empty($fileobj)) {

                throw new \moodle_exception('invalidpreset', 'data', '', $this->directory);

            }

        }

        $allowedsettings = [

            'intro',

            'comments',

            'requiredentries',

            'requiredentriestoview',

            'maxentries',

            'rssarticles',

            'approval',

            'defaultsortdir',

            'defaultsort'

        ];

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

        $result = new stdClass;

        $result->settings = new stdClass;

        $result->importfields = [];

        $result->currentfields = $this->manager->get_field_records();

        // Grab XML.

        $presetxml = $this->get_file_contents($fs, $fileobj, $this->directory, 'preset.xml');

        $parsedxml = xmlize($presetxml, 0);

        // First, do settings. Put in user friendly array.

        $settingsarray = $parsedxml['preset']['#']['settings'][0]['#'];

        $result->settings = new StdClass();

        foreach ($settingsarray as $setting => $value) {

            if (!is_array($value) || !in_array($setting, $allowedsettings)) {

                // Unsupported setting.

                continue;

            }

            $result->settings->$setting = $value[0]['#'];

        }

        // Now work out fields to user friendly array.

        if (

            array_key_exists('preset', $parsedxml) &&

            array_key_exists('#', $parsedxml['preset']) &&

            array_key_exists('field', $parsedxml['preset']['#'])) {

            $fieldsarray = $parsedxml['preset']['#']['field'];

            foreach ($fieldsarray as $field) {

                if (!is_array($field)) {

                    continue;

                }

                $fieldstoimport = new StdClass();

                foreach ($field['#'] as $param => $value) {

                    if (!is_array($value)) {

                        continue;

                    }

                    $fieldstoimport->$param = $value[0]['#'];

                }

                $fieldstoimport->dataid = $module->id;

                $fieldstoimport->type = clean_param($fieldstoimport->type, PARAM_ALPHA);

                $result->importfields[] = $fieldstoimport;

            }

        }

        // Calculate default mapping.

        if (is_null($this->fieldstoremove) && is_null($this->fieldstocreate) && is_null($this->fieldstoupdate)) {

            $this->set_affected_fields($result->importfields, $result->currentfields);

        }

        // Now add the HTML templates to the settings array so we can update d.

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

            $result->settings->$templatename = $this->get_file_contents(

                $fs,

                $fileobj,

                $this->directory,

                $templatefile

            );

        }

        $result->settings->instance = $module->id;

        return $result;

    }

    /**

     * Import the preset into the given database module

     *

     * @param bool $overwritesettings Whether to overwrite activity settings or not.

     * @return bool Wether the importing has been successful.

     */

    public function import(bool $overwritesettings): bool {

        global $DB, $OUTPUT, $CFG;

        $settings = $this->settings->settings;

        $currentfields = $this->settings->currentfields;

        $missingfieldtypes = [];

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

        foreach ($this->fieldstoupdate as $currentid => $updatable) {

            if ($currentid != -1 && isset($currentfields[$currentid])) {

                $fieldobject = data_get_field_from_id($currentfields[$currentid]->id, $module);

                $toupdate = false;

                foreach ($updatable as $param => $value) {

                    if ($param != "id" && $fieldobject->field->$param !== $value) {

                        $fieldobject->field->$param = $value;

                    }

                }

                unset($fieldobject->field->similarfield);

                $fieldobject->update_field();

                unset($fieldobject);

            }

        }

        foreach ($this->fieldstocreate as $newfield) {

            /* Make a new field */

            $filepath = $CFG->dirroot."/mod/data/field/$newfield->type/field.class.php";

            if (!file_exists($filepath)) {

                $missingfieldtypes[] = $newfield->name;

                continue;

            }

            include_once($filepath);

            if (!isset($newfield->description)) {

                $newfield->description = '';

            }

            $classname = 'data_field_' . $newfield->type;

            $fieldclass = new $classname($newfield, $module);

            $fieldclass->insert_field();

            unset($fieldclass);

        }

        if (!empty($missingfieldtypes)) {

            echo $OUTPUT->notification(get_string('missingfieldtypeimport', 'data') . html_writer::alist($missingfieldtypes));

        }

        // Get rid of all old unused data.

        foreach ($currentfields as $cid => $currentfield) {

            if (!array_key_exists($cid, $this->fieldstoupdate)) {

                // Delete all information related to fields.

                $todelete = data_get_field_from_id($currentfield->id, $module);

                $todelete->delete_field();

            }

        }

        // Handle special settings here.

        if (!empty($settings->defaultsort)) {

            if (is_numeric($settings->defaultsort)) {

                // Old broken value.

                $settings->defaultsort = 0;

            } else {

                $settings->defaultsort = (int)$DB->get_field(

                    'data_fields',

                    'id',

                    ['dataid' => $module->id, 'name' => $settings->defaultsort]

                );

            }

        } else {

            $settings->defaultsort = 0;

        }

        // Do we want to overwrite all current database settings?

        if ($overwritesettings) {

            // All supported settings.

            $overwrite = array_keys((array)$settings);

        } else {

            // Only templates and sorting.

            $overwrite = ['singletemplate', 'listtemplate', 'listtemplateheader', 'listtemplatefooter',

                'addtemplate', 'rsstemplate', 'rsstitletemplate', 'csstemplate', 'jstemplate',

                'asearchtemplate', 'defaultsortdir', 'defaultsort'];

        }

        // Now overwrite current data settings.

        foreach ($module as $prop => $unused) {

            if (in_array($prop, $overwrite)) {

                $module->$prop = $settings->$prop;

            }

        }

        data_update_instance($module);

        return $this->cleanup();

    }

    /**

     * Returns information about the fields needs to be removed, updated or created.

     *

     * @param array $newfields Array of new fields to be applied.

     * @param array $currentfields Array of current fields on database activity.

     * @return void

     */

    public function set_affected_fields(array $newfields = [], array $currentfields = []): void {

        $fieldstoremove = [];

        $fieldstocreate = [];

        $preservedfields = [];

        // Maps fields and makes new ones.

        if (!empty($newfields)) {

            // We require an injective mapping, and need to know what to protect.

            foreach ($newfields as $newid => $newfield) {

                $preservedfieldid = optional_param("field_$newid", -1, PARAM_INT);

                if (array_key_exists($preservedfieldid, $preservedfields)) {

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

                }

                if ($preservedfieldid == -1) {

                    // Let's check if there is any field with same type and name that we could map to.

                    foreach ($currentfields as $currentid => $currentfield) {

                        if (($currentfield->type == $newfield->type) &&

                            ($currentfield->name == $newfield->name) && !array_key_exists($currentid, $preservedfields)) {

                            // We found a possible default map.

                            $preservedfieldid = $currentid;

                            $preservedfields[$currentid] = $newfield;

                        }

                    }

                }

                if ($preservedfieldid == -1) {

                    // We need to create a new field.

                    $fieldstocreate[] = $newfield;

                } else {

                    $preservedfields[$preservedfieldid] = $newfield;

                }

            }

        }

        foreach ($currentfields as $currentid => $currentfield) {

            if (!array_key_exists($currentid, $preservedfields)) {

                $fieldstoremove[] = $currentfield;

            }

        }

        $this->fieldstocreate = $fieldstocreate;

        $this->fieldstoremove = $fieldstoremove;

        $this->fieldstoupdate = $preservedfields;

    }

    /**

     * Any clean up routines should go here

     *

     * @return bool Wether the preset has been successfully cleaned up.

     */

    public function cleanup(): bool {

        return true;

    }

    /**

     * Check if the importing process needs fields mapping.

     *

     * @return bool True if the current database needs to map the fields imported.

     */

    public function needs_mapping(): bool {

        if (!$this->manager->has_fields()) {

            return false;

        }

        return (!empty($this->fieldstocreate) || !empty($this->fieldstoremove));

    }

    /**

     * Returns the information we need to build the importer selector.

     *

     * @return array Value and name for the preset importer selector

     */

    public function get_preset_selector(): array {

        return ['name' => 'directory', 'value' => $this->get_directory()];

    }

    /**

     * Helper function to finish up the import routine.

     *

     * Called from fields and presets pages.

     *

     * @param bool $overwritesettings Whether to overwrite activity settings or not.

     * @param stdClass $instance database instance object

     * @return void

     */

    public function finish_import_process(bool $overwritesettings, stdClass $instance): void {

        $result = $this->import($overwritesettings);

        if ($result) {

            notification::success(get_string('importsuccess', 'mod_data'));

        } else {

            notification::error(get_string('cannotapplypreset', 'mod_data'));

        }

        $backurl = new \moodle_url('/mod/data/field.php', ['d' => $instance->id]);

        redirect($backurl);

    }

    /**

     * Get the right importer instance from the provided parameters (POST or GET)

     *

     * @param manager $manager the current database manager

     * @return preset_importer the relevant preset_importer instance

     * @throws \moodle_exception when the file provided as parameter (POST or GET) does not exist

     */

    public static function create_from_parameters(manager $manager): preset_importer {

        $fullname = optional_param('fullname', '', PARAM_PATH);    // Directory the preset is in.

        if (!$fullname) {

            $fullname = required_param('directory', PARAM_FILE);

        }

        return self::create_from_plugin_or_directory($manager, $fullname);

    }

    /**

     * Get the right importer instance from the provided parameters (POST or GET)

     *

     * @param manager $manager the current database manager

     * @param string $pluginordirectory The plugin name or directory to create the importer from.

     * @return preset_importer the relevant preset_importer instance

     */

    public static function create_from_plugin_or_directory(manager $manager, string $pluginordirectory): preset_importer {

        global $CFG;

        if (!$pluginordirectory) {

            throw new \moodle_exception('emptypresetname', 'mod_data');

        }

        try {

            $presetdir = $CFG->tempdir . '/forms/' . $pluginordirectory;

            if (file_exists($presetdir) && is_dir($presetdir)) {

                return new preset_upload_importer($manager, $presetdir);

            } else {

                return new preset_existing_importer($manager, $pluginordirectory);

            }

        } catch (\moodle_exception $e) {

            throw new \moodle_exception('errorpresetnotfound', 'mod_data', '', $pluginordirectory);

        }

    }

    /**

     * Get the information needed to decide the modal

     *

     * @return array An array with all the information to decide the mapping

     */

    public function get_mapping_information(): array {

        return [

            'needsmapping' => $this->needs_mapping(),

            'presetname' => preset::get_name_from_plugin($this->get_directory()),

            'fieldstocreate' => $this->get_field_names($this->fieldstocreate),

            'fieldstoremove' => $this->get_field_names($this->fieldstoremove),

        ];

    }

    /**

     * Returns a list of the fields

     *

     * @param array $fields Array of fields to get name from.

     * @return string   A string listing the names of the fields.

     */

    public function get_field_names(array $fields): string {

        $fieldnames = array_map(function($field) {

            return $field->name;

        }, $fields);

        return implode(', ', $fieldnames);

    }

}