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

/**
 * Custom lang importer.
 *
 * @package    tool_customlang
 * @copyright  2020 Ferran Recio <ferran@moodle.com>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */

namespace tool_customlang\local;

use tool_customlang\local\mlang\phpparser;
use tool_customlang\local\mlang\logstatus;
use tool_customlang\local\mlang\langstring;
use core\output\notification;
use stored_file;
use coding_exception;
use moodle_exception;
use core_component;
use stdClass;

/**
 * Class containing tha custom lang importer
 *
 * @package    tool_customlang
 * @copyright  2020 Ferran Recio <ferran@moodle.com>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class importer {

    /** @var int imports will only create new customizations */
    public const IMPORTNEW = 1;
    /** @var int imports will only update the current customizations */
    public const IMPORTUPDATE = 2;
    /** @var int imports all strings */
    public const IMPORTALL = 3;

    /**
     * @var string the language name
     */
    protected $lng;

    /**
     * @var int the importation mode (new, update, all)
     */
    protected $importmode;

    /**
     * @var string request folder path
     */
    private $folder;

    /**
     * @var array import log messages
     */
    private $log;

    /**
     * Constructor for the importer class.
     *
     * @param string $lng the current language to import.
     * @param int $importmode the import method (IMPORTALL, IMPORTNEW, IMPORTUPDATE).
     */
    public function __construct(string $lng, int $importmode = self::IMPORTALL) {
        $this->lng = $lng;
        $this->importmode = $importmode;
        $this->log = [];
    }

    /**
     * Returns the last parse log.
     *
     * @return logstatus[] mlang logstatus with the messages
     */
    public function get_log(): array {
        return $this->log;
    }

    /**
     * Import customlang files.
     *
     * @param stored_file[] $files array of files to import
     */
    public function import(array $files): void {
        // Create a temporal folder to store the files.
        $this->folder = make_request_directory(false);

        $langfiles = $this->deploy_files($files);

        $this->process_files($langfiles);
    }

    /**
     * Deploy all files into a request folder.
     *
     * @param stored_file[] $files array of files to deploy
     * @return string[] of file paths
     */
    private function deploy_files(array $files): array {
        $result = [];
        // Desploy all files.
        foreach ($files as $file) {
            if ($file->get_mimetype() == 'application/zip') {
                $result = array_merge($result, $this->unzip_file($file));
            } else {
                $path = $this->folder.'/'.$file->get_filename();
                $file->copy_content_to($path);
                $result = array_merge($result, [$path]);
            }
        }
        return $result;
    }

    /**
     * Unzip a file into the request folder.
     *
     * @param stored_file $file the zip file to unzip
     * @return string[] of zip content paths
     */
    private function unzip_file(stored_file $file): array {
        $fp = get_file_packer('application/zip');
        $zipcontents = $fp->extract_to_pathname($file, $this->folder);
        if (!$zipcontents) {
            throw new moodle_exception("Error Unzipping file", 1);
        }
        $result = [];
        foreach ($zipcontents as $contentname => $success) {
            if ($success) {
                $result[] = $this->folder.'/'.$contentname;
            }
        }
        return $result;
    }

    /**
     * Import strings from a list of langfiles.
     *
     * @param string[] $langfiles an array with file paths
     */
    private function process_files(array $langfiles): void {
        $parser = phpparser::get_instance();
        foreach ($langfiles as $filepath) {
            $component = $this->component_from_filepath($filepath);
            if ($component) {
                $strings = $parser->parse(file_get_contents($filepath));
                $this->import_strings($strings, $component);
            }
        }
    }

    /**
     * Try to get the component from a filepath.
     *
     * @param string $filepath the filepath
     * @return stdCalss|null the DB record of that component
     */
    private function component_from_filepath(string $filepath) {
        global $DB;

        // Get component from filename.
        $pathparts = pathinfo($filepath);
        if (empty($pathparts['filename'])) {
            throw new coding_exception("Cannot get filename from $filepath", 1);
        }
        $filename = $pathparts['filename'];

        $normalized = core_component::normalize_component($filename);
        if (count($normalized) == 1 || empty($normalized[1])) {
            $componentname = $normalized[0];
        } else {
            $componentname = implode('_', $normalized);
        }

        $result = $DB->get_record('tool_customlang_components', ['name' => $componentname]);

        if (!$result) {
            $this->log[] = new logstatus('notice_missingcomponent', notification::NOTIFY_ERROR, null, $componentname);
            return null;
        }
        return $result;
    }

    /**
     * Import an array of strings into the customlang tables.
     *
     * @param langstring[] $strings the langstring to set
     * @param stdClass $component the target component
     */
    private function import_strings(array $strings, stdClass $component): void {
        global $DB;

        foreach ($strings as $newstring) {
            // Check current DB entry.
            $customlang = $DB->get_record('tool_customlang', [
                'componentid' => $component->id,
                'stringid' => $newstring->id,
                'lang' => $this->lng,
            ]);
            if (!$customlang) {
                $customlang = null;
            }

            if ($this->can_save_string($customlang, $newstring, $component)) {
                $customlang->local = $newstring->text;
                $customlang->timecustomized = $newstring->timemodified;
                $customlang->outdated = 0;
                $customlang->modified = 1;
                $DB->update_record('tool_customlang', $customlang);
            }
        }
    }

    /**
     * Determine if a specific string can be saved based on the current importmode.
     *
     * @param stdClass $customlang customlang original record
     * @param langstring $newstring the new strign to store
     * @param stdClass $component the component target
     * @return bool if the string can be stored
     */
    private function can_save_string(?stdClass $customlang, langstring $newstring, stdClass $component): bool {
        $result = false;
        $message = 'notice_success';
        if (empty($customlang)) {
            $message = 'notice_inexitentstring';
            $this->log[] = new logstatus($message, notification::NOTIFY_ERROR, null, $component->name, $newstring);
            return $result;
        }

        switch ($this->importmode) {
            case self::IMPORTNEW:
                $result = empty($customlang->local);
                $warningmessage = 'notice_ignoreupdate';
                break;
            case self::IMPORTUPDATE:
                $result = !empty($customlang->local);
                $warningmessage = 'notice_ignorenew';
                break;
            case self::IMPORTALL:
                $result = true;
                break;
        }
        if ($result) {
            $errorlevel = notification::NOTIFY_SUCCESS;
        } else {
            $errorlevel = notification::NOTIFY_ERROR;
            $message = $warningmessage;
        }
        $this->log[] = new logstatus($message, $errorlevel, null, $component->name, $newstring);

        return $result;
    }
}