Proyectos de Subversion Moodle

<?php

// This file is part of Moodle - http://moodle.org/

//

// Moodle is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// Moodle is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

/**

 * Defines various backup steps that will be used by common tasks in backup

 *

 * @package     core_backup

 * @subpackage  moodle2

 * @category    backup

 * @copyright   2010 onwards Eloy Lafuente (stronk7) {@link http://stronk7.com}

 * @license     http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

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

/**

 * Create the temp dir where backup/restore will happen and create temp ids table.

 */

class create_and_clean_temp_stuff extends backup_execution_step {

    protected function define_execution() {

        $progress = $this->task->get_progress();

        $progress->start_progress('Deleting backup directories');

        backup_helper::check_and_create_backup_dir($this->get_backupid());// Create backup temp dir

        backup_helper::clear_backup_dir($this->get_backupid(), $progress);           // Empty temp dir, just in case

        backup_controller_dbops::drop_backup_ids_temp_table($this->get_backupid()); // Drop ids temp table

        backup_controller_dbops::create_backup_ids_temp_table($this->get_backupid()); // Create ids temp table

        $progress->end_progress();

    }

}

/**

 * Delete the temp dir used by backup/restore (conditionally) and drop temp ids table.

 * Note we delete the directory but not the corresponding log file that will be

 * there until cron cleans it up.

 */

class drop_and_clean_temp_stuff extends backup_execution_step {

    protected $skipcleaningtempdir = false;

    protected function define_execution() {

        global $CFG;

        backup_controller_dbops::drop_backup_ids_temp_table($this->get_backupid()); // Drop ids temp table

        // Delete temp dir conditionally:

        // 1) If $CFG->keeptempdirectoriesonbackup is not enabled

        // 2) If backup temp dir deletion has been marked to be avoided

        if (empty($CFG->keeptempdirectoriesonbackup) && !$this->skipcleaningtempdir) {

            $progress = $this->task->get_progress();

            $progress->start_progress('Deleting backup dir');

            backup_helper::delete_backup_dir($this->get_backupid(), $progress); // Empty backup dir

            $progress->end_progress();

        }

    }

    public function skip_cleaning_temp_dir($skip) {

        $this->skipcleaningtempdir = $skip;

    }

}

/**

 * Create the directory where all the task (activity/block...) information will be stored

 */

class create_taskbasepath_directory extends backup_execution_step {

    protected function define_execution() {

        global $CFG;

        $basepath = $this->task->get_taskbasepath();

        if (!check_dir_exists($basepath, true, true)) {

            throw new backup_step_exception('cannot_create_taskbasepath_directory', $basepath);

        }

    }

}

/**

 * Abstract structure step, parent of all the activity structure steps. Used to wrap the

 * activity structure definition within the main <activity ...> tag.

 */

abstract class backup_activity_structure_step extends backup_structure_step {

    /**

     * Wraps any activity backup structure within the common 'activity' element

     * that will include common to all activities information like id, context...

     *

     * @param backup_nested_element $activitystructure the element to wrap

     * @return backup_nested_element the $activitystructure wrapped by the common 'activity' element

     */

    protected function prepare_activity_structure($activitystructure) {

        // Create the wrap element

        $activity = new backup_nested_element('activity', array('id', 'moduleid', 'modulename', 'contextid'), null);

        // Build the tree

        $activity->add_child($activitystructure);

        // Set the source

        $activityarr = array((object)array(

            'id'         => $this->task->get_activityid(),

            'moduleid'   => $this->task->get_moduleid(),

            'modulename' => $this->task->get_modulename(),

            'contextid'  => $this->task->get_contextid()));

        $activity->set_source_array($activityarr);

        // Return the root element (activity)

        return $activity;

    }

}

/**

 * Helper code for use by any plugin that stores question attempt data that it needs to back up.

 */

trait backup_questions_attempt_data_trait {

    /**

     * Attach to $element (usually attempts) the needed backup structures

     * for question_usages and all the associated data.

     *

     * @param backup_nested_element $element the element that will contain all the question_usages data.

     * @param string $usageidname the name of the element that holds the usageid.

     *      This must be child of $element, and must be a final element.

     * @param string $nameprefix this prefix is added to all the element names we create.

     *      Element names in the XML must be unique, so if you are using usages in

     *      two different ways, you must give a prefix to at least one of them. If

     *      you only use one sort of usage, then you can just use the default empty prefix.

     *      This should include a trailing underscore. For example "myprefix_"

     */

    protected function add_question_usages($element, $usageidname, $nameprefix = '') {

        global $CFG;

        require_once($CFG->dirroot . '/question/engine/lib.php');

        // Check $element is one nested_backup_element

        if (! $element instanceof backup_nested_element) {

            throw new backup_step_exception('question_states_bad_parent_element', $element);

        }

        if (! $element->get_final_element($usageidname)) {

            throw new backup_step_exception('question_states_bad_question_attempt_element', $usageidname);

        }

        $quba = new backup_nested_element($nameprefix . 'question_usage', array('id'),

                array('component', 'preferredbehaviour'));

        $qas = new backup_nested_element($nameprefix . 'question_attempts');

        $qa = new backup_nested_element($nameprefix . 'question_attempt', array('id'), array(

                'slot', 'behaviour', 'questionid', 'variant', 'maxmark', 'minfraction', 'maxfraction',

                'flagged', 'questionsummary', 'rightanswer', 'responsesummary',

                'timemodified'));

        $steps = new backup_nested_element($nameprefix . 'steps');

        $step = new backup_nested_element($nameprefix . 'step', array('id'), array(

                'sequencenumber', 'state', 'fraction', 'timecreated', 'userid'));

        $response = new backup_nested_element($nameprefix . 'response');

        $variable = new backup_nested_element($nameprefix . 'variable', null,  array('name', 'value'));

        // Build the tree

        $element->add_child($quba);

        $quba->add_child($qas);

        $qas->add_child($qa);

        $qa->add_child($steps);

        $steps->add_child($step);

        $step->add_child($response);

        $response->add_child($variable);

        // Set the sources

        $quba->set_source_table('question_usages',

                array('id'                => '../' . $usageidname));

        $qa->set_source_table('question_attempts', array('questionusageid' => backup::VAR_PARENTID), 'slot ASC');

        $step->set_source_table('question_attempt_steps', array('questionattemptid' => backup::VAR_PARENTID), 'sequencenumber ASC');

        $variable->set_source_table('question_attempt_step_data', array('attemptstepid' => backup::VAR_PARENTID));

        // Annotate ids

        $qa->annotate_ids('question', 'questionid');

        $step->annotate_ids('user', 'userid');

        // Annotate files

        $fileareas = question_engine::get_all_response_file_areas();

        foreach ($fileareas as $filearea) {

            $step->annotate_files('question', $filearea, 'id');

        }

    }

}

/**

 * Helper to backup question reference data for an instance.

 */

trait backup_question_reference_data_trait {

    /**

     * Backup the related data from reference table for the instance.

     *

     * @param backup_nested_element $element

     * @param string $component

     * @param string $questionarea

     */

    protected function add_question_references($element, $component, $questionarea) {

        // Check $element is one nested_backup_element.

        if (! $element instanceof backup_nested_element) {

            throw new backup_step_exception('question_states_bad_parent_element', $element);

        }

        $reference = new backup_nested_element('question_reference', ['id'],

            ['usingcontextid', 'component', 'questionarea', 'questionbankentryid', 'version']);

        $element->add_child($reference);

        $reference->set_source_table('question_references', [

            'usingcontextid' => backup::VAR_CONTEXTID,

            'component' => backup_helper::is_sqlparam($component),

            'questionarea' => backup_helper::is_sqlparam($questionarea),

            'itemid' => backup::VAR_PARENTID

        ]);

    }

}

/**

 * Helper to backup question set reference data for an instance.

 */

trait backup_question_set_reference_trait {

    /**

     * Backup the related data from set_reference table for the instance.

     *

     * @param backup_nested_element $element

     * @param string $component

     * @param string $questionarea

     */

    protected function add_question_set_references($element, $component, $questionarea) {

        // Check $element is one nested_backup_element.

        if (! $element instanceof backup_nested_element) {

            throw new backup_step_exception('question_states_bad_parent_element', $element);

        }

        $setreference = new backup_nested_element('question_set_reference', ['id'],

            ['usingcontextid', 'component', 'questionarea', 'questionscontextid', 'filtercondition']);

        $element->add_child($setreference);

        $setreference->set_source_table('question_set_references', [

            'usingcontextid' => backup::VAR_CONTEXTID,

            'component' => backup_helper::is_sqlparam($component),

            'questionarea' => backup_helper::is_sqlparam($questionarea),

            'itemid' => backup::VAR_PARENTID

        ]);

    }

}

/**

 * Abstract structure step to help activities that store question attempt data, reference data and set reference data.

 *

 * @copyright 2011 The Open University

 * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

abstract class backup_questions_activity_structure_step extends backup_activity_structure_step {

    use backup_questions_attempt_data_trait;

    use backup_question_reference_data_trait;

    use backup_question_set_reference_trait;

}

/**

 * backup structure step in charge of calculating the categories to be

 * included in backup, based in the context being backuped (module/course)

 * and the already annotated questions present in backup_ids_temp

 */

class backup_calculate_question_categories extends backup_execution_step {

    protected function define_execution() {

        backup_question_dbops::calculate_question_categories($this->get_backupid(), $this->task->get_contextid());

    }

}

/**

 * backup structure step in charge of deleting all the questions annotated

 * in the backup_ids_temp table

 */

class backup_delete_temp_questions extends backup_execution_step {

    protected function define_execution() {

        backup_question_dbops::delete_temp_questions($this->get_backupid());

    }

}

/**

 * Abstract structure step, parent of all the block structure steps. Used to wrap the

 * block structure definition within the main <block ...> tag

 */

abstract class backup_block_structure_step extends backup_structure_step {

    protected function prepare_block_structure($blockstructure) {

        // Create the wrap element

        $block = new backup_nested_element('block', array('id', 'blockname', 'contextid'), null);

        // Build the tree

        $block->add_child($blockstructure);

        // Set the source

        $blockarr = array((object)array(

            'id'         => $this->task->get_blockid(),

            'blockname'  => $this->task->get_blockname(),

            'contextid'  => $this->task->get_contextid()));

        $block->set_source_array($blockarr);

        // Return the root element (block)

        return $block;

    }

}

/**

 * structure step that will generate the module.xml file for the activity,

 * accumulating various information about the activity, annotating groupings

 * and completion/avail conf

 */

class backup_module_structure_step extends backup_structure_step {

    protected function define_structure() {

        global $DB;

        // Define each element separated

        $module = new backup_nested_element('module', array('id', 'version'), array(

            'modulename', 'sectionid', 'sectionnumber', 'idnumber',

            'added', 'score', 'indent', 'visible', 'visibleoncoursepage',

            'visibleold', 'groupmode', 'groupingid',

            'completion', 'completiongradeitemnumber', 'completionpassgrade',

            'completionview', 'completionexpected',

            'availability', 'showdescription', 'downloadcontent', 'lang'));

        $tags = new backup_nested_element('tags');

        $tag = new backup_nested_element('tag', array('id'), array('name', 'rawname'));

        // attach format plugin structure to $module element, only one allowed

        $this->add_plugin_structure('format', $module, false);

        // Attach report plugin structure to $module element, multiple allowed.

        $this->add_plugin_structure('report', $module, true);

        // attach plagiarism plugin structure to $module element, there can be potentially

        // many plagiarism plugins storing information about this course

        $this->add_plugin_structure('plagiarism', $module, true);

        // attach local plugin structure to $module, multiple allowed

        $this->add_plugin_structure('local', $module, true);

        // Attach admin tools plugin structure to $module.

        $this->add_plugin_structure('tool', $module, true);

        $module->add_child($tags);

        $tags->add_child($tag);

        // Set the sources

        $concat = $DB->sql_concat("'mod_'", 'm.name');

        $module->set_source_sql("

            SELECT cm.*, cp.value AS version, m.name AS modulename, s.id AS sectionid, s.section AS sectionnumber

              FROM {course_modules} cm

              JOIN {modules} m ON m.id = cm.module

              JOIN {config_plugins} cp ON cp.plugin = $concat AND cp.name = 'version'

              JOIN {course_sections} s ON s.id = cm.section

             WHERE cm.id = ?", array(backup::VAR_MODID));

        $tag->set_source_sql("SELECT t.id, t.name, t.rawname

                                FROM {tag} t

                                JOIN {tag_instance} ti ON ti.tagid = t.id

                               WHERE ti.itemtype = 'course_modules'

                                 AND ti.component = 'core'

                                 AND ti.itemid = ?", array(backup::VAR_MODID));

        // Define annotations

        $module->annotate_ids('grouping', 'groupingid');

        // Return the root element ($module)

        return $module;

    }

}

/**

 * structure step that will generate the section.xml file for the section

 * annotating files

 */

class backup_section_structure_step extends backup_structure_step {

    protected function define_structure() {

        // Define each element separated

        $section = new backup_nested_element(

            'section',

            ['id'],

            [

                'number', 'name', 'summary', 'summaryformat', 'sequence', 'visible',

                'availabilityjson', 'component', 'itemid', 'timemodified',

            ]

        );

        // attach format plugin structure to $section element, only one allowed

        $this->add_plugin_structure('format', $section, false);

        // attach local plugin structure to $section element, multiple allowed

        $this->add_plugin_structure('local', $section, true);

        // Add nested elements for course_format_options table

        $formatoptions = new backup_nested_element('course_format_options', array('id'), array(

            'format', 'name', 'value'));

        $section->add_child($formatoptions);

        // Define sources.

        $section->set_source_table('course_sections', array('id' => backup::VAR_SECTIONID));

        $formatoptions->set_source_sql('SELECT cfo.id, cfo.format, cfo.name, cfo.value

              FROM {course} c

              JOIN {course_format_options} cfo

              ON cfo.courseid = c.id AND cfo.format = c.format

              WHERE c.id = ? AND cfo.sectionid = ?',

                array(backup::VAR_COURSEID, backup::VAR_SECTIONID));

        // Aliases

        $section->set_source_alias('section', 'number');

        // The 'availability' field needs to be renamed because it clashes with

        // the old nested element structure for availability data.

        $section->set_source_alias('availability', 'availabilityjson');

        // Set annotations

        $section->annotate_files('course', 'section', 'id');

        return $section;

    }

}

/**

 * structure step that will generate the course.xml file for the course, including

 * course category reference, tags, modules restriction information

 * and some annotations (files & groupings)

 */

class backup_course_structure_step extends backup_structure_step {

    protected function define_structure() {

        global $DB;

        // Define each element separated

        $course = new backup_nested_element('course', array('id', 'contextid'), array(

            'shortname', 'fullname', 'idnumber',

            'summary', 'summaryformat', 'format', 'showgrades',

            'newsitems', 'startdate', 'enddate',

            'marker', 'maxbytes', 'legacyfiles', 'showreports',

            'visible', 'groupmode', 'groupmodeforce',

            'defaultgroupingid', 'lang', 'theme',

            'timecreated', 'timemodified',

            'requested',

            'showactivitydates',

            'showcompletionconditions', 'pdfexportfont',

            'enablecompletion', 'completionstartonenrol', 'completionnotify'));

        $category = new backup_nested_element('category', array('id'), array(

            'name', 'description'));

        $tags = new backup_nested_element('tags');

        $tag = new backup_nested_element('tag', array('id'), array(

            'name', 'rawname'));

        $customfields = new backup_nested_element('customfields');

        $customfield = new backup_nested_element('customfield', array('id'), array(

            'shortname', 'type', 'value', 'valueformat', 'valuetrust',

        ));

        $courseformatoptions = new backup_nested_element('courseformatoptions');

        $courseformatoption = new backup_nested_element('courseformatoption', [], [

            'courseid', 'format', 'sectionid', 'name', 'value'

        ]);

        // attach format plugin structure to $course element, only one allowed

        $this->add_plugin_structure('format', $course, false);

        // attach theme plugin structure to $course element; multiple themes can

        // save course data (in case of user theme, legacy theme, etc)

        $this->add_plugin_structure('theme', $course, true);

        // attach general report plugin structure to $course element; multiple

        // reports can save course data if required

        $this->add_plugin_structure('report', $course, true);

        // attach course report plugin structure to $course element; multiple

        // course reports can save course data if required

        $this->add_plugin_structure('coursereport', $course, true);

        // attach plagiarism plugin structure to $course element, there can be potentially

        // many plagiarism plugins storing information about this course

        $this->add_plugin_structure('plagiarism', $course, true);

        // attach local plugin structure to $course element; multiple local plugins

        // can save course data if required

        $this->add_plugin_structure('local', $course, true);

        // Attach admin tools plugin structure to $course element; multiple plugins

        // can save course data if required.

        $this->add_plugin_structure('tool', $course, true);

        // Build the tree

        $course->add_child($category);

        $course->add_child($tags);

        $tags->add_child($tag);

        $course->add_child($customfields);

        $customfields->add_child($customfield);

        $course->add_child($courseformatoptions);

        $courseformatoptions->add_child($courseformatoption);

        // Set the sources

        $courserec = $DB->get_record('course', array('id' => $this->task->get_courseid()));

        $courserec->contextid = $this->task->get_contextid();

        // Add 'numsections' in order to be able to restore in previous versions of Moodle.

        // Even though Moodle does not officially support restore into older verions of Moodle from the

        // version where backup was made, without 'numsections' restoring will go very wrong.

        if (!property_exists($courserec, 'numsections') && course_get_format($courserec)->uses_sections()) {

            $courserec->numsections = course_get_format($courserec)->get_last_section_number();

        }

        $course->set_source_array(array($courserec));

        $categoryrec = $DB->get_record('course_categories', array('id' => $courserec->category));

        $category->set_source_array(array($categoryrec));

        $tag->set_source_sql('SELECT t.id, t.name, t.rawname

                                FROM {tag} t

                                JOIN {tag_instance} ti ON ti.tagid = t.id

                               WHERE ti.itemtype = ?

                                 AND ti.itemid = ?', array(

                                     backup_helper::is_sqlparam('course'),

                                     backup::VAR_PARENTID));

        // Section level settings are dealt with in backup_section_structure_step.

        // We only need to deal with course level (sectionid = 0) here.

        $courseformatoption->set_source_sql('SELECT id, format, sectionid, name, value

                                 FROM {course_format_options}

                                 WHERE courseid = ? AND sectionid = 0', [ backup::VAR_PARENTID ]);

        $handler = core_course\customfield\course_handler::create();

        $fieldsforbackup = $handler->get_instance_data_for_backup($this->task->get_courseid());

        $handler->backup_define_structure($this->task->get_courseid(), $customfield);

        $customfield->set_source_array($fieldsforbackup);

        // Some annotations

        $course->annotate_ids('grouping', 'defaultgroupingid');

        $course->annotate_files('course', 'summary', null);

        $course->annotate_files('course', 'overviewfiles', null);

        if ($this->get_setting_value('legacyfiles')) {

            $course->annotate_files('course', 'legacy', null);

        }

        // Return root element ($course)

        return $course;

    }

}

/**

 * structure step that will generate the enrolments.xml file for the given course

 */

class backup_enrolments_structure_step extends backup_structure_step {

    /**

     * Skip enrolments on the front page.

     * @return bool

     */

    protected function execute_condition() {

        return ($this->get_courseid() != SITEID);

    }

    protected function define_structure() {

        global $DB;

        // To know if we are including users

        $users = $this->get_setting_value('users');

        $keptroles = $this->task->get_kept_roles();

        // Define each element separated

        $enrolments = new backup_nested_element('enrolments');

        $enrols = new backup_nested_element('enrols');

        $enrol = new backup_nested_element('enrol', array('id'), array(

            'enrol', 'status', 'name', 'enrolperiod', 'enrolstartdate',

            'enrolenddate', 'expirynotify', 'expirythreshold', 'notifyall',

            'password', 'cost', 'currency', 'roleid',

            'customint1', 'customint2', 'customint3', 'customint4', 'customint5', 'customint6', 'customint7', 'customint8',

            'customchar1', 'customchar2', 'customchar3',

            'customdec1', 'customdec2',

            'customtext1', 'customtext2', 'customtext3', 'customtext4',

            'timecreated', 'timemodified'));

        $userenrolments = new backup_nested_element('user_enrolments');

        $enrolment = new backup_nested_element('enrolment', array('id'), array(

            'status', 'userid', 'timestart', 'timeend', 'modifierid',

            'timemodified'));

        // Build the tree

        $enrolments->add_child($enrols);

        $enrols->add_child($enrol);

        $enrol->add_child($userenrolments);

        $userenrolments->add_child($enrolment);

        // Define sources - the instances are restored using the same sortorder, we do not need to store it in xml and deal with it afterwards.

        $enrol->set_source_table('enrol', array('courseid' => backup::VAR_COURSEID), 'sortorder ASC');

        // User enrolments only added only if users included.

        if (empty($keptroles) && $users) {

            $enrolment->set_source_table('user_enrolments', array('enrolid' => backup::VAR_PARENTID));

            $enrolment->annotate_ids('user', 'userid');

        } else if (!empty($keptroles)) {

            list($insql, $inparams) = $DB->get_in_or_equal($keptroles);

            $params = array(

                backup::VAR_CONTEXTID,

                backup::VAR_PARENTID

            );

            foreach ($inparams as $inparam) {

                $params[] = backup_helper::is_sqlparam($inparam);

            }

            $enrolment->set_source_sql(

               "SELECT ue.*

                  FROM {user_enrolments} ue

            INNER JOIN {role_assignments} ra ON ue.userid = ra.userid

                 WHERE ra.contextid = ?

                       AND ue.enrolid = ?

                       AND ra.roleid $insql",

                $params);

            $enrolment->annotate_ids('user', 'userid');

        }

        $enrol->annotate_ids('role', 'roleid');

        // Add enrol plugin structure.

        $this->add_plugin_structure('enrol', $enrol, true);

        return $enrolments;

    }

}

/**

 * structure step that will generate the roles.xml file for the given context, observing

 * the role_assignments setting to know if that part needs to be included

 */

class backup_roles_structure_step extends backup_structure_step {

    protected function define_structure() {

        // To know if we are including role assignments

        $roleassignments = $this->get_setting_value('role_assignments');

        // Define each element separated

        $roles = new backup_nested_element('roles');

        $overrides = new backup_nested_element('role_overrides');

        $override = new backup_nested_element('override', array('id'), array(

            'roleid', 'capability', 'permission', 'timemodified',

            'modifierid'));

        $assignments = new backup_nested_element('role_assignments');

        $assignment = new backup_nested_element('assignment', array('id'), array(

            'roleid', 'userid', 'timemodified', 'modifierid', 'component', 'itemid',

            'sortorder'));

        // Build the tree

        $roles->add_child($overrides);

        $roles->add_child($assignments);

        $overrides->add_child($override);

        $assignments->add_child($assignment);

        // Define sources

        $override->set_source_table('role_capabilities', array('contextid' => backup::VAR_CONTEXTID));

        // Assignments only added if specified

        if ($roleassignments) {

            $assignment->set_source_table('role_assignments', array('contextid' => backup::VAR_CONTEXTID));

        }

        // Define id annotations

        $override->annotate_ids('role', 'roleid');

        $assignment->annotate_ids('role', 'roleid');

        $assignment->annotate_ids('user', 'userid');

        //TODO: how do we annotate the itemid? the meaning depends on the content of component table (skodak)

        return $roles;

    }

}

/**

 * structure step that will generate the roles.xml containing the

 * list of roles used along the whole backup process. Just raw

 * list of used roles from role table

 */

class backup_final_roles_structure_step extends backup_structure_step {

    protected function define_structure() {

        // Define elements

        $rolesdef = new backup_nested_element('roles_definition');

        $role = new backup_nested_element('role', array('id'), array(

            'name', 'shortname', 'nameincourse', 'description',

            'sortorder', 'archetype'));

        // Build the tree

        $rolesdef->add_child($role);

        // Define sources

        $role->set_source_sql("SELECT r.*, rn.name AS nameincourse

                                 FROM {role} r

                                 JOIN {backup_ids_temp} bi ON r.id = bi.itemid

                            LEFT JOIN {role_names} rn ON r.id = rn.roleid AND rn.contextid = ?

                                WHERE bi.backupid = ?

                                  AND bi.itemname = 'rolefinal'", array(backup::VAR_CONTEXTID, backup::VAR_BACKUPID));

        // Return main element (rolesdef)

        return $rolesdef;

    }

}

/**

 * structure step that will generate the scales.xml containing the

 * list of scales used along the whole backup process.

 */

class backup_final_scales_structure_step extends backup_structure_step {

    protected function define_structure() {

        // Define elements

        $scalesdef = new backup_nested_element('scales_definition');

        $scale = new backup_nested_element('scale', array('id'), array(

            'courseid', 'userid', 'name', 'scale',

            'description', 'descriptionformat', 'timemodified'));

        // Build the tree

        $scalesdef->add_child($scale);

        // Define sources

        $scale->set_source_sql("SELECT s.*

                                  FROM {scale} s

                                  JOIN {backup_ids_temp} bi ON s.id = bi.itemid

                                 WHERE bi.backupid = ?

                                   AND bi.itemname = 'scalefinal'", array(backup::VAR_BACKUPID));

        // Annotate scale files (they store files in system context, so pass it instead of default one)

        $scale->annotate_files('grade', 'scale', 'id', context_system::instance()->id);

        // Return main element (scalesdef)

        return $scalesdef;

    }

}

/**

 * structure step that will generate the outcomes.xml containing the

 * list of outcomes used along the whole backup process.

 */

class backup_final_outcomes_structure_step extends backup_structure_step {

    protected function define_structure() {

        // Define elements

        $outcomesdef = new backup_nested_element('outcomes_definition');

        $outcome = new backup_nested_element('outcome', array('id'), array(

            'courseid', 'userid', 'shortname', 'fullname',

            'scaleid', 'description', 'descriptionformat', 'timecreated',

            'timemodified','usermodified'));

        // Build the tree

        $outcomesdef->add_child($outcome);

        // Define sources

        $outcome->set_source_sql("SELECT o.*

                                    FROM {grade_outcomes} o

                                    JOIN {backup_ids_temp} bi ON o.id = bi.itemid

                                   WHERE bi.backupid = ?

                                     AND bi.itemname = 'outcomefinal'", array(backup::VAR_BACKUPID));

        // Annotate outcome files (they store files in system context, so pass it instead of default one)

        $outcome->annotate_files('grade', 'outcome', 'id', context_system::instance()->id);

        // Return main element (outcomesdef)

        return $outcomesdef;

    }

}

/**

 * structure step in charge of constructing the filters.xml file for all the filters found

 * in activity

 */

class backup_filters_structure_step extends backup_structure_step {

    protected function define_structure() {

        // Define each element separated

        $filters = new backup_nested_element('filters');

        $actives = new backup_nested_element('filter_actives');

        $active = new backup_nested_element('filter_active', null, array('filter', 'active'));

        $configs = new backup_nested_element('filter_configs');

        $config = new backup_nested_element('filter_config', null, array('filter', 'name', 'value'));

        // Build the tree

        $filters->add_child($actives);

        $filters->add_child($configs);

        $actives->add_child($active);

        $configs->add_child($config);

        // Define sources

        list($activearr, $configarr) = filter_get_all_local_settings($this->task->get_contextid());

        $active->set_source_array($activearr);

        $config->set_source_array($configarr);

        // Return the root element (filters)

        return $filters;

    }

}

/**

 * Structure step in charge of constructing the comments.xml file for all the comments found in a given context.

 */

class backup_comments_structure_step extends backup_structure_step {

    protected function define_structure() {

        // Define each element separated.

        $comments = new backup_nested_element('comments');

        $comment = new backup_nested_element('comment', array('id'), array(

            'component', 'commentarea', 'itemid', 'content', 'format',

            'userid', 'timecreated'));

        // Build the tree.

        $comments->add_child($comment);

        // Define sources.

        $comment->set_source_table('comments', array('contextid' => backup::VAR_CONTEXTID));

        // Define id annotations.

        $comment->annotate_ids('user', 'userid');

        // Return the root element (comments).

        return $comments;

    }

}

/**

 * structure step in charge of constructing the badges.xml file for all the badges found

 * in a given context

 */

class backup_badges_structure_step extends backup_structure_step {

    protected function execute_condition() {

        // Check that all activities have been included.

        if ($this->task->is_excluding_activities()) {

            return false;

        }

        return true;

    }

    protected function define_structure() {

        global $CFG;

        require_once($CFG->libdir . '/badgeslib.php');

        // Define each element separated.

        $badges = new backup_nested_element('badges');

        $badge = new backup_nested_element('badge', array('id'), array('name', 'description',

                'timecreated', 'timemodified', 'usercreated', 'usermodified', 'issuername',

                'issuerurl', 'issuercontact', 'expiredate', 'expireperiod', 'type', 'courseid',

                'message', 'messagesubject', 'attachment', 'notification', 'status', 'nextcron',

                'version', 'language', 'imageauthorname', 'imageauthoremail', 'imageauthorurl',

                'imagecaption'));

        $criteria = new backup_nested_element('criteria');

        $criterion = new backup_nested_element('criterion', array('id'), array('badgeid',

                'criteriatype', 'method', 'description', 'descriptionformat'));

        $endorsement = new backup_nested_element('endorsement', array('id'), array('badgeid',

                'issuername', 'issuerurl', 'issueremail', 'claimid', 'claimcomment', 'dateissued'));

        $alignments = new backup_nested_element('alignments');

        $alignment = new backup_nested_element('alignment', array('id'), array('badgeid',

                'targetname', 'targeturl', 'targetdescription', 'targetframework', 'targetcode'));

        $relatedbadges = new backup_nested_element('relatedbadges');

        $relatedbadge = new backup_nested_element('relatedbadge', array('id'), array('badgeid',

                'relatedbadgeid'));

        $parameters = new backup_nested_element('parameters');

        $parameter = new backup_nested_element('parameter', array('id'), array('critid',

                'name', 'value', 'criteriatype'));

        $manual_awards = new backup_nested_element('manual_awards');

        $manual_award = new backup_nested_element('manual_award', array('id'), array('badgeid',

                'recipientid', 'issuerid', 'issuerrole', 'datemet'));

        $tags = new backup_nested_element('tags');

        $tag = new backup_nested_element('tag', ['id'], ['name', 'rawname']);

        // Build the tree.

        $badges->add_child($badge);

        $badge->add_child($criteria);

        $criteria->add_child($criterion);

        $criterion->add_child($parameters);

        $parameters->add_child($parameter);

        $badge->add_child($endorsement);

        $badge->add_child($alignments);

        $alignments->add_child($alignment);

        $badge->add_child($relatedbadges);

        $relatedbadges->add_child($relatedbadge);

        $badge->add_child($manual_awards);

        $manual_awards->add_child($manual_award);

        $badge->add_child($tags);

        $tags->add_child($tag);

        // Define sources.

        $parametersql = '

                SELECT *

                FROM {badge}

                WHERE courseid = :courseid

                AND status != ' . BADGE_STATUS_ARCHIVED;

        $parameterparams = [

            'courseid' => backup::VAR_COURSEID

        ];

        $badge->set_source_sql($parametersql, $parameterparams);

        $criterion->set_source_table('badge_criteria', array('badgeid' => backup::VAR_PARENTID));

        $endorsement->set_source_table('badge_endorsement', array('badgeid' => backup::VAR_PARENTID));

        $alignment->set_source_table('badge_alignment', array('badgeid' => backup::VAR_PARENTID));

        $relatedbadge->set_source_table('badge_related', array('badgeid' => backup::VAR_PARENTID));

        $parametersql = 'SELECT cp.*, c.criteriatype

                             FROM {badge_criteria_param} cp JOIN {badge_criteria} c

                                 ON cp.critid = c.id

                             WHERE critid = :critid';

        $parameterparams = array('critid' => backup::VAR_PARENTID);

        $parameter->set_source_sql($parametersql, $parameterparams);

        $manual_award->set_source_table('badge_manual_award', array('badgeid' => backup::VAR_PARENTID));

        $tag->set_source_sql('SELECT t.id, t.name, t.rawname

                                FROM {tag} t

                                JOIN {tag_instance} ti ON ti.tagid = t.id

                               WHERE ti.itemtype = ?

                                 AND ti.itemid = ?', [backup_helper::is_sqlparam('badge'), backup::VAR_PARENTID]);

        // Define id annotations.

        $badge->annotate_ids('user', 'usercreated');

        $badge->annotate_ids('user', 'usermodified');

        $criterion->annotate_ids('badge', 'badgeid');

        $parameter->annotate_ids('criterion', 'critid');

        $endorsement->annotate_ids('badge', 'badgeid');

        $alignment->annotate_ids('badge', 'badgeid');

        $relatedbadge->annotate_ids('badge', 'badgeid');

        $relatedbadge->annotate_ids('badge', 'relatedbadgeid');

        $badge->annotate_files('badges', 'badgeimage', 'id');

        $manual_award->annotate_ids('badge', 'badgeid');

        $manual_award->annotate_ids('user', 'recipientid');

        $manual_award->annotate_ids('user', 'issuerid');

        $manual_award->annotate_ids('role', 'issuerrole');

        // Return the root element ($badges).