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

/**
 * Class for converting files between different file formats using unoconv.
 *
 * @package    core_files
 * @copyright  2017 Damyon Wiese
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
namespace core_files;

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

use stored_file;

/**
 * Class for converting files between different formats using unoconv.
 *
 * @package    core_files
 * @copyright  2017 Damyon Wiese
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class converter {

    /**
     * Get a list of enabled plugins and classes.
     *
     * @return  array List of enabled plugins
     */
    protected function get_enabled_plugins() {
        $plugins = \core\plugininfo\fileconverter::get_enabled_plugins();

        $pluginclasses = [];
        foreach ($plugins as $plugin) {
            $pluginclasses[$plugin] = \core\plugininfo\fileconverter::get_classname($plugin);
        }

        return $pluginclasses;
    }

    /**
     * Return the file_storage API.
     *
     * This allows for mocking of the file_storage API.
     *
     * @return \file_storage
     */
    protected function get_file_storage() {
        return get_file_storage();
    }

    /**
     * Start the conversion for a stored_file into a new format.
     *
     * @param   stored_file $file The file to convert
     * @param   string $format The desired target file format (file extension)
     * @param   boolean $forcerefresh If true, the file will be converted every time (not cached).
     * @return  conversion conversion object
     */
    public function start_conversion(stored_file $file, $format, $forcerefresh = false) {
        $conversions = conversion::get_conversions_for_file($file, $format);

        if ($forcerefresh || count($conversions) > 1) {
            while ($conversion = array_shift($conversions)) {
                if ($conversion->get('id')) {
                    $conversion->delete();
                }
            }
        }

        if (empty($conversions)) {
            $conversion = new conversion(0, (object) [
                'sourcefileid' => $file->get_id(),
                'targetformat' => $format,
            ]);
            $conversion->create();
        } else {
            $conversion = array_shift($conversions);
        }

        if ($conversion->get('status') !== conversion::STATUS_COMPLETE) {
            $this->poll_conversion($conversion);
        }

        return $conversion;
    }

    /**
     * Poll for updates to the supplied conversion.
     *
     * @param   conversion $conversion The conversion in progress
     * @return  $this
     */
    public function poll_conversion(conversion $conversion) {
        $format = $conversion->get('targetformat');
        $file = $conversion->get_sourcefile();

        if ($conversion->get('status') == conversion::STATUS_IN_PROGRESS) {
            // The current conversion is in progress.
            // Check for updates.
            if ($instance = $conversion->get_converter_instance()) {
                $instance->poll_conversion_status($conversion);
            } else {
                // Unable to fetch the converter instance.
                // Reset the status back to PENDING so that it may be picked up again.
                $conversion->set('status', conversion::STATUS_PENDING);
            }
            $conversion->update();
        }

        // Refresh the status.
        $status = $conversion->get('status');
        if ($status === conversion::STATUS_PENDING || $status === conversion::STATUS_FAILED) {
            // The current status is either pending or failed.
            // Attempt to pick up a new converter and convert the document.
            $from = pathinfo($file->get_filename(), PATHINFO_EXTENSION);
            $converters = $this->get_document_converter_classes($from, $format);
            $currentconverter = $this->get_next_converter($converters, $conversion->get('converter'));

            if (!$currentconverter) {
                // No more converters available.
                $conversion->set('status', conversion::STATUS_FAILED);
                $conversion->update();
                return $this;
            }

            do {
                $conversion
                    ->set('converter', $currentconverter)
                    ->set('status', conversion::STATUS_IN_PROGRESS)
                    ->update();

                $instance = $conversion->get_converter_instance();
                $instance->start_document_conversion($conversion);
                $failed = $conversion->get('status') === conversion::STATUS_FAILED;
                $currentconverter = $this->get_next_converter($converters, $currentconverter);
            } while ($failed && $currentconverter);

            $conversion->update();
        }

        return $this;
    }

    /**
     * Fetch the next converter to try.
     *
     * @param   array $converters The list of converters to try
     * @param   string|null $currentconverter The converter currently in use
     * @return  string|false Name of next converter if present
     */
    protected function get_next_converter($converters, $currentconverter = null) {
        if ($currentconverter) {
            $keys = moodle_array_keys_filter($converters, $currentconverter);
            $key = $keys[0];
            if (isset($converters[$key + 1])) {
                return $converters[$key + 1];
            } else {
                return false;
            }
        } else if (!empty($converters)) {
            return $converters[0];
        } else {
            return false;
        }
    }

    /**
     * Fetch the class for the preferred document converter.
     *
     * @param   string $from The source target file (file extension)
     * @param   string $to The desired target file format (file extension)
     * @return  string The class for document conversion
     */
    protected function get_document_converter_classes($from, $to) {
        $classes = [];

        $converters = $this->get_enabled_plugins();
        foreach ($converters as $plugin => $classname) {
            if (!class_exists($classname)) {
                continue;
            }

            if (!$classname::are_requirements_met()) {
                continue;
            }

            if ($classname::supports($from, $to)) {
                $classes[] = $classname;
            }
        }

        return $classes;
    }

    /**
     * Check whether document conversion is supported for this file and target format.
     *
     * @param   stored_file $file The file to convert
     * @param   string $to The desired target file format (file extension)
     * @return  bool Whether the target type can be converted
     */
    public function can_convert_storedfile_to(stored_file $file, $to) {
        if ($file->is_directory()) {
            // Directories cannot be converted.
            return false;
        }

        if (!$file->get_filesize()) {
            // Empty files cannot be converted.
            return false;
        }

        $from = pathinfo($file->get_filename(), PATHINFO_EXTENSION);
        if (!$from) {
            // No file extension could be found. Unable to determine converter.
            return false;
        }

        return $this->can_convert_format_to($from, $to);
    }

    /**
     * Check whether document conversion is supported for this file and target format.
     *
     * @param   string $from The source target file (file extension)
     * @param   string $to The desired target file format (file extension)
     * @return  bool Whether the target type can be converted
     */
    public function can_convert_format_to($from, $to) {
        return !empty($this->get_document_converter_classes($from, $to));
    }

}