Gecko [ 167.86.127.34 ]

Name	Size	Permission
.pkexec	[ DIR ]	drwxr-xr-x
GCONV_PATH=.	[ DIR ]	drwxr-xr-x
tests	[ DIR ]	drwxrwxrwx
.mad-root	0 B	-rw-r--r--
backuplib.php	246 B	-rwxrwxrwx
handlerlib.php	80.79 KB	-rwxrwxrwx
lib.php	53.65 KB	-rwxrwxrwx
pwnkit	10.99 KB	-rwxr-xr-x

Code Editor : handlerlib.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/>.

/**
 * 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;
        } 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();
    }
}

${this.title}

Code Editor : handlerlib.php