moodle/admin/tool/moodlenet/classes/local/import_processor.php

<?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/>.
/**
 * Contains the import_processor class.
 *
 * @package tool_moodlenet
 * @copyright 2020 Jake Dallimore <jrhdallimore@gmail.com>
 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
namespace tool_moodlenet\local;

/**
 * The import_processor class.
 *
 * The import_processor objects provide a means to import a remote resource into a course section, delegating the handling of
 * content to the relevant module, via its dndupload_handler callback.
 *
 * @copyright 2020 Jake Dallimore <jrhdallimore@gmail.com>
 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class import_processor {

    /** @var object The course that we are uploading to */
    protected $course = null;

    /** @var int The section number we are uploading to */
    protected $section = null;

    /** @var import_handler_registry $handlerregistry registry object to use for cross checking the supplied handler.*/
    protected $handlerregistry;

    /** @var import_handler_info $handlerinfo information about the module handling the import.*/
    protected $handlerinfo;

    /** @var \stdClass $user the user conducting the import.*/
    protected $user;

    /** @var remote_resource $remoteresource the remote resource being imported.*/
    protected $remoteresource;

    /** @var string[] $descriptionoverrides list of modules which support having their descriptions updated, post-import. */
    protected $descriptionoverrides = ['folder', 'page', 'resource', 'scorm', 'url'];

    /**
     * The import_processor constructor.
     *
     * @param \stdClass $course the course object.
     * @param int $section the section number in the course, starting at 0.
     * @param remote_resource $remoteresource the remote resource to import.
     * @param import_handler_info $handlerinfo information about which module is handling the import.
     * @param import_handler_registry $handlerregistry A registry of import handlers, to use for validation.
     * @throws \coding_exception If any of the params are invalid.
     */
    public function __construct(\stdClass $course, int $section, remote_resource $remoteresource, import_handler_info $handlerinfo,
            import_handler_registry $handlerregistry) {

        global $DB, $USER;

        if ($section < 0) {
            throw new \coding_exception("Invalid section number $section. Must be > 0.");
        }
        if (!$DB->record_exists('modules', array('name' => $handlerinfo->get_module_name()))) {
            throw new \coding_exception("Module {$handlerinfo->get_module_name()} does not exist");
        }

        $this->course = $course;
        $this->section = $section;
        $this->handlerregistry = $handlerregistry;
        $this->user = $USER;
        $this->remoteresource = $remoteresource;
        $this->handlerinfo = $handlerinfo;

        // ALL handlers must have a strategy and ANY strategy can process ANY resource.
        // It is therefore NOT POSSIBLE to have a resource that CANNOT be processed by a handler.
        // So, there's no need to verify that the remote_resource CAN be handled by the handler. It always can.
    }

    /**
     * Run the import process, including file download, module creation and cleanup (cache purge, etc).
     */
    public function process(): void {
        // Allow the strategy to do setup for this file import.
        $moduledata = $this->handlerinfo->get_strategy()->import($this->remoteresource, $this->user, $this->course, $this->section);

        // Create the course module, and add that information to the data to be sent to the plugin handling the resource.
        $cmdata = $this->create_course_module($this->course, $this->section, $this->handlerinfo->get_module_name());
        $moduledata->coursemodule = $cmdata->id;

        // Now, send the data to the handling plugin to let it set up.
        $instanceid = plugin_callback('mod', $this->handlerinfo->get_module_name(), 'dndupload', 'handle', [$moduledata],
            'invalidfunction');
        if ($instanceid == 'invalidfunction') {
            $name = $this->handlerinfo->get_module_name();
            throw new \coding_exception("$name does not support drag and drop upload (missing {$name}_dndupload_handle function)");
        }

        // Now, update the module description if the module supports it and only if it's not currently set.
        $this->update_module_description($instanceid);

        // Finish setting up the course module.
        $this->finish_setup_course_module($instanceid, $cmdata->id);
    }

    /**
     * Update the module's description (intro), if that feature is supported.
     *
     * @param int $instanceid the instance id of the module to update.
     */
    protected function update_module_description(int $instanceid): void {
        global $DB, $CFG;
        require_once($CFG->libdir . '/moodlelib.php');

        if (plugin_supports('mod', $this->handlerinfo->get_module_name(), FEATURE_MOD_INTRO, true)) {
            require_once($CFG->libdir . '/editorlib.php');
            require_once($CFG->libdir . '/modinfolib.php');

            $rec = $DB->get_record($this->handlerinfo->get_module_name(), ['id' => $instanceid]);

            if (empty($rec->intro) || in_array($this->handlerinfo->get_module_name(), $this->descriptionoverrides)) {
                $updatedata = (object)[
                    'id' => $instanceid,
                    'intro' => clean_param($this->remoteresource->get_description(), PARAM_TEXT),
                    'introformat' => editors_get_preferred_format()
                ];

                $DB->update_record($this->handlerinfo->get_module_name(), $updatedata);

                rebuild_course_cache($this->course->id, true);
            }
        }
    }

    /**
     * Create the course module to hold the file/content that has been uploaded.
     * @param \stdClass $course the course object.
     * @param int $section the section.
     * @param string $modname the name of the module, e.g. 'label'.
     * @return \stdClass the course module data.
     */
    protected function create_course_module(\stdClass $course, int $section, string $modname): \stdClass {
        global $CFG;
        require_once($CFG->dirroot . '/course/modlib.php');
        list($module, $context, $cw, $cm, $data) = prepare_new_moduleinfo_data($course, $modname, $section);
        $data->visible = false; // The module is created in a hidden state.
        $data->coursemodule = $data->id = add_course_module($data);
        return $data;
    }

    /**
     * Finish off any course module setup, such as adding to the course section and firing events.
     *
     * @param int $instanceid id returned by the mod when it was created.
     * @param int $cmid the course module record id, for removal if something went wrong.
     */
    protected function finish_setup_course_module($instanceid, int $cmid): void {
        global $DB;

        if (!$instanceid) {
            // Something has gone wrong - undo everything we can.
            course_delete_module($cmid);
            throw new \moodle_exception('errorcreatingactivity', 'moodle', '', $this->handlerinfo->get_module_name());
        }

        // Note the section visibility.
        $visible = get_fast_modinfo($this->course)->get_section_info($this->section)->visible;

        $DB->set_field('course_modules', 'instance', $instanceid, array('id' => $cmid));

        // Rebuild the course cache after update action.
        rebuild_course_cache($this->course->id, true);

        course_add_cm_to_section($this->course, $cmid, $this->section);

        set_coursemodule_visible($cmid, $visible);
        if (!$visible) {
            $DB->set_field('course_modules', 'visibleold', 1, array('id' => $cmid));
        }

        // Retrieve the final info about this module.
        $info = get_fast_modinfo($this->course, $this->user->id);
        if (!isset($info->cms[$cmid])) {
            // The course module has not been properly created in the course - undo everything.
            course_delete_module($cmid);
            throw new \moodle_exception('errorcreatingactivity', 'moodle', '', $this->handlerinfo->get_module_name());
        }
        $mod = $info->get_cm($cmid);

        // Trigger course module created event.
        $event = \core\event\course_module_created::create_from_cm($mod);
        $event->trigger();
    }
}