Search moodle.org's
Developer Documentation

See Release Notes

  • Bug fixes for general core bugs in 4.2.x will end 22 April 2024 (12 months).
  • Bug fixes for security issues in 4.2.x will end 7 October 2024 (18 months).
  • PHP version: minimum PHP 8.0.0 Note: minimum PHP version has increased since Moodle 4.1. PHP 8.1.x is supported too.
<?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/>.

/**
 * Defines Moodle 1.9 backup conversion handlers
 *
 * Handlers are classes responsible for the actual conversion work. Their logic
 * is similar to the functionality provided by steps in plan based restore process.
 *
 * @package    backup-convert
 * @subpackage moodle1
 * @copyright  2011 David Mudrak <david@moodle.com>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */

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

require_once($CFG->dirroot . '/backup/util/xml/xml_writer.class.php');
require_once($CFG->dirroot . '/backup/util/xml/output/xml_output.class.php');
require_once($CFG->dirroot . '/backup/util/xml/output/file_xml_output.class.php');

/**
 * Handlers factory class
 */
abstract class moodle1_handlers_factory {

    /**
     * @param moodle1_converter the converter requesting the converters
     * @return list of all available conversion handlers
     */
    public static function get_handlers(moodle1_converter $converter) {

        $handlers = array(
            new moodle1_root_handler($converter),
            new moodle1_info_handler($converter),
            new moodle1_course_header_handler($converter),
            new moodle1_course_outline_handler($converter),
            new moodle1_roles_definition_handler($converter),
            new moodle1_question_bank_handler($converter),
            new moodle1_scales_handler($converter),
            new moodle1_outcomes_handler($converter),
            new moodle1_gradebook_handler($converter),
        );

        $handlers = array_merge($handlers, self::get_plugin_handlers('mod', $converter));
        $handlers = array_merge($handlers, self::get_plugin_handlers('block', $converter));

        // make sure that all handlers have expected class
        foreach ($handlers as $handler) {
            if (!$handler instanceof moodle1_handler) {
                throw new moodle1_convert_exception('wrong_handler_class', get_class($handler));
            }
        }

        return $handlers;
    }

    /// public API ends here ///////////////////////////////////////////////////

    /**
     * Runs through all plugins of a specific type and instantiates their handlers
     *
     * @todo ask mod's subplugins
     * @param string $type the plugin type
     * @param moodle1_converter $converter the converter requesting the handler
     * @throws moodle1_convert_exception
     * @return array of {@link moodle1_handler} instances
     */
    protected static function get_plugin_handlers($type, moodle1_converter $converter) {
        global $CFG;

        $handlers = array();
        $plugins = core_component::get_plugin_list($type);
        foreach ($plugins as $name => $dir) {
            $handlerfile  = $dir . '/backup/moodle1/lib.php';
            $handlerclass = "moodle1_{$type}_{$name}_handler";
            if (file_exists($handlerfile)) {
                require_once($handlerfile);
            } elseif ($type == 'block') {
                $handlerclass = "moodle1_block_generic_handler";
            } else {
                continue;
            }

            if (!class_exists($handlerclass)) {
                throw new moodle1_convert_exception('missing_handler_class', $handlerclass);
            }
            $handlers[] = new $handlerclass($converter, $type, $name);
        }
        return $handlers;
    }
}


/**
 * Base backup conversion handler
 */
abstract class moodle1_handler implements loggable {

    /** @var moodle1_converter */
    protected $converter;

    /**
     * @param moodle1_converter $converter the converter that requires us
     */
    public function __construct(moodle1_converter $converter) {
        $this->converter = $converter;
    }

    /**
     * @return moodle1_converter the converter that required this handler
     */
    public function get_converter() {
        return $this->converter;
    }

    /**
     * Log a message using the converter's logging mechanism
     *
     * @param string $message message text
     * @param int $level message level {@example backup::LOG_WARNING}
     * @param null|mixed $a additional information
     * @param null|int $depth the message depth
     * @param bool $display whether the message should be sent to the output, too
     */
    public function log($message, $level, $a = null, $depth = null, $display = false) {
        $this->converter->log($message, $level, $a, $depth, $display);
    }
}


/**
 * Base backup conversion handler that generates an XML file
 */
abstract class moodle1_xml_handler extends moodle1_handler {

    /** @var null|string the name of file we are writing to */
    protected $xmlfilename;

    /** @var null|xml_writer */
    protected $xmlwriter;

    /**
     * Opens the XML writer - after calling, one is free to use $xmlwriter
     *
     * @param string $filename XML file name to write into
     * @return void
     */
    protected function open_xml_writer($filename) {

        if (!is_null($this->xmlfilename) and $filename !== $this->xmlfilename) {
            throw new moodle1_convert_exception('xml_writer_already_opened_for_other_file', $this->xmlfilename);
        }

        if (!$this->xmlwriter instanceof xml_writer) {
            $this->xmlfilename = $filename;
            $fullpath  = $this->converter->get_workdir_path() . '/' . $this->xmlfilename;
            $directory = pathinfo($fullpath, PATHINFO_DIRNAME);

            if (!check_dir_exists($directory)) {
                throw new moodle1_convert_exception('unable_create_target_directory', $directory);
            }
            $this->xmlwriter = new xml_writer(new file_xml_output($fullpath), new moodle1_xml_transformer());
            $this->xmlwriter->start();
        }
    }

    /**
     * Close the XML writer
     *
     * At the moment, the caller must close all tags before calling
     *
     * @return void
     */
    protected function close_xml_writer() {
        if ($this->xmlwriter instanceof xml_writer) {
            $this->xmlwriter->stop();
        }
        unset($this->xmlwriter);
        $this->xmlwriter = null;
        $this->xmlfilename = null;
    }

    /**
     * Checks if the XML writer has been opened by {@link self::open_xml_writer()}
     *
     * @return bool
     */
    protected function has_xml_writer() {

        if ($this->xmlwriter instanceof xml_writer) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Writes the given XML tree data into the currently opened file
     *
     * @param string $element the name of the root element of the tree
     * @param array $data the associative array of data to write
     * @param array $attribs list of additional fields written as attributes instead of nested elements
     * @param string $parent used internally during the recursion, do not set yourself
     */
    protected function write_xml($element, array $data, array $attribs = array(), $parent = '/') {

        if (!$this->has_xml_writer()) {
            throw new moodle1_convert_exception('write_xml_without_writer');
        }

        $mypath    = $parent . $element;
        $myattribs = array();

        // detect properties that should be rendered as element's attributes instead of children
        foreach ($data as $name => $value) {
            if (!is_array($value)) {
                if (in_array($mypath . '/' . $name, $attribs)) {
                    $myattribs[$name] = $value;
                    unset($data[$name]);
                }
            }
        }

        // reorder the $data so that all sub-branches are at the end (needed by our parser)
        $leaves   = array();
        $branches = array();
        foreach ($data as $name => $value) {
            if (is_array($value)) {
                $branches[$name] = $value;
            } else {
                $leaves[$name] = $value;
            }
        }
        $data = array_merge($leaves, $branches);

        $this->xmlwriter->begin_tag($element, $myattribs);

        foreach ($data as $name => $value) {
            if (is_array($value)) {
                // recursively call self
                $this->write_xml($name, $value, $attribs, $mypath.'/');
            } else {
                $this->xmlwriter->full_tag($name, $value);
            }
        }

        $this->xmlwriter->end_tag($element);
    }

    /**
     * Makes sure that a new XML file exists, or creates it itself
     *
     * This is here so we can check that all XML files that the restore process relies on have
     * been created by an executed handler. If the file is not found, this method can create it
     * using the given $rootelement as an empty root container in the file.
     *
     * @param string $filename relative file name like 'course/course.xml'
     * @param string|bool $rootelement root element to use, false to not create the file
     * @param array $content content of the root element
     * @return bool true is the file existed, false if it did not
     */
    protected function make_sure_xml_exists($filename, $rootelement = false, $content = array()) {

        $existed = file_exists($this->converter->get_workdir_path().'/'.$filename);

        if ($existed) {
            return true;
        }

        if ($rootelement !== false) {
            $this->open_xml_writer($filename);
            $this->write_xml($rootelement, $content);
            $this->close_xml_writer();
        }

        return false;
    }
}


/**
 * Process the root element of the backup file
 */
class moodle1_root_handler extends moodle1_xml_handler {

    public function get_paths() {
        return array(new convert_path('root_element', '/MOODLE_BACKUP'));
    }

    /**
     * Converts course_files and site_files
     */
    public function on_root_element_start() {

        // convert course files
        $fileshandler = new moodle1_files_handler($this->converter);
        $fileshandler->process();
    }

    /**
     * This is executed at the end of the moodle.xml parsing
     */
    public function on_root_element_end() {
        global $CFG;

        // restore the stashes prepared by other handlers for us
        $backupinfo         = $this->converter->get_stash('backup_info');
        $originalcourseinfo = $this->converter->get_stash('original_course_info');

        ////////////////////////////////////////////////////////////////////////
        // write moodle_backup.xml
        ////////////////////////////////////////////////////////////////////////
        $this->open_xml_writer('moodle_backup.xml');

        $this->xmlwriter->begin_tag('moodle_backup');
        $this->xmlwriter->begin_tag('information');

        // moodle_backup/information
        $this->xmlwriter->full_tag('name', $backupinfo['name']);
        $this->xmlwriter->full_tag('moodle_version', $backupinfo['moodle_version']);
        $this->xmlwriter->full_tag('moodle_release', $backupinfo['moodle_release']);
        $this->xmlwriter->full_tag('backup_version', $CFG->backup_version); // {@see restore_prechecks_helper::execute_prechecks}
        $this->xmlwriter->full_tag('backup_release', $CFG->backup_release);
        $this->xmlwriter->full_tag('backup_date', $backupinfo['date']);
        // see the commit c0543b - all backups created in 1.9 and later declare the
        // information or it is considered as false
        if (isset($backupinfo['mnet_remoteusers'])) {
            $this->xmlwriter->full_tag('mnet_remoteusers', $backupinfo['mnet_remoteusers']);
        } else {
            $this->xmlwriter->full_tag('mnet_remoteusers', false);
        }
        $this->xmlwriter->full_tag('original_wwwroot', $backupinfo['original_wwwroot']);
        // {@see backup_general_helper::backup_is_samesite()}
        if (isset($backupinfo['original_site_identifier_hash'])) {
            $this->xmlwriter->full_tag('original_site_identifier_hash', $backupinfo['original_site_identifier_hash']);
        } else {
            $this->xmlwriter->full_tag('original_site_identifier_hash', null);
        }
        $this->xmlwriter->full_tag('original_course_id', $originalcourseinfo['original_course_id']);
        $this->xmlwriter->full_tag('original_course_fullname', $originalcourseinfo['original_course_fullname']);
        $this->xmlwriter->full_tag('original_course_shortname', $originalcourseinfo['original_course_shortname']);
        $this->xmlwriter->full_tag('original_course_startdate', $originalcourseinfo['original_course_startdate']);
        $this->xmlwriter->full_tag('original_system_contextid', $this->converter->get_contextid(CONTEXT_SYSTEM));
        // note that even though we have original_course_contextid available, we regenerate the
        // original course contextid using our helper method to be sure that the data are consistent
        // within the MBZ file
        $this->xmlwriter->full_tag('original_course_contextid', $this->converter->get_contextid(CONTEXT_COURSE));

        // moodle_backup/information/details
        $this->xmlwriter->begin_tag('details');
        $this->write_xml('detail', array(
            'backup_id'     => $this->converter->get_id(),
            'type'          => backup::TYPE_1COURSE,
            'format'        => backup::FORMAT_MOODLE,
            'interactive'   => backup::INTERACTIVE_YES,
            'mode'          => backup::MODE_CONVERTED,
            'execution'     => backup::EXECUTION_INMEDIATE,
            'executiontime' => 0,
        ), array('/detail/backup_id'));
        $this->xmlwriter->end_tag('details');

        // moodle_backup/information/contents
        $this->xmlwriter->begin_tag('contents');

        // moodle_backup/information/contents/activities
        $this->xmlwriter->begin_tag('activities');
        $activitysettings = array();
        foreach ($this->converter->get_stash('coursecontents') as $activity) {
            $modinfo = $this->converter->get_stash('modinfo_'.$activity['modulename']);
            $modinstance = $modinfo['instances'][$activity['instanceid']];
            $this->write_xml('activity', array(
                'moduleid'      => $activity['cmid'],
                'sectionid'     => $activity['sectionid'],
                'modulename'    => $activity['modulename'],
                'title'         => $modinstance['name'],
                'directory'     => 'activities/'.$activity['modulename'].'_'.$activity['cmid']
            ));
            $activitysettings[] = array(
                'level'     => 'activity',
                'activity'  => $activity['modulename'].'_'.$activity['cmid'],
                'name'      => $activity['modulename'].'_'.$activity['cmid'].'_included',
                'value'     => (($modinfo['included'] === 'true' and $modinstance['included'] === 'true') ? 1 : 0));
            $activitysettings[] = array(
                'level'     => 'activity',
                'activity'  => $activity['modulename'].'_'.$activity['cmid'],
                'name'      => $activity['modulename'].'_'.$activity['cmid'].'_userinfo',
                //'value'     => (($modinfo['userinfo'] === 'true' and $modinstance['userinfo'] === 'true') ? 1 : 0));
                'value'     => 0); // todo hardcoded non-userinfo for now
        }
        $this->xmlwriter->end_tag('activities');

        // moodle_backup/information/contents/sections
        $this->xmlwriter->begin_tag('sections');
        $sectionsettings = array();
        foreach ($this->converter->get_stash_itemids('sectioninfo') as $sectionid) {
            $sectioninfo = $this->converter->get_stash('sectioninfo', $sectionid);
            $sectionsettings[] = array(
                'level'     => 'section',
                'section'   => 'section_'.$sectionid,
                'name'      => 'section_'.$sectionid.'_included',
                'value'     => 1);
            $sectionsettings[] = array(
                'level'     => 'section',
                'section'   => 'section_'.$sectionid,
                'name'      => 'section_'.$sectionid.'_userinfo',
                'value'     => 0); // @todo how to detect this from moodle.xml?
            $this->write_xml('section', array(
                'sectionid' => $sectionid,
                'title'     => $sectioninfo['number'], // because the title is not available
                'directory' => 'sections/section_'.$sectionid));
        }
        $this->xmlwriter->end_tag('sections');

        // moodle_backup/information/contents/course
        $this->write_xml('course', array(
            'courseid'  => $originalcourseinfo['original_course_id'],
            'title'     => $originalcourseinfo['original_course_shortname'],
            'directory' => 'course'));
        unset($originalcourseinfo);

        $this->xmlwriter->end_tag('contents');

        // moodle_backup/information/settings
        $this->xmlwriter->begin_tag('settings');

        // fake backup root seetings
        $rootsettings = array(
            'filename'         => $backupinfo['name'],
            'users'            => 0, // @todo how to detect this from moodle.xml?
            'anonymize'        => 0,
            'role_assignments' => 0,
            'activities'       => 1,
            'blocks'           => 1,
            'filters'          => 0,
            'comments'         => 0,
            'userscompletion'  => 0,
            'logs'             => 0,
            'grade_histories'  => 0,
        );
        unset($backupinfo);
        foreach ($rootsettings as $name => $value) {
            $this->write_xml('setting', array(
                'level' => 'root',
                'name'  => $name,
                'value' => $value));
        }
        unset($rootsettings);

        // activity settings populated above
        foreach ($activitysettings as $activitysetting) {
            $this->write_xml('setting', $activitysetting);
        }
        unset($activitysettings);

        // section settings populated above
        foreach ($sectionsettings as $sectionsetting) {
            $this->write_xml('setting', $sectionsetting);
        }
        unset($sectionsettings);

        $this->xmlwriter->end_tag('settings');

        $this->xmlwriter->end_tag('information');
        $this->xmlwriter->end_tag('moodle_backup');

        $this->close_xml_writer();

        ////////////////////////////////////////////////////////////////////////
        // write files.xml
        ////////////////////////////////////////////////////////////////////////
        $this->open_xml_writer('files.xml');
        $this->xmlwriter->begin_tag('files');
        foreach ($this->converter->get_stash_itemids('files') as $fileid) {
            $this->write_xml('file', $this->converter->get_stash('files', $fileid), array('/file/id'));
        }
        $this->xmlwriter->end_tag('files');
        $this->close_xml_writer('files.xml');

        ////////////////////////////////////////////////////////////////////////
        // write scales.xml
        ////////////////////////////////////////////////////////////////////////
        $this->open_xml_writer('scales.xml');
        $this->xmlwriter->begin_tag('scales_definition');
        foreach ($this->converter->get_stash_itemids('scales') as $scaleid) {
            $this->write_xml('scale', $this->converter->get_stash('scales', $scaleid), array('/scale/id'));
        }
        $this->xmlwriter->end_tag('scales_definition');
        $this->close_xml_writer('scales.xml');

        ////////////////////////////////////////////////////////////////////////
        // write course/inforef.xml
        ////////////////////////////////////////////////////////////////////////
        $this->open_xml_writer('course/inforef.xml');
        $this->xmlwriter->begin_tag('inforef');

        $this->xmlwriter->begin_tag('fileref');
        // legacy course files
        $fileids = $this->converter->get_stash('course_files_ids');
        if (is_array($fileids)) {
            foreach ($fileids as $fileid) {
                $this->write_xml('file', array('id' => $fileid));
            }
        }
        // todo site files
        // course summary files
        $fileids = $this->converter->get_stash('course_summary_files_ids');
        if (is_array($fileids)) {
            foreach ($fileids as $fileid) {
                $this->write_xml('file', array('id' => $fileid));
            }
        }
        $this->xmlwriter->end_tag('fileref');

        $this->xmlwriter->begin_tag('question_categoryref');
        foreach ($this->converter->get_stash_itemids('question_categories') as $questioncategoryid) {
            $this->write_xml('question_category', array('id' => $questioncategoryid));
        }
        $this->xmlwriter->end_tag('question_categoryref');

        $this->xmlwriter->end_tag('inforef');
        $this->close_xml_writer();

        // make sure that the files required by the restore process have been generated.
        // missing file may happen if the watched tag is not present in moodle.xml (for example
        // QUESTION_CATEGORIES is optional in moodle.xml but questions.xml must exist in
        // moodle2 format) or the handler has not been implemented yet.
        // apparently this must be called after the handler had a chance to create the file.
        $this->make_sure_xml_exists('questions.xml', 'question_categories');
        $this->make_sure_xml_exists('groups.xml', 'groups');
        $this->make_sure_xml_exists('outcomes.xml', 'outcomes_definition');
        $this->make_sure_xml_exists('users.xml', 'users');
        $this->make_sure_xml_exists('course/roles.xml', 'roles',
            array('role_assignments' => array(), 'role_overrides' => array()));
        $this->make_sure_xml_exists('course/enrolments.xml', 'enrolments',
            array('enrols' => array()));
    }
}


/**
 * The class responsible for course and site files migration
 *
 * @todo migrate site_files
 */
class moodle1_files_handler extends moodle1_xml_handler {

    /**
     * Migrates course_files and site_files in the converter workdir
     */
    public function process() {
        $this->migrate_course_files();
        // todo $this->migrate_site_files();
    }

    /**
     * Migrates course_files in the converter workdir
     */
    protected function migrate_course_files() {
        $ids  = array();
        $fileman = $this->converter->get_file_manager($this->converter->get_contextid(CONTEXT_COURSE), 'course', 'legacy');
        $this->converter->set_stash('course_files_ids', array());
        if (file_exists($this->converter->get_tempdir_path().'/course_files')) {
            $ids = $fileman->migrate_directory('course_files');
            $this->converter->set_stash('course_files_ids', $ids);
        }
        $this->log('course files migrated', backup::LOG_INFO, count($ids));
    }
}


/**
 * Handles the conversion of /MOODLE_BACKUP/INFO paths
 *
 * We do not produce any XML file here, just storing the data in the temp
 * table so thay can be used by a later handler.
 */
class moodle1_info_handler extends moodle1_handler {

    /** @var array list of mod names included in info_details */
    protected $modnames = array();

    /** @var array the in-memory cache of the currently parsed info_details_mod element */
    protected $currentmod;

    public function get_paths() {
        return array(
            new convert_path('info', '/MOODLE_BACKUP/INFO'),
            new convert_path('info_details', '/MOODLE_BACKUP/INFO/DETAILS'),
            new convert_path('info_details_mod', '/MOODLE_BACKUP/INFO/DETAILS/MOD'),
            new convert_path('info_details_mod_instance', '/MOODLE_BACKUP/INFO/DETAILS/MOD/INSTANCES/INSTANCE'),
        );
    }

    /**
     * Stashes the backup info for later processing by {@link moodle1_root_handler}
     */
    public function process_info($data) {
        $this->converter->set_stash('backup_info', $data);
    }

    /**
     * Initializes the in-memory cache for the current mod
     */
    public function process_info_details_mod($data) {
        $this->currentmod = $data;
        $this->currentmod['instances'] = array();
    }

    /**
     * Appends the current instance data to the temporary in-memory cache
     */
    public function process_info_details_mod_instance($data) {
        $this->currentmod['instances'][$data['id']] = $data;
    }

    /**
     * Stashes the backup info for later processing by {@link moodle1_root_handler}
     */
    public function on_info_details_mod_end($data) {
        global $CFG;

        // keep only such modules that seem to have the support for moodle1 implemented
        $modname = $this->currentmod['name'];
        if (file_exists($CFG->dirroot.'/mod/'.$modname.'/backup/moodle1/lib.php')) {
            $this->converter->set_stash('modinfo_'.$modname, $this->currentmod);
            $this->modnames[] = $modname;
        } else {
            $this->log('unsupported activity module', backup::LOG_WARNING, $modname);
        }

        $this->currentmod = array();
    }

    /**
     * Stashes the list of activity module types for later processing by {@link moodle1_root_handler}
     */
    public function on_info_details_end() {
        $this->converter->set_stash('modnameslist', $this->modnames);
    }
}


/**
 * Handles the conversion of /MOODLE_BACKUP/COURSE/HEADER paths
 */
class moodle1_course_header_handler extends moodle1_xml_handler {

    /** @var array we need to merge course information because it is dispatched twice */
    protected $course = array();

    /** @var array we need to merge course information because it is dispatched twice */
    protected $courseraw = array();

    /** @var array */
    protected $category;

    public function get_paths() {
        return array(
            new convert_path(
                'course_header', '/MOODLE_BACKUP/COURSE/HEADER',
                array(
                    'newfields' => array(
                        'summaryformat'          => 1,
                        'legacyfiles'            => 2,
                        'requested'              => 0, // @todo not really new, but maybe never backed up?
                        'restrictmodules'        => 0,
                        'enablecompletion'       => 0,
                        'completionstartonenrol' => 0,
                        'completionnotify'       => 0,
                        'tags'                   => array(),
                        'allowed_modules'        => array(),
                    ),
                    'dropfields' => array(
                        'roles_overrides',
                        'roles_assignments',
                        'cost',
                        'currancy',
                        'defaultrole',
                        'enrol',
                        'enrolenddate',
                        'enrollable',
                        'enrolperiod',
                        'enrolstartdate',
                        'expirynotify',
                        'expirythreshold',
                        'guest',
                        'notifystudents',
                        'password',
                        'student',
                        'students',
                        'teacher',
                        'teachers',
                        'metacourse',
                    )
                )
            ),
            new convert_path(
                'course_header_category', '/MOODLE_BACKUP/COURSE/HEADER/CATEGORY',
                array(
                    'newfields' => array(
                        'description' => null,
                    )
                )
            ),
        );
    }

    /**
     * Because there is the CATEGORY branch in the middle of the COURSE/HEADER
     * branch, this is dispatched twice. We use $this->coursecooked to merge
     * the result. Once the parser is fixed, it can be refactored.
     */
    public function process_course_header($data, $raw) {
       $this->course    = array_merge($this->course, $data);
       $this->courseraw = array_merge($this->courseraw, $raw);
    }

    public function process_course_header_category($data) {
        $this->category = $data;
    }

    public function on_course_header_end() {

        $contextid = $this->converter->get_contextid(CONTEXT_COURSE);

        // stash the information needed by other handlers
        $info = array(
            'original_course_id'        => $this->course['id'],
            'original_course_fullname'  => $this->course['fullname'],
            'original_course_shortname' => $this->course['shortname'],
            'original_course_startdate' => $this->course['startdate'],
            'original_course_contextid' => $contextid
        );
        $this->converter->set_stash('original_course_info', $info);

        $this->course['contextid'] = $contextid;
        $this->course['category'] = $this->category;

        // migrate files embedded into the course summary and stash their ids
        $fileman = $this->converter->get_file_manager($contextid, 'course', 'summary');
        $this->course['summary'] = moodle1_converter::migrate_referenced_files($this->course['summary'], $fileman);
        $this->converter->set_stash('course_summary_files_ids', $fileman->get_fileids());

        // write course.xml
        $this->open_xml_writer('course/course.xml');
        $this->write_xml('course', $this->course, array('/course/id', '/course/contextid'));
        $this->close_xml_writer();
    }
}


/**
 * Handles the conversion of course sections and course modules
 */
class moodle1_course_outline_handler extends moodle1_xml_handler {

    /** @var array ordered list of the course contents */
    protected $coursecontents = array();

    /** @var array current section data */
    protected $currentsection;

    /**
     * This handler is interested in course sections and course modules within them
     */
    public function get_paths() {
        return array(
            new convert_path('course_sections', '/MOODLE_BACKUP/COURSE/SECTIONS'),
            new convert_path(
                'course_section', '/MOODLE_BACKUP/COURSE/SECTIONS/SECTION',
                array(
                    'newfields' => array(
                        'name'          => null,
                        'summaryformat' => 1,
                        'sequence'      => null,
                    ),
                )
            ),
            new convert_path(
                'course_module', '/MOODLE_BACKUP/COURSE/SECTIONS/SECTION/MODS/MOD',
                array(
                    'newfields' => array(
                        'completion'                => 0,
                        'completiongradeitemnumber' => null,
                        'completionview'            => 0,
                        'completionexpected'        => 0,
                        'availability'              => null,
                        'visibleold'                => 1,
                        'showdescription'           => 0,
                    ),
                    'dropfields' => array(
                        'instance',
                        'roles_overrides',
                        'roles_assignments',
                    ),
                    'renamefields' => array(
                        'type' => 'modulename',
                    ),
                )
            ),
            new convert_path('course_modules', '/MOODLE_BACKUP/COURSE/MODULES'),
            // todo new convert_path('course_module_roles_overrides', '/MOODLE_BACKUP/COURSE/SECTIONS/SECTION/MODS/MOD/ROLES_OVERRIDES'),
            // todo new convert_path('course_module_roles_assignments', '/MOODLE_BACKUP/COURSE/SECTIONS/SECTION/MODS/MOD/ROLES_ASSIGNMENTS'),
        );
    }

    public function process_course_section($data) {
        $this->currentsection = $data;
    }

    /**
     * Populates the section sequence field (order of course modules) and stashes the
     * course module info so that is can be dumped to activities/xxxx_x/module.xml later
     */
    public function process_course_module($data, $raw) {
        global $CFG;

        // check that this type of module should be included in the mbz
        $modinfo = $this->converter->get_stash_itemids('modinfo_'.$data['modulename']);
        if (empty($modinfo)) {
            return;
        }

        // add the course module into the course contents list
        $this->coursecontents[$data['id']] = array(
            'cmid'       => $data['id'],
            'instanceid' => $raw['INSTANCE'],
            'sectionid'  => $this->currentsection['id'],
            'modulename' => $data['modulename'],
            'title'      => null
        );

        // add the course module id into the section's sequence
        if (is_null($this->currentsection['sequence'])) {
            $this->currentsection['sequence'] = $data['id'];
        } else {
            $this->currentsection['sequence'] .= ',' . $data['id'];
        }

        // add the sectionid and sectionnumber
        $data['sectionid']      = $this->currentsection['id'];
        $data['sectionnumber']  = $this->currentsection['number'];

        // generate the module version - this is a bit tricky as this information
        // is not present in 1.9 backups. we will use the currently installed version
        // whenever we can but that might not be accurate for some modules.
        // also there might be problem with modules that are not present at the target
        // host...
        $versionfile = $CFG->dirroot.'/mod/'.$data['modulename'].'/version.php';
        if (file_exists($versionfile)) {
            $plugin = new stdClass();
            $plugin->version = null;
            $module = $plugin;
            include($versionfile);
< $data['version'] = $plugin->version;
> // Have to hardcode - since quiz uses some hardcoded version numbers when restoring. > // This is the lowest number used minus one. > $data['version'] = 2011010099;
} else { $data['version'] = null; } // stash the course module info in stashes like 'cminfo_forum' with // itemid set to the instance id. this is needed so that module handlers // can later obtain information about the course module and dump it into // the module.xml file $this->converter->set_stash('cminfo_'.$data['modulename'], $data, $raw['INSTANCE']); } /** * Writes sections/section_xxx/section.xml file and stashes it, too */ public function on_course_section_end() { // migrate files embedded into the section summary field $contextid = $this->converter->get_contextid(CONTEXT_COURSE); $fileman = $this->converter->get_file_manager($contextid, 'course', 'section', $this->currentsection['id']); $this->currentsection['summary'] = moodle1_converter::migrate_referenced_files($this->currentsection['summary'], $fileman); // write section's inforef.xml with the file references $this->open_xml_writer('sections/section_' . $this->currentsection['id'] . '/inforef.xml'); $this->xmlwriter->begin_tag('inforef'); $this->xmlwriter->begin_tag('fileref'); $fileids = $fileman->get_fileids(); if (is_array($fileids)) { foreach ($fileids as $fileid) { $this->write_xml('file', array('id' => $fileid)); } } $this->xmlwriter->end_tag('fileref'); $this->xmlwriter->end_tag('inforef'); $this->close_xml_writer(); // stash the section info and write section.xml $this->converter->set_stash('sectioninfo', $this->currentsection, $this->currentsection['id']); $this->open_xml_writer('sections/section_' . $this->currentsection['id'] . '/section.xml'); $this->write_xml('section', $this->currentsection); $this->close_xml_writer(); unset($this->currentsection); } /** * Stashes the course contents */ public function on_course_sections_end() { $this->converter->set_stash('coursecontents', $this->coursecontents); } /** * Writes the information collected by mod handlers */ public function on_course_modules_end() { foreach ($this->converter->get_stash('modnameslist') as $modname) { $modinfo = $this->converter->get_stash('modinfo_'.$modname); foreach ($modinfo['instances'] as $modinstanceid => $modinstance) { $cminfo = $this->converter->get_stash('cminfo_'.$modname, $modinstanceid); $directory = 'activities/'.$modname.'_'.$cminfo['id']; // write module.xml $this->open_xml_writer($directory.'/module.xml'); $this->write_xml('module', $cminfo, array('/module/id', '/module/version')); $this->close_xml_writer(); // write grades.xml $this->open_xml_writer($directory.'/grades.xml'); $this->xmlwriter->begin_tag('activity_gradebook'); $gradeitems = $this->converter->get_stash_or_default('gradebook_modgradeitem_'.$modname, $modinstanceid, array()); if (!empty($gradeitems)) { $this->xmlwriter->begin_tag('grade_items'); foreach ($gradeitems as $gradeitem) { $this->write_xml('grade_item', $gradeitem, array('/grade_item/id')); } $this->xmlwriter->end_tag('grade_items'); } $this->write_xml('grade_letters', array()); // no grade_letters in module context in Moodle 1.9 $this->xmlwriter->end_tag('activity_gradebook'); $this->close_xml_writer(); // todo: write proper roles.xml, for now we just make sure the file is present $this->make_sure_xml_exists($directory.'/roles.xml', 'roles'); } } } } /** * Handles the conversion of the defined roles */ class moodle1_roles_definition_handler extends moodle1_xml_handler { /** * Where the roles are defined in the source moodle.xml */ public function get_paths() { return array( new convert_path('roles', '/MOODLE_BACKUP/ROLES'), new convert_path( 'roles_role', '/MOODLE_BACKUP/ROLES/ROLE', array( 'newfields' => array( 'description' => '', 'sortorder' => 0, 'archetype' => '' ) ) ) ); } /** * If there are any roles defined in moodle.xml, convert them to roles.xml */ public function process_roles_role($data) { if (!$this->has_xml_writer()) { $this->open_xml_writer('roles.xml'); $this->xmlwriter->begin_tag('roles_definition'); } if (!isset($data['nameincourse'])) { $data['nameincourse'] = null; } $this->write_xml('role', $data, array('role/id')); } /** * Finishes writing roles.xml */ public function on_roles_end() { if (!$this->has_xml_writer()) { // no roles defined in moodle.xml so {link self::process_roles_role()} // was never executed $this->open_xml_writer('roles.xml'); $this->write_xml('roles_definition', array()); } else { // some roles were dumped into the file, let us close their wrapper now $this->xmlwriter->end_tag('roles_definition'); } $this->close_xml_writer(); } } /** * Handles the conversion of the question bank included in the moodle.xml file */ class moodle1_question_bank_handler extends moodle1_xml_handler { /** @var array the current question category being parsed */ protected $currentcategory = null; /** @var array of the raw data for the current category */ protected $currentcategoryraw = null; /** @var moodle1_file_manager instance used to convert question images */ protected $fileman = null; /** @var bool are the currentcategory data already written (this is a work around MDL-27693) */ private $currentcategorywritten = false; /** @var bool was the <questions> tag already written (work around MDL-27693) */ private $questionswrapperwritten = false; /** @var array holds the instances of qtype specific conversion handlers */ private $qtypehandlers = null; /** * Return the file manager instance used. * * @return moodle1_file_manager */ public function get_file_manager() { return $this->fileman; } /** * Returns the information about the question category context being currently parsed * * @return array with keys contextid, contextlevel and contextinstanceid */ public function get_current_category_context() { return $this->currentcategory; } /** * Registers path that are not qtype-specific */ public function get_paths() { $paths = array( new convert_path('question_categories', '/MOODLE_BACKUP/COURSE/QUESTION_CATEGORIES'), new convert_path( 'question_category', '/MOODLE_BACKUP/COURSE/QUESTION_CATEGORIES/QUESTION_CATEGORY', array( 'newfields' => array( 'infoformat' => 0 ) )), new convert_path('question_category_context', '/MOODLE_BACKUP/COURSE/QUESTION_CATEGORIES/QUESTION_CATEGORY/CONTEXT'), new convert_path('questions', '/MOODLE_BACKUP/COURSE/QUESTION_CATEGORIES/QUESTION_CATEGORY/QUESTIONS'), // the question element must be grouped so we can re-dispatch it to the qtype handler as a whole new convert_path('question', '/MOODLE_BACKUP/COURSE/QUESTION_CATEGORIES/QUESTION_CATEGORY/QUESTIONS/QUESTION', array(), true), ); // annotate all question subpaths required by the qtypes subplugins $subpaths = array(); foreach ($this->get_qtype_handler('*') as $qtypehandler) { foreach ($qtypehandler->get_question_subpaths() as $subpath) { $subpaths[$subpath] = true; } } foreach (array_keys($subpaths) as $subpath) { $name = 'subquestion_'.strtolower(str_replace('/', '_', $subpath)); $path = '/MOODLE_BACKUP/COURSE/QUESTION_CATEGORIES/QUESTION_CATEGORY/QUESTIONS/QUESTION/'.$subpath; $paths[] = new convert_path($name, $path); } return $paths; } /** * Starts writing questions.xml and prepares the file manager instance */ public function on_question_categories_start() { $this->open_xml_writer('questions.xml'); $this->xmlwriter->begin_tag('question_categories'); if (is_null($this->fileman)) { $this->fileman = $this->converter->get_file_manager(); } } /** * Initializes the current category cache */ public function on_question_category_start() { $this->currentcategory = array(); $this->currentcategoryraw = array(); $this->currentcategorywritten = false; $this->questionswrapperwritten = false; } /** * Populates the current question category data * * Bacuse of the known subpath-in-the-middle problem (CONTEXT in this case), this is actually * called twice for both halves of the data. We merge them here into the currentcategory array. */ public function process_question_category($data, $raw) { $this->currentcategory = array_merge($this->currentcategory, $data); $this->currentcategoryraw = array_merge($this->currentcategoryraw, $raw); } /** * Inject the context related information into the current category */ public function process_question_category_context($data) { switch ($data['level']) { case 'module': $this->currentcategory['contextid'] = $this->converter->get_contextid(CONTEXT_MODULE, $data['instance']); $this->currentcategory['contextlevel'] = CONTEXT_MODULE; $this->currentcategory['contextinstanceid'] = $data['instance']; break; case 'course': $originalcourseinfo = $this->converter->get_stash('original_course_info'); $originalcourseid = $originalcourseinfo['original_course_id']; $this->currentcategory['contextid'] = $this->converter->get_contextid(CONTEXT_COURSE); $this->currentcategory['contextlevel'] = CONTEXT_COURSE; $this->currentcategory['contextinstanceid'] = $originalcourseid; break; case 'coursecategory': // this is a bit hacky. the source moodle.xml defines COURSECATEGORYLEVEL as a distance // of the course category (1 = parent category, 2 = grand-parent category etc). We pretend // that this level*10 is the id of that category and create an artifical contextid for it $this->currentcategory['contextid'] = $this->converter->get_contextid(CONTEXT_COURSECAT, $data['coursecategorylevel'] * 10); $this->currentcategory['contextlevel'] = CONTEXT_COURSECAT; $this->currentcategory['contextinstanceid'] = $data['coursecategorylevel'] * 10; break; case 'system': $this->currentcategory['contextid'] = $this->converter->get_contextid(CONTEXT_SYSTEM); $this->currentcategory['contextlevel'] = CONTEXT_SYSTEM; $this->currentcategory['contextinstanceid'] = 0; break; } } /** * Writes the common <question> data and re-dispateches the whole grouped * <QUESTION> data to the qtype for appending its qtype specific data processing * * @param array $data * @param array $raw * @return array */ public function process_question(array $data, array $raw) { global $CFG; // firstly make sure that the category data and the <questions> wrapper are written // note that because of MDL-27693 we can't use {@link self::process_question_category()} // and {@link self::on_questions_start()} to do so if (empty($this->currentcategorywritten)) { $this->xmlwriter->begin_tag('question_category', array('id' => $this->currentcategory['id'])); foreach ($this->currentcategory as $name => $value) { if ($name === 'id') { continue; } $this->xmlwriter->full_tag($name, $value); } $this->currentcategorywritten = true; } if (empty($this->questionswrapperwritten)) { $this->xmlwriter->begin_tag('questions'); $this->questionswrapperwritten = true; } $qtype = $data['qtype']; // replay the upgrade step 2008050700 {@see question_fix_random_question_parents()} if ($qtype == 'random' and $data['parent'] <> $data['id']) { $data['parent'] = $data['id']; } // replay the upgrade step 2010080900 and part of 2010080901 $data['generalfeedbackformat'] = $data['questiontextformat']; $data['oldquestiontextformat'] = $data['questiontextformat']; if ($CFG->texteditors !== 'textarea') { $data['questiontext'] = text_to_html($data['questiontext'], false, false, true); $data['questiontextformat'] = FORMAT_HTML; $data['generalfeedback'] = text_to_html($data['generalfeedback'], false, false, true); $data['generalfeedbackformat'] = FORMAT_HTML; } // Migrate files in questiontext. $this->fileman->contextid = $this->currentcategory['contextid']; $this->fileman->component = 'question'; $this->fileman->filearea = 'questiontext'; $this->fileman->itemid = $data['id']; $data['questiontext'] = moodle1_converter::migrate_referenced_files($data['questiontext'], $this->fileman); // Migrate files in generalfeedback. $this->fileman->filearea = 'generalfeedback'; $data['generalfeedback'] = moodle1_converter::migrate_referenced_files($data['generalfeedback'], $this->fileman); // replay the upgrade step 2010080901 - updating question image if (!empty($data['image'])) { if (core_text::substr(core_text::strtolower($data['image']), 0, 7) == 'http://') { // it is a link, appending to existing question text $data['questiontext'] .= ' <img src="' . $data['image'] . '" />'; } else { // it is a file in course_files $filename = basename($data['image']); $filepath = dirname($data['image']); if (empty($filepath) or $filepath == '.' or $filepath == '/') { $filepath = '/'; } else { // append / $filepath = '/'.trim($filepath, './@#$ ').'/'; } if (file_exists($this->converter->get_tempdir_path().'/course_files'.$filepath.$filename)) { $this->fileman->contextid = $this->currentcategory['contextid']; $this->fileman->component = 'question'; $this->fileman->filearea = 'questiontext'; $this->fileman->itemid = $data['id']; $this->fileman->migrate_file('course_files'.$filepath.$filename, '/', $filename); // note this is slightly different from the upgrade code as we put the file into the // root folder here. this makes our life easier as we do not need to create all the // directories within the specified filearea/itemid $data['questiontext'] .= ' <img src="@@PLUGINFILE@@/' . $filename . '" />'; } else { $this->log('question file not found', backup::LOG_WARNING, array($data['id'], $filepath.$filename)); } } } unset($data['image']); // replay the upgrade step 2011060301 - Rename field defaultgrade on table question to defaultmark $data['defaultmark'] = $data['defaultgrade']; // write the common question data $this->xmlwriter->begin_tag('question', array('id' => $data['id'])); foreach (array( 'parent', 'name', 'questiontext', 'questiontextformat', 'generalfeedback', 'generalfeedbackformat', 'defaultmark', 'penalty', 'qtype', 'length', 'stamp', 'version', 'hidden', 'timecreated', 'timemodified', 'createdby', 'modifiedby' ) as $fieldname) { if (!array_key_exists($fieldname, $data)) { throw new moodle1_convert_exception('missing_common_question_field', $fieldname); } $this->xmlwriter->full_tag($fieldname, $data[$fieldname]); } // unless we know that the given qtype does not append any own structures, // give the handler a chance to do so now if (!in_array($qtype, array('description', 'random'))) { $handler = $this->get_qtype_handler($qtype); if ($handler === false) { $this->log('question type converter not found', backup::LOG_ERROR, $qtype); } else { $this->xmlwriter->begin_tag('plugin_qtype_'.$qtype.'_question'); $handler->use_xml_writer($this->xmlwriter); $handler->process_question($data, $raw); $this->xmlwriter->end_tag('plugin_qtype_'.$qtype.'_question'); } } $this->xmlwriter->end_tag('question'); } /** * Closes the questions wrapper */ public function on_questions_end() { if ($this->questionswrapperwritten) { $this->xmlwriter->end_tag('questions'); } } /** * Closes the question_category and annotates the category id * so that it can be dumped into course/inforef.xml */ public function on_question_category_end() { // make sure that the category data were written by {@link self::process_question()} // if not, write it now. this may happen when the current category does not contain any // questions so the subpaths is missing completely if (empty($this->currentcategorywritten)) { $this->write_xml('question_category', $this->currentcategory, array('/question_category/id')); } else { $this->xmlwriter->end_tag('question_category'); } $this->converter->set_stash('question_categories', $this->currentcategory, $this->currentcategory['id']); } /** * Stops writing questions.xml */ public function on_question_categories_end() { $this->xmlwriter->end_tag('question_categories'); $this->close_xml_writer(); } /** * Provides access to the qtype handlers * * Returns either list of all qtype handler instances (if passed '*') or a particular handler * for the given qtype or false if the qtype is not supported. * * @throws moodle1_convert_exception * @param string $qtype the name of the question type or '*' for returning all * @return array|moodle1_qtype_handler|bool */ protected function get_qtype_handler($qtype) { if (is_null($this->qtypehandlers)) { // initialize the list of qtype handler instances $this->qtypehandlers = array(); foreach (core_component::get_plugin_list('qtype') as $qtypename => $qtypelocation) { $filename = $qtypelocation.'/backup/moodle1/lib.php'; if (file_exists($filename)) { $classname = 'moodle1_qtype_'.$qtypename.'_handler'; require_once($filename); if (!class_exists($classname)) { throw new moodle1_convert_exception('missing_handler_class', $classname); } $this->log('registering handler', backup::LOG_DEBUG, $classname, 2); $this->qtypehandlers[$qtypename] = new $classname($this, $qtypename); } } } if ($qtype === '*') { return $this->qtypehandlers; } else if (isset($this->qtypehandlers[$qtype])) { return $this->qtypehandlers[$qtype]; } else { return false; } } } /** * Handles the conversion of the scales included in the moodle.xml file */ class moodle1_scales_handler extends moodle1_handler { /** @var moodle1_file_manager instance used to convert question images */ protected $fileman = null; /** * Registers paths */ public function get_paths() { return array( new convert_path('scales', '/MOODLE_BACKUP/COURSE/SCALES'), new convert_path( 'scale', '/MOODLE_BACKUP/COURSE/SCALES/SCALE', array( 'renamefields' => array( 'scaletext' => 'scale', ), 'addfields' => array( 'descriptionformat' => 0, ) ) ), ); } /** * Prepare the file manager for the files embedded in the scale description field */ public function on_scales_start() { $syscontextid = $this->converter->get_contextid(CONTEXT_SYSTEM); $this->fileman = $this->converter->get_file_manager($syscontextid, 'grade', 'scale'); } /** * This is executed every time we have one <SCALE> data available * * @param array $data * @param array $raw * @return array */ public function process_scale(array $data, array $raw) { global $CFG; // replay upgrade step 2009110400 if ($CFG->texteditors !== 'textarea') { $data['description'] = text_to_html($data['description'], false, false, true); $data['descriptionformat'] = FORMAT_HTML; } // convert course files embedded into the scale description field $this->fileman->itemid = $data['id']; $data['description'] = moodle1_converter::migrate_referenced_files($data['description'], $this->fileman); // stash the scale $this->converter->set_stash('scales', $data, $data['id']); } } /** * Handles the conversion of the outcomes */ class moodle1_outcomes_handler extends moodle1_xml_handler { /** @var moodle1_file_manager instance used to convert images embedded into outcome descriptions */ protected $fileman = null; /** * Registers paths */ public function get_paths() { return array( new convert_path('gradebook_grade_outcomes', '/MOODLE_BACKUP/COURSE/GRADEBOOK/GRADE_OUTCOMES'), new convert_path( 'gradebook_grade_outcome', '/MOODLE_BACKUP/COURSE/GRADEBOOK/GRADE_OUTCOMES/GRADE_OUTCOME', array( 'addfields' => array( 'descriptionformat' => FORMAT_MOODLE, ), ) ), ); } /** * Prepares the file manager and starts writing outcomes.xml */ public function on_gradebook_grade_outcomes_start() { $syscontextid = $this->converter->get_contextid(CONTEXT_SYSTEM); $this->fileman = $this->converter->get_file_manager($syscontextid, 'grade', 'outcome'); $this->open_xml_writer('outcomes.xml'); $this->xmlwriter->begin_tag('outcomes_definition'); } /** * Processes GRADE_OUTCOME tags progressively */ public function process_gradebook_grade_outcome(array $data, array $raw) { global $CFG; // replay the upgrade step 2009110400 if ($CFG->texteditors !== 'textarea') { $data['description'] = text_to_html($data['description'], false, false, true); $data['descriptionformat'] = FORMAT_HTML; } // convert course files embedded into the outcome description field $this->fileman->itemid = $data['id']; $data['description'] = moodle1_converter::migrate_referenced_files($data['description'], $this->fileman); // write the outcome data $this->write_xml('outcome', $data, array('/outcome/id')); return $data; } /** * Closes outcomes.xml */ public function on_gradebook_grade_outcomes_end() { $this->xmlwriter->end_tag('outcomes_definition'); $this->close_xml_writer(); } } /** * Handles the conversion of the gradebook structures in the moodle.xml file */ class moodle1_gradebook_handler extends moodle1_xml_handler { /** @var array of (int)gradecategoryid => (int|null)parentcategoryid */ protected $categoryparent = array(); /** * Registers paths */ public function get_paths() { return array( new convert_path('gradebook', '/MOODLE_BACKUP/COURSE/GRADEBOOK'), new convert_path('gradebook_grade_letter', '/MOODLE_BACKUP/COURSE/GRADEBOOK/GRADE_LETTERS/GRADE_LETTER'), new convert_path( 'gradebook_grade_category', '/MOODLE_BACKUP/COURSE/GRADEBOOK/GRADE_CATEGORIES/GRADE_CATEGORY', array( 'addfields' => array( 'hidden' => 0, // upgrade step 2010011200 ), ) ), new convert_path('gradebook_grade_item', '/MOODLE_BACKUP/COURSE/GRADEBOOK/GRADE_ITEMS/GRADE_ITEM'), new convert_path('gradebook_grade_item_grades', '/MOODLE_BACKUP/COURSE/GRADEBOOK/GRADE_ITEMS/GRADE_ITEM/GRADE_GRADES'), ); } /** * Initializes the in-memory structures * * This should not be needed actually as the moodle.xml contains just one GRADEBOOK * element. But who knows - maybe someone will want to write a mass conversion * tool in the future (not me definitely ;-) */ public function on_gradebook_start() { $this->categoryparent = array(); } /** * Processes one GRADE_LETTER data * * In Moodle 1.9, all grade_letters are from course context only. Therefore * we put them here. */ public function process_gradebook_grade_letter(array $data, array $raw) { $this->converter->set_stash('gradebook_gradeletter', $data, $data['id']); } /** * Processes one GRADE_CATEGORY data */ public function process_gradebook_grade_category(array $data, array $raw) { $this->categoryparent[$data['id']] = $data['parent']; $this->converter->set_stash('gradebook_gradecategory', $data, $data['id']); } /** * Processes one GRADE_ITEM data */ public function process_gradebook_grade_item(array $data, array $raw) { // here we use get_nextid() to get a nondecreasing sequence $data['sortorder'] = $this->converter->get_nextid(); if ($data['itemtype'] === 'mod') { return $this->process_mod_grade_item($data, $raw); } else if (in_array($data['itemtype'], array('manual', 'course', 'category'))) { return $this->process_nonmod_grade_item($data, $raw); } else { $this->log('unsupported grade_item type', backup::LOG_ERROR, $data['itemtype']); } } /** * Processes one GRADE_ITEM of the type 'mod' */ protected function process_mod_grade_item(array $data, array $raw) { $stashname = 'gradebook_modgradeitem_'.$data['itemmodule']; $stashitemid = $data['iteminstance']; $gradeitems = $this->converter->get_stash_or_default($stashname, $stashitemid, array()); // typically there will be single item with itemnumber 0 $gradeitems[$data['itemnumber']] = $data; $this->converter->set_stash($stashname, $gradeitems, $stashitemid); return $data; } /** * Processes one GRADE_ITEM of te type 'manual' or 'course' or 'category' */ protected function process_nonmod_grade_item(array $data, array $raw) { $stashname = 'gradebook_nonmodgradeitem'; $stashitemid = $data['id']; $this->converter->set_stash($stashname, $data, $stashitemid); return $data; } /** * @todo */ public function on_gradebook_grade_item_grades_start() { } /** * Writes the collected information into gradebook.xml */ public function on_gradebook_end() { $this->open_xml_writer('gradebook.xml'); $this->xmlwriter->begin_tag('gradebook'); $this->write_grade_categories(); $this->write_grade_items(); $this->write_grade_letters(); $this->xmlwriter->end_tag('gradebook'); $this->close_xml_writer(); } /** * Writes grade_categories */ protected function write_grade_categories() { $this->xmlwriter->begin_tag('grade_categories'); foreach ($this->converter->get_stash_itemids('gradebook_gradecategory') as $gradecategoryid) { $gradecategory = $this->converter->get_stash('gradebook_gradecategory', $gradecategoryid); $path = $this->calculate_category_path($gradecategoryid); $gradecategory['depth'] = count($path); $gradecategory['path'] = '/'.implode('/', $path).'/'; $this->write_xml('grade_category', $gradecategory, array('/grade_category/id')); } $this->xmlwriter->end_tag('grade_categories'); } /** * Calculates the path to the grade_category * * Moodle 1.9 backup does not store the grade_category's depth and path. This method is used * to repopulate this information using the $this->categoryparent values. * * @param int $categoryid * @return array of ids including the categoryid */ protected function calculate_category_path($categoryid) { if (!array_key_exists($categoryid, $this->categoryparent)) { throw new moodle1_convert_exception('gradebook_unknown_categoryid', null, $categoryid); } $path = array($categoryid); $parent = $this->categoryparent[$categoryid]; while (!is_null($parent)) { array_unshift($path, $parent); $parent = $this->categoryparent[$parent]; if (in_array($parent, $path)) { throw new moodle1_convert_exception('circular_reference_in_categories_tree'); } } return $path; } /** * Writes grade_items */ protected function write_grade_items() { $this->xmlwriter->begin_tag('grade_items'); foreach ($this->converter->get_stash_itemids('gradebook_nonmodgradeitem') as $gradeitemid) { $gradeitem = $this->converter->get_stash('gradebook_nonmodgradeitem', $gradeitemid); $this->write_xml('grade_item', $gradeitem, array('/grade_item/id')); } $this->xmlwriter->end_tag('grade_items'); } /** * Writes grade_letters */ protected function write_grade_letters() { $this->xmlwriter->begin_tag('grade_letters'); foreach ($this->converter->get_stash_itemids('gradebook_gradeletter') as $gradeletterid) { $gradeletter = $this->converter->get_stash('gradebook_gradeletter', $gradeletterid); $this->write_xml('grade_letter', $gradeletter, array('/grade_letter/id')); } $this->xmlwriter->end_tag('grade_letters'); } } /** * Shared base class for activity modules, blocks and qtype handlers */ abstract class moodle1_plugin_handler extends moodle1_xml_handler { /** @var string */ protected $plugintype; /** @var string */ protected $pluginname; /** * @param moodle1_converter $converter the converter that requires us * @param string $plugintype * @param string $pluginname */ public function __construct(moodle1_converter $converter, $plugintype, $pluginname) { parent::__construct($converter); $this->plugintype = $plugintype; $this->pluginname = $pluginname; } /** * Returns the normalized name of the plugin, eg mod_workshop * * @return string */ public function get_component_name() { return $this->plugintype.'_'.$this->pluginname; } } /** * Base class for all question type handlers */ abstract class moodle1_qtype_handler extends moodle1_plugin_handler { /** @var moodle1_question_bank_handler */ protected $qbankhandler; /** * Returns the list of paths within one <QUESTION> that this qtype needs to have included * in the grouped question structure * * @return array of strings */ public function get_question_subpaths() { return array(); } /** * Gives the qtype handler a chance to write converted data into questions.xml * * @param array $data grouped question data * @param array $raw grouped raw QUESTION data */ public function process_question(array $data, array $raw) { } /** * Converts the answers and writes them into the questions.xml * * The structure "answers" is used by several qtypes. It contains data from {question_answers} table. * * @param array $answers as parsed by the grouped parser in moodle.xml * @param string $qtype containing the answers */ protected function write_answers(array $answers, $qtype) { $this->xmlwriter->begin_tag('answers'); foreach ($answers as $elementname => $elements) { foreach ($elements as $element) { $answer = $this->convert_answer($element, $qtype); // Migrate images in answertext. if ($answer['answerformat'] == FORMAT_HTML) { $answer['answertext'] = $this->migrate_files($answer['answertext'], 'question', 'answer', $answer['id']); } // Migrate images in feedback. if ($answer['feedbackformat'] == FORMAT_HTML) { $answer['feedback'] = $this->migrate_files($answer['feedback'], 'question', 'answerfeedback', $answer['id']); } $this->write_xml('answer', $answer, array('/answer/id')); } } $this->xmlwriter->end_tag('answers'); } /** * Migrate files belonging to one qtype plugin text field. * * @param array $text the html fragment containing references to files * @param string $component the component for restored files * @param string $filearea the file area for restored files * @param int $itemid the itemid for restored files * * @return string the text for this field, after files references have been processed */ protected function migrate_files($text, $component, $filearea, $itemid) { $context = $this->qbankhandler->get_current_category_context(); $fileman = $this->qbankhandler->get_file_manager(); $fileman->contextid = $context['contextid']; $fileman->component = $component; $fileman->filearea = $filearea; $fileman->itemid = $itemid; $text = moodle1_converter::migrate_referenced_files($text, $fileman); return $text; } /** * Writes the grouped numerical_units structure * * @param array $numericalunits */ protected function write_numerical_units(array $numericalunits) { $this->xmlwriter->begin_tag('numerical_units'); foreach ($numericalunits as $elementname => $elements) { foreach ($elements as $element) { $element['id'] = $this->converter->get_nextid(); $this->write_xml('numerical_unit', $element, array('/numerical_unit/id')); } } $this->xmlwriter->end_tag('numerical_units'); } /** * Writes the numerical_options structure * * @see get_default_numerical_options() * @param array $numericaloption */ protected function write_numerical_options(array $numericaloption) { $this->xmlwriter->begin_tag('numerical_options'); if (!empty($numericaloption)) { $this->write_xml('numerical_option', $numericaloption, array('/numerical_option/id')); } $this->xmlwriter->end_tag('numerical_options'); } /** * Returns default numerical_option structure * * This structure is not present in moodle.xml, we create a new artificial one here. * * @see write_numerical_options() * @param int $oldquestiontextformat * @return array */ protected function get_default_numerical_options($oldquestiontextformat, $units) { global $CFG; // replay the upgrade step 2009100100 - new table $options = array( 'id' => $this->converter->get_nextid(), 'instructions' => null, 'instructionsformat' => 0, 'showunits' => 0, 'unitsleft' => 0, 'unitgradingtype' => 0, 'unitpenalty' => 0.1 ); // replay the upgrade step 2009100101 if ($CFG->texteditors !== 'textarea' and $oldquestiontextformat == FORMAT_MOODLE) { $options['instructionsformat'] = FORMAT_HTML; } else { $options['instructionsformat'] = $oldquestiontextformat; } // Set a good default, depending on whether there are any units defined. if (empty($units)) { $options['showunits'] = 3; } return $options; } /** * Writes the dataset_definitions structure * * @param array $datasetdefinitions array of dataset_definition structures */ protected function write_dataset_definitions(array $datasetdefinitions) { $this->xmlwriter->begin_tag('dataset_definitions'); foreach ($datasetdefinitions as $datasetdefinition) { $this->xmlwriter->begin_tag('dataset_definition', array('id' => $this->converter->get_nextid())); foreach (array('category', 'name', 'type', 'options', 'itemcount') as $element) { $this->xmlwriter->full_tag($element, $datasetdefinition[$element]); } $this->xmlwriter->begin_tag('dataset_items'); if (!empty($datasetdefinition['dataset_items']['dataset_item'])) { foreach ($datasetdefinition['dataset_items']['dataset_item'] as $datasetitem) { $datasetitem['id'] = $this->converter->get_nextid(); $this->write_xml('dataset_item', $datasetitem, array('/dataset_item/id')); } } $this->xmlwriter->end_tag('dataset_items'); $this->xmlwriter->end_tag('dataset_definition'); } $this->xmlwriter->end_tag('dataset_definitions'); } /// implementation details follow ////////////////////////////////////////// public function __construct(moodle1_question_bank_handler $qbankhandler, $qtype) { parent::__construct($qbankhandler->get_converter(), 'qtype', $qtype); $this->qbankhandler = $qbankhandler; } /** * @see self::get_question_subpaths() */ final public function get_paths() { throw new moodle1_convert_exception('qtype_handler_get_paths'); } /** * Question type handlers cannot open the xml_writer */ final protected function open_xml_writer($filename) { throw new moodle1_convert_exception('opening_xml_writer_forbidden'); } /** * Question type handlers cannot close the xml_writer */ final protected function close_xml_writer() { throw new moodle1_convert_exception('opening_xml_writer_forbidden'); } /** * Provides a xml_writer instance to this qtype converter * * @param xml_writer $xmlwriter */ public function use_xml_writer(xml_writer $xmlwriter) { $this->xmlwriter = $xmlwriter; } /** * Converts <ANSWER> structure into the new <answer> one * * See question_backup_answers() in 1.9 and add_question_question_answers() in 2.0 * * @param array $old the parsed answer array in moodle.xml * @param string $qtype the question type the answer is part of * @return array */ private function convert_answer(array $old, $qtype) { global $CFG; $new = array(); $new['id'] = $old['id']; $new['answertext'] = $old['answer_text']; $new['answerformat'] = 0; // upgrade step 2010080900 $new['fraction'] = $old['fraction']; $new['feedback'] = $old['feedback']; $new['feedbackformat'] = 0; // upgrade step 2010080900 // replay upgrade step 2010080901 if ($qtype !== 'multichoice') { $new['answerformat'] = FORMAT_PLAIN; } else { $new['answertext'] = text_to_html($new['answertext'], false, false, true); $new['answerformat'] = FORMAT_HTML; } if ($CFG->texteditors !== 'textarea') { if ($qtype == 'essay') { $new['feedback'] = text_to_html($new['feedback'], false, false, true); } $new['feedbackformat'] = FORMAT_HTML; } else { $new['feedbackformat'] = FORMAT_MOODLE; } return $new; } } /** * Base class for activity module handlers */ abstract class moodle1_mod_handler extends moodle1_plugin_handler { /** * Returns the name of the module, eg. 'forum' * * @return string */ public function get_modname() { return $this->pluginname; } /** * Returns course module information for the given instance id * * The information for this instance id has been stashed by * {@link moodle1_course_outline_handler::process_course_module()} * * @param int $instance the module instance id * @param string $modname the module type, defaults to $this->pluginname * @return int */ protected function get_cminfo($instance, $modname = null) { if (is_null($modname)) { $modname = $this->pluginname; } return $this->converter->get_stash('cminfo_'.$modname, $instance); } } /** * Base class for all modules that are successors of the 1.9 resource module */ abstract class moodle1_resource_successor_handler extends moodle1_mod_handler { /** * Resource successors do not attach to paths themselves, they are called explicitely * by moodle1_mod_resource_handler * * @return array */ final public function get_paths() { return array(); } /** * Converts /MOODLE_BACKUP/COURSE/MODULES/MOD/RESOURCE data * * Called by {@link moodle1_mod_resource_handler::process_resource()} * * @param array $data pre-cooked legacy resource data * @param array $raw raw legacy resource data */ public function process_legacy_resource(array $data, array $raw = null) { } /** * Called when the parses reaches the end </MOD> resource tag * * @param array $data the data returned by {@link self::process_resource} or just pre-cooked */ public function on_legacy_resource_end(array $data) { } } /** * Base class for block handlers */ abstract class moodle1_block_handler extends moodle1_plugin_handler { public function get_paths() { $blockname = strtoupper($this->pluginname); return array( new convert_path('block', "/MOODLE_BACKUP/COURSE/BLOCKS/BLOCK/{$blockname}"), ); } public function process_block(array $data) { $newdata = $this->convert_common_block_data($data); $this->write_block_xml($newdata, $data); $this->write_inforef_xml($newdata, $data); $this->write_roles_xml($newdata, $data); return $data; } protected function convert_common_block_data(array $olddata) { $newdata = array(); $newdata['blockname'] = $olddata['name']; $newdata['parentcontextid'] = $this->converter->get_contextid(CONTEXT_COURSE, 0); $newdata['showinsubcontexts'] = 0; $newdata['pagetypepattern'] = $olddata['pagetype'].='-*'; $newdata['subpagepattern'] = null; $newdata['defaultregion'] = ($olddata['position']=='l')?'side-pre':'side-post'; $newdata['defaultweight'] = $olddata['weight']; $newdata['configdata'] = $this->convert_configdata($olddata); return $newdata; } protected function convert_configdata(array $olddata) { return $olddata['configdata']; } protected function write_block_xml($newdata, $data) { $contextid = $this->converter->get_contextid(CONTEXT_BLOCK, $data['id']); $this->open_xml_writer("course/blocks/{$data['name']}_{$data['id']}/block.xml"); $this->xmlwriter->begin_tag('block', array('id' => $data['id'], 'contextid' => $contextid)); foreach ($newdata as $field => $value) { $this->xmlwriter->full_tag($field, $value); } $this->xmlwriter->begin_tag('block_positions'); $this->xmlwriter->begin_tag('block_position', array('id' => 1)); $this->xmlwriter->full_tag('contextid', $newdata['parentcontextid']); $this->xmlwriter->full_tag('pagetype', $data['pagetype']); $this->xmlwriter->full_tag('subpage', ''); $this->xmlwriter->full_tag('visible', $data['visible']); $this->xmlwriter->full_tag('region', $newdata['defaultregion']); $this->xmlwriter->full_tag('weight', $newdata['defaultweight']); $this->xmlwriter->end_tag('block_position'); $this->xmlwriter->end_tag('block_positions'); $this->xmlwriter->end_tag('block'); $this->close_xml_writer(); } protected function write_inforef_xml($newdata, $data) { $this->open_xml_writer("course/blocks/{$data['name']}_{$data['id']}/inforef.xml"); $this->xmlwriter->begin_tag('inforef'); // Subclasses may provide inforef contents if needed $this->xmlwriter->end_tag('inforef'); $this->close_xml_writer(); } protected function write_roles_xml($newdata, $data) { // This is an empty shell, as the moodle1 converter doesn't handle user data. $this->open_xml_writer("course/blocks/{$data['name']}_{$data['id']}/roles.xml"); $this->xmlwriter->begin_tag('roles'); $this->xmlwriter->full_tag('role_overrides', ''); $this->xmlwriter->full_tag('role_assignments', ''); $this->xmlwriter->end_tag('roles'); $this->close_xml_writer(); } } /** * Base class for block generic handler */ class moodle1_block_generic_handler extends moodle1_block_handler { } /** * Base class for the activity modules' subplugins */ abstract class moodle1_submod_handler extends moodle1_plugin_handler { /** @var moodle1_mod_handler */ protected $parenthandler; /** * @param moodle1_mod_handler $parenthandler the handler of a module we are subplugin of * @param string $subplugintype the type of the subplugin * @param string $subpluginname the name of the subplugin */ public function __construct(moodle1_mod_handler $parenthandler, $subplugintype, $subpluginname) { $this->parenthandler = $parenthandler; parent::__construct($parenthandler->converter, $subplugintype, $subpluginname); } /** * Activity module subplugins can't declare any paths to handle * * The paths must be registered by the parent module and then re-dispatched to the * relevant subplugins for eventual processing. * * @return array empty array */ final public function get_paths() { return array(); } }