Merge branch 'MDL-39246' of git://github.com/timhunt/moodle
[moodle.git] / 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/>.
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  */
25 defined('MOODLE_INTERNAL') || die();
27 require_once($CFG->dirroot.'/mod/assign/locallib.php');
28 require_once($CFG->libdir.'/accesslib.php');
29 require_once($CFG->dirroot.'/course/lib.php');
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);
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 {
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.
59         // Is the user the admin? admin check goes here.
60         if (!is_siteadmin($USER->id)) {
61               return false;
62         }
64         @set_time_limit(ASSIGN_MAX_UPGRADE_TIME_SECS);
66         // Get the module details.
67         $oldmodule = $DB->get_record('modules', array('name'=>'assignment'), '*', MUST_EXIST);
68         $params = array('module'=>$oldmodule->id, 'instance'=>$oldassignmentid);
69         $oldcoursemodule = $DB->get_record('course_modules',
70                                            $params,
71                                            '*',
72                                            MUST_EXIST);
73         $oldcontext = context_module::instance($oldcoursemodule->id);
75         // First insert an assign instance to get the id.
76         $oldassignment = $DB->get_record('assignment', array('id'=>$oldassignmentid), '*', MUST_EXIST);
78         $oldversion = get_config('assignment_' . $oldassignment->assignmenttype, 'version');
80         $data = new stdClass();
81         $data->course = $oldassignment->course;
82         $data->name = $oldassignment->name;
83         $data->intro = $oldassignment->intro;
84         $data->introformat = $oldassignment->introformat;
85         $data->alwaysshowdescription = 1;
86         $data->sendnotifications = $oldassignment->emailteachers;
87         $data->sendlatenotifications = $oldassignment->emailteachers;
88         $data->duedate = $oldassignment->timedue;
89         $data->allowsubmissionsfromdate = $oldassignment->timeavailable;
90         $data->grade = $oldassignment->grade;
91         $data->submissiondrafts = $oldassignment->resubmit;
92         $data->requiresubmissionstatement = 0;
93         $data->cutoffdate = 0;
94         // New way to specify no late submissions.
95         if ($oldassignment->preventlate) {
96             $data->cutoffdate = $data->duedate;
97         }
98         $data->teamsubmission = 0;
99         $data->requireallteammemberssubmit = 0;
100         $data->teamsubmissiongroupingid = 0;
101         $data->blindmarking = 0;
102         $data->attemptreopenmethod = 'none';
103         $data->maxattempts = ASSIGN_UNLIMITED_ATTEMPTS;
105         $newassignment = new assign(null, null, null);
107         if (!$newassignment->add_instance($data, false)) {
108             $log = get_string('couldnotcreatenewassignmentinstance', 'mod_assign');
109             return false;
110         }
112         // Now create a new coursemodule from the old one.
113         $newmodule = $DB->get_record('modules', array('name'=>'assign'), '*', MUST_EXIST);
114         $newcoursemodule = $this->duplicate_course_module($oldcoursemodule,
115                                                           $newmodule->id,
116                                                           $newassignment->get_instance()->id);
117         if (!$newcoursemodule) {
118             $log = get_string('couldnotcreatenewcoursemodule', 'mod_assign');
119             return false;
120         }
122         // Convert the base database tables (assignment, submission, grade).
124         // These are used to store information in case a rollback is required.
125         $gradingarea = null;
126         $gradingdefinitions = null;
127         $gradeidmap = array();
128         $completiondone = false;
129         $gradesdone = false;
131         // From this point we want to rollback on failure.
132         $rollback = false;
133         try {
134             $newassignment->set_context(context_module::instance($newcoursemodule->id));
136             // The course module has now been created - time to update the core tables.
138             // Copy intro files.
139             $newassignment->copy_area_files_for_upgrade($oldcontext->id, 'mod_assignment', 'intro', 0,
140                                             $newassignment->get_context()->id, 'mod_assign', 'intro', 0);
142             // Get the plugins to do their bit.
143             foreach ($newassignment->get_submission_plugins() as $plugin) {
144                 if ($plugin->can_upgrade($oldassignment->assignmenttype, $oldversion)) {
145                     $plugin->enable();
146                     if (!$plugin->upgrade_settings($oldcontext, $oldassignment, $log)) {
147                         $rollback = true;
148                     }
149                 } else {
150                     $plugin->disable();
151                 }
152             }
153             foreach ($newassignment->get_feedback_plugins() as $plugin) {
154                 if ($plugin->can_upgrade($oldassignment->assignmenttype, $oldversion)) {
155                     $plugin->enable();
156                     if (!$plugin->upgrade_settings($oldcontext, $oldassignment, $log)) {
157                         $rollback = true;
158                     }
159                 } else {
160                     $plugin->disable();
161                 }
162             }
164             // See if there is advanced grading upgrades required.
165             $gradingarea = $DB->get_record('grading_areas',
166                                            array('contextid'=>$oldcontext->id, 'areaname'=>'submission'),
167                                            '*',
168                                            IGNORE_MISSING);
169             if ($gradingarea) {
170                 $params = array('id'=>$gradingarea->id,
171                                 'contextid'=>$newassignment->get_context()->id,
172                                 'component'=>'mod_assign',
173                                 'areaname'=>'submissions');
174                 $DB->update_record('grading_areas', $params);
175                 $gradingdefinitions = $DB->get_records('grading_definitions',
176                                                        array('areaid'=>$gradingarea->id));
177             }
179             // Upgrade availability data.
180             $DB->set_field('course_modules_avail_fields',
181                            'coursemoduleid',
182                            $newcoursemodule->id,
183                            array('coursemoduleid'=>$oldcoursemodule->id));
184             $DB->set_field('course_modules_availability',
185                            'coursemoduleid',
186                            $newcoursemodule->id,
187                            array('coursemoduleid'=>$oldcoursemodule->id));
188             $DB->set_field('course_modules_availability',
189                            'sourcecmid',
190                            $newcoursemodule->id,
191                            array('sourcecmid'=>$oldcoursemodule->id));
192             $DB->set_field('course_sections_availability',
193                            'sourcecmid',
194                            $newcoursemodule->id,
195                            array('sourcecmid'=>$oldcoursemodule->id));
197             // Upgrade completion data.
198             $DB->set_field('course_modules_completion',
199                            'coursemoduleid',
200                            $newcoursemodule->id,
201                            array('coursemoduleid'=>$oldcoursemodule->id));
202             $allcriteria = $DB->get_records('course_completion_criteria',
203                                             array('moduleinstance'=>$oldcoursemodule->id));
204             foreach ($allcriteria as $criteria) {
205                 $criteria->module = 'assign';
206                 $criteria->moduleinstance = $newcoursemodule->id;
207                 $DB->update_record('course_completion_criteria', $criteria);
208             }
209             $completiondone = true;
211             // Migrate log entries so we don't lose them.
212             $logparams = array('cmid' => $oldcoursemodule->id, 'course' => $oldcoursemodule->course);
213             $DB->set_field('log', 'module', 'assign', $logparams);
214             $DB->set_field('log', 'cmid', $newcoursemodule->id, $logparams);
216             // Copy all the submission data (and get plugins to do their bit).
217             $oldsubmissions = $DB->get_records('assignment_submissions',
218                                                array('assignment'=>$oldassignmentid));
220             foreach ($oldsubmissions as $oldsubmission) {
221                 $submission = new stdClass();
222                 $submission->assignment = $newassignment->get_instance()->id;
223                 $submission->userid = $oldsubmission->userid;
224                 $submission->timecreated = $oldsubmission->timecreated;
225                 $submission->timemodified = $oldsubmission->timemodified;
226                 $submission->status = ASSIGN_SUBMISSION_STATUS_SUBMITTED;
227                 $submission->id = $DB->insert_record('assign_submission', $submission);
228                 if (!$submission->id) {
229                     $log .= get_string('couldnotinsertsubmission', 'mod_assign', $submission->userid);
230                     $rollback = true;
231                 }
232                 foreach ($newassignment->get_submission_plugins() as $plugin) {
233                     if ($plugin->can_upgrade($oldassignment->assignmenttype, $oldversion)) {
234                         if (!$plugin->upgrade($oldcontext,
235                                               $oldassignment,
236                                               $oldsubmission,
237                                               $submission,
238                                               $log)) {
239                             $rollback = true;
240                         }
241                     }
242                 }
243                 if ($oldsubmission->timemarked) {
244                     // Submission has been graded - create a grade record.
245                     $grade = new stdClass();
246                     $grade->assignment = $newassignment->get_instance()->id;
247                     $grade->userid = $oldsubmission->userid;
248                     $grade->grader = $oldsubmission->teacher;
249                     $grade->timemodified = $oldsubmission->timemarked;
250                     $grade->timecreated = $oldsubmission->timecreated;
251                     $grade->grade = $oldsubmission->grade;
252                     if ($oldsubmission->mailed) {
253                         // The mailed flag goes in the flags table.
254                         $flags = new stdClass();
255                         $flags->userid = $oldsubmission->userid;
256                         $flags->assignment = $newassignment->get_instance()->id;
257                         $flags->mailed = 1;
258                         $DB->insert_record('assign_user_flags', $flags);
259                     }
260                     $grade->id = $DB->insert_record('assign_grades', $grade);
261                     if (!$grade->id) {
262                         $log .= get_string('couldnotinsertgrade', 'mod_assign', $grade->userid);
263                         $rollback = true;
264                     }
266                     // Copy any grading instances.
267                     if ($gradingarea) {
269                         $gradeidmap[$grade->id] = $oldsubmission->id;
271                         foreach ($gradingdefinitions as $definition) {
272                             $params = array('definitionid'=>$definition->id,
273                                             'itemid'=>$oldsubmission->id);
274                             $DB->set_field('grading_instances', 'itemid', $grade->id, $params);
275                         }
277                     }
278                     foreach ($newassignment->get_feedback_plugins() as $plugin) {
279                         if ($plugin->can_upgrade($oldassignment->assignmenttype, $oldversion)) {
280                             if (!$plugin->upgrade($oldcontext,
281                                                   $oldassignment,
282                                                   $oldsubmission,
283                                                   $grade,
284                                                   $log)) {
285                                 $rollback = true;
286                             }
287                         }
288                     }
289                 }
290             }
292             $newassignment->update_calendar($newcoursemodule->id);
294             // Reassociate grade_items from the old assignment instance to the new assign instance.
295             // This includes outcome linked grade_items.
296             $params = array('assign', $newassignment->get_instance()->id, 'assignment', $oldassignment->id);
297             $sql = 'UPDATE {grade_items} SET itemmodule = ?, iteminstance = ? WHERE itemmodule = ? AND iteminstance = ?';
298             $DB->execute($sql, $params);
300             $gradesdone = true;
302         } catch (Exception $exception) {
303             $rollback = true;
304             $log .= get_string('conversionexception', 'mod_assign', $exception->getMessage());
305         }
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));
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();
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     }
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;
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->availablefrom             = $cm->availablefrom;
393             $newcm->availableuntil            = $cm->availableuntil;
394             $newcm->showavailability          = $cm->showavailability;
395         }
396         $newcm->showdescription = $cm->showdescription;
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         }
408         $newcm->section = course_add_cm_to_section($newcm->course, $newcm->id, $section->section);
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);
414         return $newcm;
415     }