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         $data->gradingduedate = 0;
 100         // New way to specify no late submissions.
 101         if ($oldassignment->preventlate) {
 102             $data->cutoffdate = $data->duedate;
 103         }
 104         $data->teamsubmission = 0;
 105         $data->requireallteammemberssubmit = 0;
 106         $data->teamsubmissiongroupingid = 0;
 107         $data->blindmarking = 0;
 108         $data->attemptreopenmethod = 'none';
 109         $data->maxattempts = ASSIGN_UNLIMITED_ATTEMPTS;
 110
 111         $newassignment = new assign(null, null, null);
 112
 113         if (!$newassignment->add_instance($data, false)) {
 114             $log = get_string('couldnotcreatenewassignmentinstance', 'mod_assign');
 115             return false;
 116         }
 117
 118         // Now create a new coursemodule from the old one.
 119         $newmodule = $DB->get_record('modules', array('name'=>'assign'), '*', MUST_EXIST);
 120         $newcoursemodule = $this->duplicate_course_module($oldcoursemodule,
 121                                                           $newmodule->id,
 122                                                           $newassignment->get_instance()->id);
 123         if (!$newcoursemodule) {
 124             $log = get_string('couldnotcreatenewcoursemodule', 'mod_assign');
 125             return false;
 126         }
 127
 128         // Convert the base database tables (assignment, submission, grade).
 129
 130         // These are used to store information in case a rollback is required.
 131         $gradingarea = null;
 132         $gradingdefinitions = null;
 133         $gradeidmap = array();
 134         $completiondone = false;
 135         $gradesdone = false;
 136
 137         // From this point we want to rollback on failure.
 138         $rollback = false;
 139         try {
 140             $newassignment->set_context(context_module::instance($newcoursemodule->id));
 141
 142             // The course module has now been created - time to update the core tables.
 143
 144             // Copy intro files.
 145             $newassignment->copy_area_files_for_upgrade($oldcontext->id, 'mod_assignment', 'intro', 0,
 146                                             $newassignment->get_context()->id, 'mod_assign', 'intro', 0);
 147
 148             // Get the plugins to do their bit.
 149             foreach ($newassignment->get_submission_plugins() as $plugin) {
 150                 if ($plugin->can_upgrade($oldassignment->assignmenttype, $oldversion)) {
 151                     $plugin->enable();
 152                     if (!$plugin->upgrade_settings($oldcontext, $oldassignment, $log)) {
 153                         $rollback = true;
 154                     }
 155                 } else {
 156                     $plugin->disable();
 157                 }
 158             }
 159             foreach ($newassignment->get_feedback_plugins() as $plugin) {
 160                 if ($plugin->can_upgrade($oldassignment->assignmenttype, $oldversion)) {
 161                     $plugin->enable();
 162                     if (!$plugin->upgrade_settings($oldcontext, $oldassignment, $log)) {
 163                         $rollback = true;
 164                     }
 165                 } else {
 166                     $plugin->disable();
 167                 }
 168             }
 169
 170             // See if there is advanced grading upgrades required.
 171             $gradingarea = $DB->get_record('grading_areas',
 172                                            array('contextid'=>$oldcontext->id, 'areaname'=>'submission'),
 173                                            '*',
 174                                            IGNORE_MISSING);
 175             if ($gradingarea) {
 176                 $params = array('id'=>$gradingarea->id,
 177                                 'contextid'=>$newassignment->get_context()->id,
 178                                 'component'=>'mod_assign',
 179                                 'areaname'=>'submissions');
 180                 $DB->update_record('grading_areas', $params);
 181                 $gradingdefinitions = $DB->get_records('grading_definitions',
 182                                                        array('areaid'=>$gradingarea->id));
 183             }
 184
 185             // Upgrade availability data.
 186             \core_availability\info::update_dependency_id_across_course(
 187                     $newcoursemodule->course, 'course_modules', $oldcoursemodule->id, $newcoursemodule->id);
 188
 189             // Upgrade completion data.
 190             $DB->set_field('course_modules_completion',
 191                            'coursemoduleid',
 192                            $newcoursemodule->id,
 193                            array('coursemoduleid'=>$oldcoursemodule->id));
 194             $allcriteria = $DB->get_records('course_completion_criteria',
 195                                             array('moduleinstance'=>$oldcoursemodule->id));
 196             foreach ($allcriteria as $criteria) {
 197                 $criteria->module = 'assign';
 198                 $criteria->moduleinstance = $newcoursemodule->id;
 199                 $DB->update_record('course_completion_criteria', $criteria);
 200             }
 201             $completiondone = true;
 202
 203             // Migrate log entries so we don't lose them.
 204             $logparams = array('cmid' => $oldcoursemodule->id, 'course' => $oldcoursemodule->course);
 205             $DB->set_field('log', 'module', 'assign', $logparams);
 206             $DB->set_field('log', 'cmid', $newcoursemodule->id, $logparams);
 207
 208             // Copy all the submission data (and get plugins to do their bit).
 209             $oldsubmissions = $DB->get_records('assignment_submissions',
 210                                                array('assignment'=>$oldassignmentid));
 211
 212             foreach ($oldsubmissions as $oldsubmission) {
 213                 $submission = new stdClass();
 214                 $submission->assignment = $newassignment->get_instance()->id;
 215                 $submission->userid = $oldsubmission->userid;
 216                 $submission->timecreated = $oldsubmission->timecreated;
 217                 $submission->timemodified = $oldsubmission->timemodified;
 218                 $submission->status = ASSIGN_SUBMISSION_STATUS_SUBMITTED;
 219                 // Because in mod_assignment there could only be one submission per student, it is always the latest.
 220                 $submission->latest = 1;
 221                 $submission->id = $DB->insert_record('assign_submission', $submission);
 222                 if (!$submission->id) {
 223                     $log .= get_string('couldnotinsertsubmission', 'mod_assign', $submission->userid);
 224                     $rollback = true;
 225                 }
 226                 foreach ($newassignment->get_submission_plugins() as $plugin) {
 227                     if ($plugin->can_upgrade($oldassignment->assignmenttype, $oldversion)) {
 228                         if (!$plugin->upgrade($oldcontext,
 229                                               $oldassignment,
 230                                               $oldsubmission,
 231                                               $submission,
 232                                               $log)) {
 233                             $rollback = true;
 234                         }
 235                     }
 236                 }
 237                 if ($oldsubmission->timemarked) {
 238                     // Submission has been graded - create a grade record.
 239                     $grade = new stdClass();
 240                     $grade->assignment = $newassignment->get_instance()->id;
 241                     $grade->userid = $oldsubmission->userid;
 242                     $grade->grader = $oldsubmission->teacher;
 243                     $grade->timemodified = $oldsubmission->timemarked;
 244                     $grade->timecreated = $oldsubmission->timecreated;
 245                     $grade->grade = $oldsubmission->grade;
 246                     if ($oldsubmission->mailed) {
 247                         // The mailed flag goes in the flags table.
 248                         $flags = new stdClass();
 249                         $flags->userid = $oldsubmission->userid;
 250                         $flags->assignment = $newassignment->get_instance()->id;
 251                         $flags->mailed = 1;
 252                         $DB->insert_record('assign_user_flags', $flags);
 253                     }
 254                     $grade->id = $DB->insert_record('assign_grades', $grade);
 255                     if (!$grade->id) {
 256                         $log .= get_string('couldnotinsertgrade', 'mod_assign', $grade->userid);
 257                         $rollback = true;
 258                     }
 259
 260                     // Copy any grading instances.
 261                     if ($gradingarea) {
 262
 263                         $gradeidmap[$grade->id] = $oldsubmission->id;
 264
 265                         foreach ($gradingdefinitions as $definition) {
 266                             $params = array('definitionid'=>$definition->id,
 267                                             'itemid'=>$oldsubmission->id);
 268                             $DB->set_field('grading_instances', 'itemid', $grade->id, $params);
 269                         }
 270
 271                     }
 272                     foreach ($newassignment->get_feedback_plugins() as $plugin) {
 273                         if ($plugin->can_upgrade($oldassignment->assignmenttype, $oldversion)) {
 274                             if (!$plugin->upgrade($oldcontext,
 275                                                   $oldassignment,
 276                                                   $oldsubmission,
 277                                                   $grade,
 278                                                   $log)) {
 279                                 $rollback = true;
 280                             }
 281                         }
 282                     }
 283                 }
 284             }
 285
 286             $newassignment->update_calendar($newcoursemodule->id);
 287
 288             // Reassociate grade_items from the old assignment instance to the new assign instance.
 289             // This includes outcome linked grade_items.
 290             $params = array('assign', $newassignment->get_instance()->id, 'assignment', $oldassignment->id);
 291             $sql = 'UPDATE {grade_items} SET itemmodule = ?, iteminstance = ? WHERE itemmodule = ? AND iteminstance = ?';
 292             $DB->execute($sql, $params);
 293
 294             // Create a mapping record to map urls from the old to the new assignment.
 295             $mapping = new stdClass();
 296             $mapping->oldcmid = $oldcoursemodule->id;
 297             $mapping->oldinstance = $oldassignment->id;
 298             $mapping->newcmid = $newcoursemodule->id;
 299             $mapping->newinstance = $newassignment->get_instance()->id;
 300             $mapping->timecreated = time();
 301             $DB->insert_record('assignment_upgrade', $mapping);
 302
 303             $gradesdone = true;
 304
 305         } catch (Exception $exception) {
 306             $rollback = true;
 307             $log .= get_string('conversionexception', 'mod_assign', $exception->getMessage());
 308         }
 309
 310         if ($rollback) {
 311             // Roll back the grades changes.
 312             if ($gradesdone) {
 313                 // Reassociate grade_items from the new assign instance to the old assignment instance.
 314                 $params = array('assignment', $oldassignment->id, 'assign', $newassignment->get_instance()->id);
 315                 $sql = 'UPDATE {grade_items} SET itemmodule = ?, iteminstance = ? WHERE itemmodule = ? AND iteminstance = ?';
 316                 $DB->execute($sql, $params);
 317             }
 318             // Roll back the completion changes.
 319             if ($completiondone) {
 320                 $DB->set_field('course_modules_completion',
 321                                'coursemoduleid',
 322                                $oldcoursemodule->id,
 323                                array('coursemoduleid'=>$newcoursemodule->id));
 324
 325                 $allcriteria = $DB->get_records('course_completion_criteria',
 326                                                 array('moduleinstance'=>$newcoursemodule->id));
 327                 foreach ($allcriteria as $criteria) {
 328                     $criteria->module = 'assignment';
 329                     $criteria->moduleinstance = $oldcoursemodule->id;
 330                     $DB->update_record('course_completion_criteria', $criteria);
 331                 }
 332             }
 333             // Roll back the log changes.
 334             $logparams = array('cmid' => $newcoursemodule->id, 'course' => $newcoursemodule->course);
 335             $DB->set_field('log', 'module', 'assignment', $logparams);
 336             $DB->set_field('log', 'cmid', $oldcoursemodule->id, $logparams);
 337             // Roll back the advanced grading update.
 338             if ($gradingarea) {
 339                 foreach ($gradeidmap as $newgradeid => $oldsubmissionid) {
 340                     foreach ($gradingdefinitions as $definition) {
 341                         $DB->set_field('grading_instances',
 342                                        'itemid',
 343                                        $oldsubmissionid,
 344                                        array('definitionid'=>$definition->id, 'itemid'=>$newgradeid));
 345                     }
 346                 }
 347                 $params = array('id'=>$gradingarea->id,
 348                                 'contextid'=>$oldcontext->id,
 349                                 'component'=>'mod_assignment',
 350                                 'areaname'=>'submission');
 351                 $DB->update_record('grading_areas', $params);
 352             }
 353             $newassignment->delete_instance();
 354
 355             return false;
 356         }
 357         // Delete the old assignment (use object delete).
 358         $cm = get_coursemodule_from_id('', $oldcoursemodule->id, $oldcoursemodule->course);
 359         if ($cm) {
 360             course_delete_module($cm->id);
 361         }
 362         rebuild_course_cache($oldcoursemodule->course);
 363         return true;
 364     }
 365
 366
 367     /**
 368      * Create a duplicate course module record so we can create the upgraded
 369      * assign module alongside the old assignment module.
 370      *
 371      * @param stdClass $cm The old course module record
 372      * @param int $moduleid The id of the new assign module
 373      * @param int $newinstanceid The id of the new instance of the assign module
 374      * @return mixed stdClass|bool The new course module record or FALSE
 375      */
 376     private function duplicate_course_module(stdClass $cm, $moduleid, $newinstanceid) {
 377         global $DB, $CFG;
 378
 379         $newcm = new stdClass();
 380         $newcm->course           = $cm->course;
 381         $newcm->module           = $moduleid;
 382         $newcm->instance         = $newinstanceid;
 383         $newcm->visible          = $cm->visible;
 384         $newcm->section          = $cm->section;
 385         $newcm->score            = $cm->score;
 386         $newcm->indent           = $cm->indent;
 387         $newcm->groupmode        = $cm->groupmode;
 388         $newcm->groupingid       = $cm->groupingid;
 389         $newcm->completion                = $cm->completion;
 390         $newcm->completiongradeitemnumber = $cm->completiongradeitemnumber;
 391         $newcm->completionview            = $cm->completionview;
 392         $newcm->completionexpected        = $cm->completionexpected;
 393         if (!empty($CFG->enableavailability)) {
 394             $newcm->availability = $cm->availability;
 395         }
 396         $newcm->showdescription = $cm->showdescription;
 397
 398         $newcmid = add_course_module($newcm);
 399         $newcm = get_coursemodule_from_id('', $newcmid, $cm->course);
 400         if (!$newcm) {
 401             return false;
 402         }
 403         $section = $DB->get_record("course_sections", array("id"=>$newcm->section));
 404         if (!$section) {
 405             return false;
 406         }
 407
 408         $newcm->section = course_add_cm_to_section($newcm->course, $newcm->id, $section->section, $cm->id);
 409
 410         // Make sure visibility is set correctly (in particular in calendar).
 411         // Note: Allow them to set it even without moodle/course:activityvisibility.
 412         set_coursemodule_visible($newcm->id, $newcm->visible);
 413
 414         return $newcm;
 415     }
 416 }