mod/assign/upgradelib.php

   1 <?php
   2 // This file is part of Moodle - http://moodle.org/
   3 //
   4 // Moodle is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, either version 3 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // Moodle is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 /**
  18  * This file contains the upgrade code to upgrade from mod_assignment to mod_assign
  19  *
  20  * @package   mod_assign
  21  * @copyright 2012 NetSpot {@link http://www.netspot.com.au}
  22  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23  */
  24
  25 defined('MOODLE_INTERNAL') || die();
  26
  27 require_once($CFG->dirroot.'/mod/assign/locallib.php');
  28 require_once($CFG->libdir.'/accesslib.php');
  29 require_once($CFG->dirroot.'/course/lib.php');
  30
  31 /*
  32  * The maximum amount of time to spend upgrading a single assignment.
  33  * This is intentionally generous (5 mins) as the effect of a timeout
  34  * for a legitimate upgrade would be quite harsh (roll back code will not run)
  35  */
  36 define('ASSIGN_MAX_UPGRADE_TIME_SECS', 300);
  37
  38 /**
  39  * Class to manage upgrades from mod_assignment to mod_assign
  40  *
  41  * @package   mod_assign
  42  * @copyright 2012 NetSpot {@link http://www.netspot.com.au}
  43  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  44  */
  45 class assign_upgrade_manager {
  46
  47     /**
  48      * This function converts all of the base settings for an instance of
  49      * the old assignment to the new format. Then it calls each of the plugins
  50      * to see if they can help upgrade this assignment.
  51      * @param int $oldassignmentid (don't rely on the old assignment type even being installed)
  52      * @param string $log This string gets appended to during the conversion process
  53      * @return bool true or false
  54      */
  55     public function upgrade_assignment($oldassignmentid, & $log) {
  56         global $DB, $CFG, $USER;
  57         // Steps to upgrade an assignment.
  58
  59         core_php_time_limit::raise(ASSIGN_MAX_UPGRADE_TIME_SECS);
  60
  61         // Get the module details.
  62         $oldmodule = $DB->get_record('modules', array('name'=>'assignment'), '*', MUST_EXIST);
  63         $params = array('module'=>$oldmodule->id, 'instance'=>$oldassignmentid);
  64         $oldcoursemodule = $DB->get_record('course_modules',
  65                                            $params,
  66                                            '*',
  67                                            MUST_EXIST);
  68         $oldcontext = context_module::instance($oldcoursemodule->id);
  69         // We used to check for admin capability, but since Moodle 2.7 this is called
  70         // during restore of a mod_assignment module.
  71         // Also note that we do not check for any mod_assignment capabilities, because they can
  72         // be removed so that users don't add new instances of the broken old thing.
  73         if (!has_capability('mod/assign:addinstance', $oldcontext)) {
  74             $log = get_string('couldnotcreatenewassignmentinstance', 'mod_assign');
  75             return false;
  76         }
  77
  78         // First insert an assign instance to get the id.
  79         $oldassignment = $DB->get_record('assignment', array('id'=>$oldassignmentid), '*', MUST_EXIST);
  80
  81         $oldversion = get_config('assignment_' . $oldassignment->assignmenttype, 'version');
  82
  83         $data = new stdClass();
  84         $data->course = $oldassignment->course;
  85         $data->name = $oldassignment->name;
  86         $data->intro = $oldassignment->intro;
  87         $data->introformat = $oldassignment->introformat;
  88         $data->alwaysshowdescription = 1;
  89         $data->sendnotifications = $oldassignment->emailteachers;
  90         $data->sendlatenotifications = $oldassignment->emailteachers;
  91         $data->duedate = $oldassignment->timedue;
  92         $data->allowsubmissionsfromdate = $oldassignment->timeavailable;
  93         $data->grade = $oldassignment->grade;
  94         $data->submissiondrafts = $oldassignment->resubmit;
  95         $data->requiresubmissionstatement = 0;
  96         $data->markingworkflow = 0;
  97         $data->markingallocation = 0;
  98         $data->cutoffdate = 0;
  99         // New way to specify no late submissions.
 100         if ($oldassignment->preventlate) {
 101             $data->cutoffdate = $data->duedate;
 102         }
 103         $data->teamsubmission = 0;
 104         $data->requireallteammemberssubmit = 0;
 105         $data->teamsubmissiongroupingid = 0;
 106         $data->blindmarking = 0;
 107         $data->attemptreopenmethod = 'none';
 108         $data->maxattempts = ASSIGN_UNLIMITED_ATTEMPTS;
 109
 110         $newassignment = new assign(null, null, null);
 111
 112         if (!$newassignment->add_instance($data, false)) {
 113             $log = get_string('couldnotcreatenewassignmentinstance', 'mod_assign');
 114             return false;
 115         }
 116
 117         // Now create a new coursemodule from the old one.
 118         $newmodule = $DB->get_record('modules', array('name'=>'assign'), '*', MUST_EXIST);
 119         $newcoursemodule = $this->duplicate_course_module($oldcoursemodule,
 120                                                           $newmodule->id,
 121                                                           $newassignment->get_instance()->id);
 122         if (!$newcoursemodule) {
 123             $log = get_string('couldnotcreatenewcoursemodule', 'mod_assign');
 124             return false;
 125         }
 126
 127         // Convert the base database tables (assignment, submission, grade).
 128
 129         // These are used to store information in case a rollback is required.
 130         $gradingarea = null;
 131         $gradingdefinitions = null;
 132         $gradeidmap = array();
 133         $completiondone = false;
 134         $gradesdone = false;
 135
 136         // From this point we want to rollback on failure.
 137         $rollback = false;
 138         try {
 139             $newassignment->set_context(context_module::instance($newcoursemodule->id));
 140
 141             // The course module has now been created - time to update the core tables.
 142
 143             // Copy intro files.
 144             $newassignment->copy_area_files_for_upgrade($oldcontext->id, 'mod_assignment', 'intro', 0,
 145                                             $newassignment->get_context()->id, 'mod_assign', 'intro', 0);
 146
 147             // Get the plugins to do their bit.
 148             foreach ($newassignment->get_submission_plugins() as $plugin) {
 149                 if ($plugin->can_upgrade($oldassignment->assignmenttype, $oldversion)) {
 150                     $plugin->enable();
 151                     if (!$plugin->upgrade_settings($oldcontext, $oldassignment, $log)) {
 152                         $rollback = true;
 153                     }
 154                 } else {
 155                     $plugin->disable();
 156                 }
 157             }
 158             foreach ($newassignment->get_feedback_plugins() as $plugin) {
 159                 if ($plugin->can_upgrade($oldassignment->assignmenttype, $oldversion)) {
 160                     $plugin->enable();
 161                     if (!$plugin->upgrade_settings($oldcontext, $oldassignment, $log)) {
 162                         $rollback = true;
 163                     }
 164                 } else {
 165                     $plugin->disable();
 166                 }
 167             }
 168
 169             // See if there is advanced grading upgrades required.
 170             $gradingarea = $DB->get_record('grading_areas',
 171                                            array('contextid'=>$oldcontext->id, 'areaname'=>'submission'),
 172                                            '*',
 173                                            IGNORE_MISSING);
 174             if ($gradingarea) {
 175                 $params = array('id'=>$gradingarea->id,
 176                                 'contextid'=>$newassignment->get_context()->id,
 177                                 'component'=>'mod_assign',
 178                                 'areaname'=>'submissions');
 179                 $DB->update_record('grading_areas', $params);
 180                 $gradingdefinitions = $DB->get_records('grading_definitions',
 181                                                        array('areaid'=>$gradingarea->id));
 182             }
 183
 184             // Upgrade availability data.
 185             \core_availability\info::update_dependency_id_across_course(
 186                     $newcoursemodule->course, 'course_modules', $oldcoursemodule->id, $newcoursemodule->id);
 187
 188             // Upgrade completion data.
 189             $DB->set_field('course_modules_completion',
 190                            'coursemoduleid',
 191                            $newcoursemodule->id,
 192                            array('coursemoduleid'=>$oldcoursemodule->id));
 193             $allcriteria = $DB->get_records('course_completion_criteria',
 194                                             array('moduleinstance'=>$oldcoursemodule->id));
 195             foreach ($allcriteria as $criteria) {
 196                 $criteria->module = 'assign';
 197                 $criteria->moduleinstance = $newcoursemodule->id;
 198                 $DB->update_record('course_completion_criteria', $criteria);
 199             }
 200             $completiondone = true;
 201
 202             // Migrate log entries so we don't lose them.
 203             $logparams = array('cmid' => $oldcoursemodule->id, 'course' => $oldcoursemodule->course);
 204             $DB->set_field('log', 'module', 'assign', $logparams);
 205             $DB->set_field('log', 'cmid', $newcoursemodule->id, $logparams);
 206
 207             // Copy all the submission data (and get plugins to do their bit).
 208             $oldsubmissions = $DB->get_records('assignment_submissions',
 209                                                array('assignment'=>$oldassignmentid));
 210
 211             foreach ($oldsubmissions as $oldsubmission) {
 212                 $submission = new stdClass();
 213                 $submission->assignment = $newassignment->get_instance()->id;
 214                 $submission->userid = $oldsubmission->userid;
 215                 $submission->timecreated = $oldsubmission->timecreated;
 216                 $submission->timemodified = $oldsubmission->timemodified;
 217                 $submission->status = ASSIGN_SUBMISSION_STATUS_SUBMITTED;
 218                 $submission->id = $DB->insert_record('assign_submission', $submission);
 219                 if (!$submission->id) {
 220                     $log .= get_string('couldnotinsertsubmission', 'mod_assign', $submission->userid);
 221                     $rollback = true;
 222                 }
 223                 foreach ($newassignment->get_submission_plugins() as $plugin) {
 224                     if ($plugin->can_upgrade($oldassignment->assignmenttype, $oldversion)) {
 225                         if (!$plugin->upgrade($oldcontext,
 226                                               $oldassignment,
 227                                               $oldsubmission,
 228                                               $submission,
 229                                               $log)) {
 230                             $rollback = true;
 231                         }
 232                     }
 233                 }
 234                 if ($oldsubmission->timemarked) {
 235                     // Submission has been graded - create a grade record.
 236                     $grade = new stdClass();
 237                     $grade->assignment = $newassignment->get_instance()->id;
 238                     $grade->userid = $oldsubmission->userid;
 239                     $grade->grader = $oldsubmission->teacher;
 240                     $grade->timemodified = $oldsubmission->timemarked;
 241                     $grade->timecreated = $oldsubmission->timecreated;
 242                     $grade->grade = $oldsubmission->grade;
 243                     if ($oldsubmission->mailed) {
 244                         // The mailed flag goes in the flags table.
 245                         $flags = new stdClass();
 246                         $flags->userid = $oldsubmission->userid;
 247                         $flags->assignment = $newassignment->get_instance()->id;
 248                         $flags->mailed = 1;
 249                         $DB->insert_record('assign_user_flags', $flags);
 250                     }
 251                     $grade->id = $DB->insert_record('assign_grades', $grade);
 252                     if (!$grade->id) {
 253                         $log .= get_string('couldnotinsertgrade', 'mod_assign', $grade->userid);
 254                         $rollback = true;
 255                     }
 256
 257                     // Copy any grading instances.
 258                     if ($gradingarea) {
 259
 260                         $gradeidmap[$grade->id] = $oldsubmission->id;
 261
 262                         foreach ($gradingdefinitions as $definition) {
 263                             $params = array('definitionid'=>$definition->id,
 264                                             'itemid'=>$oldsubmission->id);
 265                             $DB->set_field('grading_instances', 'itemid', $grade->id, $params);
 266                         }
 267
 268                     }
 269                     foreach ($newassignment->get_feedback_plugins() as $plugin) {
 270                         if ($plugin->can_upgrade($oldassignment->assignmenttype, $oldversion)) {
 271                             if (!$plugin->upgrade($oldcontext,
 272                                                   $oldassignment,
 273                                                   $oldsubmission,
 274                                                   $grade,
 275                                                   $log)) {
 276                                 $rollback = true;
 277                             }
 278                         }
 279                     }
 280                 }
 281             }
 282
 283             $newassignment->update_calendar($newcoursemodule->id);
 284
 285             // Reassociate grade_items from the old assignment instance to the new assign instance.
 286             // This includes outcome linked grade_items.
 287             $params = array('assign', $newassignment->get_instance()->id, 'assignment', $oldassignment->id);
 288             $sql = 'UPDATE {grade_items} SET itemmodule = ?, iteminstance = ? WHERE itemmodule = ? AND iteminstance = ?';
 289             $DB->execute($sql, $params);
 290
 291             // Create a mapping record to map urls from the old to the new assignment.
 292             $mapping = new stdClass();
 293             $mapping->oldcmid = $oldcoursemodule->id;
 294             $mapping->oldinstance = $oldassignment->id;
 295             $mapping->newcmid = $newcoursemodule->id;
 296             $mapping->newinstance = $newassignment->get_instance()->id;
 297             $mapping->timecreated = time();
 298             $DB->insert_record('assignment_upgrade', $mapping);
 299
 300             $gradesdone = true;
 301
 302         } catch (Exception $exception) {
 303             $rollback = true;
 304             $log .= get_string('conversionexception', 'mod_assign', $exception->getMessage());
 305         }
 306
 307         if ($rollback) {
 308             // Roll back the grades changes.
 309             if ($gradesdone) {
 310                 // Reassociate grade_items from the new assign instance to the old assignment instance.
 311                 $params = array('assignment', $oldassignment->id, 'assign', $newassignment->get_instance()->id);
 312                 $sql = 'UPDATE {grade_items} SET itemmodule = ?, iteminstance = ? WHERE itemmodule = ? AND iteminstance = ?';
 313                 $DB->execute($sql, $params);
 314             }
 315             // Roll back the completion changes.
 316             if ($completiondone) {
 317                 $DB->set_field('course_modules_completion',
 318                                'coursemoduleid',
 319                                $oldcoursemodule->id,
 320                                array('coursemoduleid'=>$newcoursemodule->id));
 321
 322                 $allcriteria = $DB->get_records('course_completion_criteria',
 323                                                 array('moduleinstance'=>$newcoursemodule->id));
 324                 foreach ($allcriteria as $criteria) {
 325                     $criteria->module = 'assignment';
 326                     $criteria->moduleinstance = $oldcoursemodule->id;
 327                     $DB->update_record('course_completion_criteria', $criteria);
 328                 }
 329             }
 330             // Roll back the log changes.
 331             $logparams = array('cmid' => $newcoursemodule->id, 'course' => $newcoursemodule->course);
 332             $DB->set_field('log', 'module', 'assignment', $logparams);
 333             $DB->set_field('log', 'cmid', $oldcoursemodule->id, $logparams);
 334             // Roll back the advanced grading update.
 335             if ($gradingarea) {
 336                 foreach ($gradeidmap as $newgradeid => $oldsubmissionid) {
 337                     foreach ($gradingdefinitions as $definition) {
 338                         $DB->set_field('grading_instances',
 339                                        'itemid',
 340                                        $oldsubmissionid,
 341                                        array('definitionid'=>$definition->id, 'itemid'=>$newgradeid));
 342                     }
 343                 }
 344                 $params = array('id'=>$gradingarea->id,
 345                                 'contextid'=>$oldcontext->id,
 346                                 'component'=>'mod_assignment',
 347                                 'areaname'=>'submission');
 348                 $DB->update_record('grading_areas', $params);
 349             }
 350             $newassignment->delete_instance();
 351
 352             return false;
 353         }
 354         // Delete the old assignment (use object delete).
 355         $cm = get_coursemodule_from_id('', $oldcoursemodule->id, $oldcoursemodule->course);
 356         if ($cm) {
 357             course_delete_module($cm->id);
 358         }
 359         rebuild_course_cache($oldcoursemodule->course);
 360         return true;
 361     }
 362
 363
 364     /**
 365      * Create a duplicate course module record so we can create the upgraded
 366      * assign module alongside the old assignment module.
 367      *
 368      * @param stdClass $cm The old course module record
 369      * @param int $moduleid The id of the new assign module
 370      * @param int $newinstanceid The id of the new instance of the assign module
 371      * @return mixed stdClass|bool The new course module record or FALSE
 372      */
 373     private function duplicate_course_module(stdClass $cm, $moduleid, $newinstanceid) {
 374         global $DB, $CFG;
 375
 376         $newcm = new stdClass();
 377         $newcm->course           = $cm->course;
 378         $newcm->module           = $moduleid;
 379         $newcm->instance         = $newinstanceid;
 380         $newcm->visible          = $cm->visible;
 381         $newcm->section          = $cm->section;
 382         $newcm->score            = $cm->score;
 383         $newcm->indent           = $cm->indent;
 384         $newcm->groupmode        = $cm->groupmode;
 385         $newcm->groupingid       = $cm->groupingid;
 386         $newcm->groupmembersonly = $cm->groupmembersonly;
 387         $newcm->completion                = $cm->completion;
 388         $newcm->completiongradeitemnumber = $cm->completiongradeitemnumber;
 389         $newcm->completionview            = $cm->completionview;
 390         $newcm->completionexpected        = $cm->completionexpected;
 391         if (!empty($CFG->enableavailability)) {
 392             $newcm->availability = $cm->availability;
 393         }
 394         $newcm->showdescription = $cm->showdescription;
 395
 396         $newcmid = add_course_module($newcm);
 397         $newcm = get_coursemodule_from_id('', $newcmid, $cm->course);
 398         if (!$newcm) {
 399             return false;
 400         }
 401         $section = $DB->get_record("course_sections", array("id"=>$newcm->section));
 402         if (!$section) {
 403             return false;
 404         }
 405
 406         $newcm->section = course_add_cm_to_section($newcm->course, $newcm->id, $section->section, $cm->id);
 407
 408         // Make sure visibility is set correctly (in particular in calendar).
 409         // Note: Allow them to set it even without moodle/course:activityvisibility.
 410         set_coursemodule_visible($newcm->id, $newcm->visible);
 411
 412         return $newcm;
 413     }
 414 }