WebSVN – Moodle – Diff – /backup/moodle2/backup_stepslib.php

  * @license     http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  */
+defined('MOODLE_INTERNAL') || die();
-defined('MOODLE_INTERNAL') || die();
+use core_question\local\bank\random_question_loader;
 /**
  * Create the temp dir where backup/restore will happen and create temp ids table.
         $activity->set_source_array($activityarr);
         // Return the root element (activity)
         return $activity;
+    }
+    /**
+     * Set a delegate section itemid mapping.
+     *
+     * @param string $pluginname the name of the plugin that is delegating the section.
+     * @param int $itemid the itemid of the section being delegated.
+     */
+    protected function set_delegated_section_mapping(string $pluginname, int $itemid) {
+        backup_structure_dbops::insert_backup_ids_record(
+            $this->get_backupid(),
+            "course_section::$pluginname::$itemid",
+            $this->task->get_moduleid()
+        );
+    }
+}
 /**
             'usingcontextid' => backup::VAR_CONTEXTID,
             'component' => backup_helper::is_sqlparam($component),
             'questionarea' => backup_helper::is_sqlparam($questionarea),
             'itemid' => backup::VAR_PARENTID
         ]);
+        $reference->annotate_ids('question_bank_entry', 'questionbankentryid');
+    }
+}
 /**
             'component' => backup_helper::is_sqlparam($component),
             'questionarea' => backup_helper::is_sqlparam($questionarea),
             'itemid' => backup::VAR_PARENTID
         ]);
+    }
+    /**
+     * Find all questions that match set reference conditions used by the activity, and record the question bank entry IDs.
+     *
+     * @param int $contextid The context ID of the activity being backed up
+     * @param string $component The component of the activity
+     * @param string $questionarea The question area for finding set references
+     * @param string $backupid The backup ID to annotate question bank entries against
+     */
+    protected function annotate_set_reference_bank_entries(
+        int $contextid,
+        string $component,
+        string $questionarea,
+        string $backupid,
+    ): void {
+        global $DB;
+        $setreferenceconditions = $DB->get_fieldset(
+            'question_set_references',
+            'filtercondition',
+            [
+                'usingcontextid' => $contextid,
+                'component' => $component,
+                'questionarea' => $questionarea,
+            ],
+        );
+        if (empty($setreferenceconditions)) {
+            return;
+        }
+        $setreferencequestionids = [];
+        $randomloader = new random_question_loader(new qubaid_list([]), []);
+        foreach ($setreferenceconditions as $setreferencecondition) {
+            $conditions = json_decode($setreferencecondition, true);
+            $setreferencequestionids += array_keys($randomloader->get_filtered_questions($conditions['filter'], 0));
+        }
+        if (empty($setreferencequestionids)) {
+            return;
+        }
+        [$insql, $inparams] = $DB->get_in_or_equal($setreferencequestionids);
+        $qbeids = $DB->get_fieldset_select(
+            'question_versions',
+            'questionbankentryid',
+            "questionid {$insql}",
+            $inparams,
+        );
+        foreach ($qbeids as $qbeid) {
+            backup_structure_dbops::insert_backup_ids_record($backupid, 'question_bank_entry', $qbeid);
+        }
+    }
+}
         // 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 ]);
+        // Custom fields.
+        if ($this->get_setting_value('customfield')) {
-        $handler = core_course\customfield\course_handler::create();
+            $handler = core_course\customfield\course_handler::create();
-        $fieldsforbackup = $handler->get_instance_data_for_backup($this->task->get_courseid());
+            $fieldsforbackup = $handler->get_instance_data_for_backup($this->task->get_courseid());
-        $handler->backup_define_structure($this->task->get_courseid(), $customfield);
+            $handler->backup_define_structure($this->task->get_courseid(), $customfield);
+            $customfield->set_source_array($fieldsforbackup);
         $customfield->set_source_array($fieldsforbackup);
  * 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;
         $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'));
+                'version', 'language', 'imagecaption'));
         $criteria = new backup_nested_element('criteria');
         $criterion = new backup_nested_element('criterion', array('id'), array('badgeid',
         $tag = new backup_nested_element('tag', ['id'], ['name', 'rawname']);
         // Build the tree.
+        $badges->add_child($badge);
+        // Have the activities been included? Only if that's the case, the criteria will be included too.
+        $activitiesincluded = !$this->task->is_excluding_activities();
-        $badges->add_child($badge);
+        if ($activitiesincluded) {
-        $badge->add_child($criteria);
+            $badge->add_child($criteria);
-        $criteria->add_child($criterion);
+            $criteria->add_child($criterion);
+            $criterion->add_child($parameters);
+            $parameters->add_child($parameter);
         $criterion->add_child($parameters);
         $parameters->add_child($parameter);
         $badge->add_child($endorsement);
         $badge->add_child($alignments);
         $alignments->add_child($alignment);
                 AND status != ' . BADGE_STATUS_ARCHIVED;
         $parameterparams = [
             'courseid' => backup::VAR_COURSEID
         ];
         $badge->set_source_sql($parametersql, $parameterparams);
+        if ($activitiesincluded) {
-        $criterion->set_source_table('badge_criteria', array('badgeid' => backup::VAR_PARENTID));
+            $criterion->set_source_table('badge_criteria', ['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 = ['critid' => backup::VAR_PARENTID];
+            $parameter->set_source_sql($parametersql, $parameterparams);
+        }
         $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);
+        $relatedbadge->set_source_table('badge_related', array('badgeid' => backup::VAR_PARENTID));
         $manual_award->set_source_table('badge_manual_award', array('badgeid' => backup::VAR_PARENTID));
         // Define id annotations.
+        $badge->annotate_ids('user', 'usercreated');
-        $badge->annotate_ids('user', 'usercreated');
+        $badge->annotate_ids('user', 'usermodified');
-        $badge->annotate_ids('user', 'usermodified');
+        if ($activitiesincluded) {
+            $criterion->annotate_ids('badge', 'badgeid');
-        $criterion->annotate_ids('badge', 'badgeid');
+            $parameter->annotate_ids('criterion', 'critid');
         $parameter->annotate_ids('criterion', 'critid');
         $endorsement->annotate_ids('badge', 'badgeid');
         $alignment->annotate_ids('badge', 'badgeid');
         $relatedbadge->annotate_ids('badge', 'badgeid');
             $group->set_source_sql("
                 SELECT g.*
                   FROM {groups} g
                   JOIN {backup_ids_temp} bi ON g.id = bi.itemid
                  WHERE bi.backupid = ?
-                   AND bi.itemname = 'groupfinal'", array(backup::VAR_BACKUPID));
+                   AND bi.itemname = 'groupfinal'",
+                [backup_helper::is_sqlparam($this->get_backupid())]
+            );
             $grouping->set_source_sql("
                 SELECT g.*
                   FROM {groupings} g
                   JOIN {backup_ids_temp} bi ON g.id = bi.itemid
                  WHERE bi.backupid = ?
+                   AND bi.itemname = 'groupingfinal'",
+                [backup_helper::is_sqlparam($this->get_backupid())]
+            );
                    AND bi.itemname = 'groupingfinal'", array(backup::VAR_BACKUPID));
             $groupinggroup->set_source_table('groupings_groups', array('groupingid' => backup::VAR_PARENTID));
             // This only happens if we are including users.
             if ($userinfo) {
+                $member->set_source_table('groups_members', array('groupid' => backup::VAR_PARENTID));
+            }
+            // Custom fields.
-                $member->set_source_table('groups_members', array('groupid' => backup::VAR_PARENTID));
+            if ($this->get_setting_value('customfield')) {
+                $groupcustomfieldarray = $this->get_group_custom_fields_for_backup(
-            }
+                    $group->get_source_sql(),
+                    [$this->get_backupid()]
+                );
+                $groupcustomfield->set_source_array($groupcustomfieldarray);
+                $groupingcustomfieldarray = $this->get_grouping_custom_fields_for_backup(
+                    $grouping->get_source_sql(),
+                    [$this->get_backupid()]
-            $courseid = $this->task->get_courseid();
+                );
-            $groupcustomfield->set_source_array($this->get_group_custom_fields_for_backup($courseid));
+                $groupingcustomfield->set_source_array($groupingcustomfieldarray);
             $groupingcustomfield->set_source_array($this->get_grouping_custom_fields_for_backup($courseid));
         return $groups;
+    }
     /**
+     * Get custom fields array for group
-     * Get custom fields array for group
+     *
+     * @param string $groupsourcesql
-     * @param int $courseid
+     * @param array $groupsourceparams
      * @return array
      */
-    protected function get_group_custom_fields_for_backup(int $courseid): array {
+    protected function get_group_custom_fields_for_backup(string $groupsourcesql, array $groupsourceparams): array {
         global $DB;
         $handler = \core_group\customfield\group_handler::create();
         $fieldsforbackup = [];
-        if ($groups = $DB->get_records('groups', ['courseid' => $courseid], '', 'id')) {
+        if ($groups = $DB->get_records_sql($groupsourcesql, $groupsourceparams)) {
             foreach ($groups as $group) {
                 $fieldsforbackup = array_merge($fieldsforbackup, $handler->get_instance_data_for_backup($group->id));
+            }
+        }
         return $fieldsforbackup;
+    }
+    /**
-    /**
+     * Get custom fields array for grouping
+     *
-     * Get custom fields array for grouping
+     * @param string $groupingsourcesql
-     * @param int $courseid
+     * @param array $groupingsourceparams
      * @return array
      */
-    protected function get_grouping_custom_fields_for_backup(int $courseid): array {
+    protected function get_grouping_custom_fields_for_backup(string $groupingsourcesql, array $groupingsourceparams): array {
         global $DB;
         $handler = \core_group\customfield\grouping_handler::create();
         $fieldsforbackup = [];
-        if ($groupings = $DB->get_records('groupings', ['courseid' => $courseid], '', 'id')) {
+        if ($groupings = $DB->get_records_sql($groupingsourcesql, $groupingsourceparams)) {
             foreach ($groupings as $grouping) {
                 $fieldsforbackup = array_merge($fieldsforbackup, $handler->get_instance_data_for_backup($grouping->id));
+            }
         $contents = new backup_nested_element('contents');
+        $activities = new backup_nested_element('activities');
-        $activities = new backup_nested_element('activities');
+        $activity = new backup_nested_element(
+            'activity',
-        $activity = new backup_nested_element('activity', null, array(
+            null,
-            'moduleid', 'sectionid', 'modulename', 'title',
+            ['moduleid', 'sectionid', 'modulename', 'title', 'directory', 'insubsection']
+        );
-            'directory'));
+        $sections = new backup_nested_element('sections');
         $section = new backup_nested_element(
-        $sections = new backup_nested_element('sections');
+            'section',
             null,
  * question categories and questions required by the backup
  * and letters related to one activity.
  */
 class backup_questions_structure_step extends backup_structure_step {
+    #[\Override]
+    public function execute() {
+        global $DB;
+        backup_controller_dbops::create_question_category_temp_tables();
+        $DB->execute("INSERT INTO {question_category_complete_temp} (backupid, itemid)
+            SELECT backupid, itemid
+             FROM {backup_ids_temp}
+            WHERE itemname = 'question_category_complete'");
+        $DB->execute("INSERT INTO {question_category_partial_temp} (backupid, itemid)
+            SELECT backupid, itemid
+             FROM {backup_ids_temp}
+            WHERE itemname = 'question_category_partial'");
+        $results = parent::execute();
+        backup_controller_dbops::drop_question_category_temp_tables();
+        return $results;
+    }
     protected function define_structure() {
               JOIN {backup_ids_temp} bi ON bi.itemid = gc.id
               JOIN {context} co ON co.id = gc.contextid
              WHERE bi.backupid = ?
                AND bi.itemname = 'question_categoryfinal'", [backup::VAR_BACKUPID]);
+        // Add all question bank entries from "complete" categories, plus annotated question bank entires
+        // from "partial" categories.
+        $questionbankentry->set_source_sql(
+            "
+                SELECT qbe.*
+                 FROM {question_bank_entries} qbe
+                 JOIN {question_category_complete_temp} qcc ON qcc.itemid = qbe.questioncategoryid
+                WHERE qcc.itemid = ?
+                      AND qcc.backupid = ?
+                UNION
+                SELECT qbe.*
+                 FROM {question_bank_entries} qbe
+                 JOIN {question_category_partial_temp} qcp ON qcp.itemid = qbe.questioncategoryid
+                 JOIN {backup_ids_temp} biq ON biq.itemid = qbe.id
+                WHERE qcp.itemid = ?
+                      AND qcp.backupid = ?
+                      AND biq.backupid = ?
+                      AND biq.itemname = 'question_bank_entry'
+            ",
+            [
+                backup::VAR_PARENTID,
+                backup::VAR_BACKUPID,
+                backup::VAR_PARENTID,
+                backup::VAR_BACKUPID,
+                backup::VAR_BACKUPID,
+            ],
-        $questionbankentry->set_source_table('question_bank_entries', ['questioncategoryid' => backup::VAR_PARENTID]);
+        );
         $questionverion->set_source_table('question_versions', ['questionbankentryid' => backup::VAR_PARENTID]);

Proyectos de Subversion Moodle

(root)/backup/moodle2/backup_stepslib.php – Rev 1 → 1441