[Summary view] [Print] [Text view]

   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                  // Because in mod_assignment there could only be one submission per student, it is always the latest.
 219                  $submission->latest = 1;
 220                  $submission->id = $DB->insert_record('assign_submission', $submission);
 221                  if (!$submission->id) {
 222                      $log .= get_string('couldnotinsertsubmission', 'mod_assign', $submission->userid);
 223                      $rollback = true;
 224                  }
 225                  foreach ($newassignment->get_submission_plugins() as $plugin) {
 226                      if ($plugin->can_upgrade($oldassignment->assignmenttype, $oldversion)) {
 227                          if (!$plugin->upgrade($oldcontext,
 228                                                $oldassignment,
 229                                                $oldsubmission,
 230                                                $submission,
 231                                                $log)) {
 232                              $rollback = true;
 233                          }
 234                      }
 235                  }
 236                  if ($oldsubmission->timemarked) {
 237                      // Submission has been graded - create a grade record.
 238                      $grade = new stdClass();
 239                      $grade->assignment = $newassignment->get_instance()->id;
 240                      $grade->userid = $oldsubmission->userid;
 241                      $grade->grader = $oldsubmission->teacher;
 242                      $grade->timemodified = $oldsubmission->timemarked;
 243                      $grade->timecreated = $oldsubmission->timecreated;
 244                      $grade->grade = $oldsubmission->grade;
 245                      if ($oldsubmission->mailed) {
 246                          // The mailed flag goes in the flags table.
 247                          $flags = new stdClass();
 248                          $flags->userid = $oldsubmission->userid;
 249                          $flags->assignment = $newassignment->get_instance()->id;
 250                          $flags->mailed = 1;
 251                          $DB->insert_record('assign_user_flags', $flags);
 252                      }
 253                      $grade->id = $DB->insert_record('assign_grades', $grade);
 254                      if (!$grade->id) {
 255                          $log .= get_string('couldnotinsertgrade', 'mod_assign', $grade->userid);
 256                          $rollback = true;
 257                      }
 258  
 259                      // Copy any grading instances.
 260                      if ($gradingarea) {
 261  
 262                          $gradeidmap[$grade->id] = $oldsubmission->id;
 263  
 264                          foreach ($gradingdefinitions as $definition) {
 265                              $params = array('definitionid'=>$definition->id,
 266                                              'itemid'=>$oldsubmission->id);
 267                              $DB->set_field('grading_instances', 'itemid', $grade->id, $params);
 268                          }
 269  
 270                      }
 271                      foreach ($newassignment->get_feedback_plugins() as $plugin) {
 272                          if ($plugin->can_upgrade($oldassignment->assignmenttype, $oldversion)) {
 273                              if (!$plugin->upgrade($oldcontext,
 274                                                    $oldassignment,
 275                                                    $oldsubmission,
 276                                                    $grade,
 277                                                    $log)) {
 278                                  $rollback = true;
 279                              }
 280                          }
 281                      }
 282                  }
 283              }
 284  
 285              $newassignment->update_calendar($newcoursemodule->id);
 286  
 287              // Reassociate grade_items from the old assignment instance to the new assign instance.
 288              // This includes outcome linked grade_items.
 289              $params = array('assign', $newassignment->get_instance()->id, 'assignment', $oldassignment->id);
 290              $sql = 'UPDATE {grade_items} SET itemmodule = ?, iteminstance = ? WHERE itemmodule = ? AND iteminstance = ?';
 291              $DB->execute($sql, $params);
 292  
 293              // Create a mapping record to map urls from the old to the new assignment.
 294              $mapping = new stdClass();
 295              $mapping->oldcmid = $oldcoursemodule->id;
 296              $mapping->oldinstance = $oldassignment->id;
 297              $mapping->newcmid = $newcoursemodule->id;
 298              $mapping->newinstance = $newassignment->get_instance()->id;
 299              $mapping->timecreated = time();
 300              $DB->insert_record('assignment_upgrade', $mapping);
 301  
 302              $gradesdone = true;
 303  
 304          } catch (Exception $exception) {
 305              $rollback = true;
 306              $log .= get_string('conversionexception', 'mod_assign', $exception->getMessage());
 307          }
 308  
 309          if ($rollback) {
 310              // Roll back the grades changes.
 311              if ($gradesdone) {
 312                  // Reassociate grade_items from the new assign instance to the old assignment instance.
 313                  $params = array('assignment', $oldassignment->id, 'assign', $newassignment->get_instance()->id);
 314                  $sql = 'UPDATE {grade_items} SET itemmodule = ?, iteminstance = ? WHERE itemmodule = ? AND iteminstance = ?';
 315                  $DB->execute($sql, $params);
 316              }
 317              // Roll back the completion changes.
 318              if ($completiondone) {
 319                  $DB->set_field('course_modules_completion',
 320                                 'coursemoduleid',
 321                                 $oldcoursemodule->id,
 322                                 array('coursemoduleid'=>$newcoursemodule->id));
 323  
 324                  $allcriteria = $DB->get_records('course_completion_criteria',
 325                                                  array('moduleinstance'=>$newcoursemodule->id));
 326                  foreach ($allcriteria as $criteria) {
 327                      $criteria->module = 'assignment';
 328                      $criteria->moduleinstance = $oldcoursemodule->id;
 329                      $DB->update_record('course_completion_criteria', $criteria);
 330                  }
 331              }
 332              // Roll back the log changes.
 333              $logparams = array('cmid' => $newcoursemodule->id, 'course' => $newcoursemodule->course);
 334              $DB->set_field('log', 'module', 'assignment', $logparams);
 335              $DB->set_field('log', 'cmid', $oldcoursemodule->id, $logparams);
 336              // Roll back the advanced grading update.
 337              if ($gradingarea) {
 338                  foreach ($gradeidmap as $newgradeid => $oldsubmissionid) {
 339                      foreach ($gradingdefinitions as $definition) {
 340                          $DB->set_field('grading_instances',
 341                                         'itemid',
 342                                         $oldsubmissionid,
 343                                         array('definitionid'=>$definition->id, 'itemid'=>$newgradeid));
 344                      }
 345                  }
 346                  $params = array('id'=>$gradingarea->id,
 347                                  'contextid'=>$oldcontext->id,
 348                                  'component'=>'mod_assignment',
 349                                  'areaname'=>'submission');
 350                  $DB->update_record('grading_areas', $params);
 351              }
 352              $newassignment->delete_instance();
 353  
 354              return false;
 355          }
 356          // Delete the old assignment (use object delete).
 357          $cm = get_coursemodule_from_id('', $oldcoursemodule->id, $oldcoursemodule->course);
 358          if ($cm) {
 359              course_delete_module($cm->id);
 360          }
 361          rebuild_course_cache($oldcoursemodule->course);
 362          return true;
 363      }
 364  
 365  
 366      /**
 367       * Create a duplicate course module record so we can create the upgraded
 368       * assign module alongside the old assignment module.
 369       *
 370       * @param stdClass $cm The old course module record
 371       * @param int $moduleid The id of the new assign module
 372       * @param int $newinstanceid The id of the new instance of the assign module
 373       * @return mixed stdClass|bool The new course module record or FALSE
 374       */
 375      private function duplicate_course_module(stdClass $cm, $moduleid, $newinstanceid) {
 376          global $DB, $CFG;
 377  
 378          $newcm = new stdClass();
 379          $newcm->course           = $cm->course;
 380          $newcm->module           = $moduleid;
 381          $newcm->instance         = $newinstanceid;
 382          $newcm->visible          = $cm->visible;
 383          $newcm->section          = $cm->section;
 384          $newcm->score            = $cm->score;
 385          $newcm->indent           = $cm->indent;
 386          $newcm->groupmode        = $cm->groupmode;
 387          $newcm->groupingid       = $cm->groupingid;
 388          $newcm->completion                = $cm->completion;
 389          $newcm->completiongradeitemnumber = $cm->completiongradeitemnumber;
 390          $newcm->completionview            = $cm->completionview;
 391          $newcm->completionexpected        = $cm->completionexpected;
 392          if (!empty($CFG->enableavailability)) {
 393              $newcm->availability = $cm->availability;
 394          }
 395          $newcm->showdescription = $cm->showdescription;
 396  
 397          $newcmid = add_course_module($newcm);
 398          $newcm = get_coursemodule_from_id('', $newcmid, $cm->course);
 399          if (!$newcm) {
 400              return false;
 401          }
 402          $section = $DB->get_record("course_sections", array("id"=>$newcm->section));
 403          if (!$section) {
 404              return false;
 405          }
 406  
 407          $newcm->section = course_add_cm_to_section($newcm->course, $newcm->id, $section->section, $cm->id);
 408  
 409          // Make sure visibility is set correctly (in particular in calendar).
 410          // Note: Allow them to set it even without moodle/course:activityvisibility.
 411          set_coursemodule_visible($newcm->id, $newcm->visible);
 412  
 413          return $newcm;
 414      }
 415  }