f082eabd40634a41090cbfac22f99cb93426554a
[moodle.git] / admin / tool / uploadcourse / classes / course.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  * File containing the course class.
19  *
20  * @package    tool_uploadcourse
21  * @copyright  2013 Frédéric Massart
22  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
23  */
25 defined('MOODLE_INTERNAL') || die();
26 require_once($CFG->dirroot . '/backup/util/includes/restore_includes.php');
27 require_once($CFG->dirroot . '/course/lib.php');
29 /**
30  * Course class.
31  *
32  * @package    tool_uploadcourse
33  * @copyright  2013 Frédéric Massart
34  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
35  */
36 class tool_uploadcourse_course {
38     /** Outcome of the process: creating the course */
39     const DO_CREATE = 1;
41     /** Outcome of the process: updating the course */
42     const DO_UPDATE = 2;
44     /** Outcome of the process: deleting the course */
45     const DO_DELETE = 3;
47     /** @var array final import data. */
48     protected $data = array();
50     /** @var array default values. */
51     protected $defaults = array();
53     /** @var array enrolment data. */
54     protected $enrolmentdata;
56     /** @var array errors. */
57     protected $errors = array();
59     /** @var int the ID of the course that had been processed. */
60     protected $id;
62     /** @var array containing options passed from the processor. */
63     protected $importoptions = array();
65     /** @var int import mode. Matches tool_uploadcourse_processor::MODE_* */
66     protected $mode;
68     /** @var array course import options. */
69     protected $options = array();
71     /** @var int constant value of self::DO_*, what to do with that course */
72     protected $do;
74     /** @var bool set to true once we have prepared the course */
75     protected $prepared = false;
77     /** @var bool set to true once we have started the process of the course */
78     protected $processstarted = false;
80     /** @var array course import data. */
81     protected $rawdata = array();
83     /** @var array restore directory. */
84     protected $restoredata;
86     /** @var string course shortname. */
87     protected $shortname;
89     /** @var array errors. */
90     protected $statuses = array();
92     /** @var int update mode. Matches tool_uploadcourse_processor::UPDATE_* */
93     protected $updatemode;
95     /** @var array fields allowed as course data. */
96     static protected $validfields = array('fullname', 'shortname', 'idnumber', 'category', 'visible', 'startdate',
97         'summary', 'format', 'theme', 'lang', 'newsitems', 'showgrades', 'showreports', 'legacyfiles', 'maxbytes',
98         'groupmode', 'groupmodeforce', 'groupmodeforce', 'enablecompletion');
100     /** @var array fields required on course creation. */
101     static protected $mandatoryfields = array('fullname', 'category');
103     /** @var array fields which are considered as options. */
104     static protected $optionfields = array('delete' => false, 'rename' => null, 'backupfile' => null,
105         'templatecourse' => null, 'reset' => false);
107     /** @var array options determining what can or cannot be done at an import level. */
108     static protected $importoptionsdefaults = array('canrename' => false, 'candelete' => false, 'canreset' => false,
109         'reset' => false, 'restoredir' => null, 'shortnametemplate' => null);
111     /** @var array special fields used when processing the enrolment methods. */
112     static protected $enrolmentspecialfields = array('delete', 'disable', 'startdate', 'enddate', 'enrolperiod', 'role');
114     /**
115      * Constructor
116      *
117      * @param int $mode import mode, constant matching tool_uploadcourse_processor::MODE_*
118      * @param int $updatemode update mode, constant matching tool_uploadcourse_processor::UPDATE_*
119      * @param array $rawdata raw course data.
120      * @param array $defaults default course data.
121      * @param array $importoptions import options.
122      */
123     public function __construct($mode, $updatemode, $rawdata, $defaults = array(), $importoptions = array()) {
125         if ($mode !== tool_uploadcourse_processor::MODE_CREATE_NEW &&
126                 $mode !== tool_uploadcourse_processor::MODE_CREATE_ALL &&
127                 $mode !== tool_uploadcourse_processor::MODE_CREATE_OR_UPDATE &&
128                 $mode !== tool_uploadcourse_processor::MODE_UPDATE_ONLY) {
129             throw new coding_exception('Incorrect mode.');
130         } else if ($updatemode !== tool_uploadcourse_processor::UPDATE_NOTHING &&
131                 $updatemode !== tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_ONLY &&
132                 $updatemode !== tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_OR_DEFAUTLS &&
133                 $updatemode !== tool_uploadcourse_processor::UPDATE_MISSING_WITH_DATA_OR_DEFAUTLS) {
134             throw new coding_exception('Incorrect update mode.');
135         }
137         $this->mode = $mode;
138         $this->updatemode = $updatemode;
140         if (isset($rawdata['shortname'])) {
141             $this->shortname = $rawdata['shortname'];
142         }
143         $this->rawdata = $rawdata;
144         $this->defaults = $defaults;
146         // Extract course options.
147         foreach (self::$optionfields as $option => $default) {
148             $this->options[$option] = isset($rawdata[$option]) ? $rawdata[$option] : $default;
149         }
151         // Import options.
152         foreach (self::$importoptionsdefaults as $option => $default) {
153             $this->importoptions[$option] = isset($importoptions[$option]) ? $importoptions[$option] : $default;
154         }
155     }
157     /**
158      * Does the mode allow for course creation?
159      *
160      * @return bool
161      */
162     public function can_create() {
163         return in_array($this->mode, array(tool_uploadcourse_processor::MODE_CREATE_ALL,
164             tool_uploadcourse_processor::MODE_CREATE_NEW,
165             tool_uploadcourse_processor::MODE_CREATE_OR_UPDATE)
166         );
167     }
169     /**
170      * Does the mode allow for course deletion?
171      *
172      * @return bool
173      */
174     public function can_delete() {
175         return $this->importoptions['candelete'];
176     }
178     /**
179      * Does the mode only allow for course creation?
180      *
181      * @return bool
182      */
183     public function can_only_create() {
184         return in_array($this->mode, array(tool_uploadcourse_processor::MODE_CREATE_ALL,
185             tool_uploadcourse_processor::MODE_CREATE_NEW));
186     }
188     /**
189      * Does the mode allow for course rename?
190      *
191      * @return bool
192      */
193     public function can_rename() {
194         return $this->importoptions['canrename'];
195     }
197     /**
198      * Does the mode allow for course reset?
199      *
200      * @return bool
201      */
202     public function can_reset() {
203         return $this->importoptions['canreset'];
204     }
206     /**
207      * Does the mode allow for course update?
208      *
209      * @return bool
210      */
211     public function can_update() {
212         return in_array($this->mode,
213                 array(
214                     tool_uploadcourse_processor::MODE_UPDATE_ONLY,
215                     tool_uploadcourse_processor::MODE_CREATE_OR_UPDATE)
216                 ) && $this->updatemode != tool_uploadcourse_processor::UPDATE_NOTHING;
217     }
219     /**
220      * Can we use default values?
221      *
222      * @return bool
223      */
224     public function can_use_defaults() {
225         return in_array($this->updatemode, array(tool_uploadcourse_processor::UPDATE_MISSING_WITH_DATA_OR_DEFAUTLS,
226             tool_uploadcourse_processor::UPDATE_ALL_WITH_DATA_OR_DEFAUTLS));
227     }
229     /**
230      * Delete the current course.
231      *
232      * @return bool
233      */
234     protected function delete() {
235         global $DB;
236         $this->id = $DB->get_field_select('course', 'id', 'shortname = :shortname',
237             array('shortname' => $this->shortname), MUST_EXIST);
238         return delete_course($this->id, false);
239     }
241     /**
242      * Log an error
243      *
244      * @param string $code error code.
245      * @param lang_string $message error message.
246      * @return void
247      */
248     protected function error($code, lang_string $message) {
249         if (array_key_exists($code, $this->errors)) {
250             throw new coding_exception('Error code already defined');
251         }
252         $this->errors[$code] = $message;
253     }
255     /**
256      * Return whether the course exists or not.
257      *
258      * @param string $shortname the shortname to use to check if the course exists. Falls back on $this->shortname if empty.
259      * @return bool
260      */
261     protected function exists($shortname = null) {
262         global $DB;
263         if (is_null($shortname)) {
264             $shortname = $this->shortname;
265         }
266         if (!empty($shortname) || is_numeric($shortname)) {
267             return $DB->record_exists('course', array('shortname' => $shortname));
268         }
269         return false;
270     }
272     /**
273      * Return the data that will be used upon saving.
274      *
275      * @return null|array
276      */
277     public function get_data() {
278         return $this->data;
279     }
281     /**
282      * Return the errors found during preparation.
283      *
284      * @return array
285      */
286     public function get_errors() {
287         return $this->errors;
288     }
290     /**
291      * Assemble the course data based on defaults.
292      *
293      * This returns the final data to be passed to create_course().
294      *
295      * @param array $data current data.
296      * @return array
297      */
298     protected function get_final_create_data($data) {
299         foreach (self::$validfields as $field) {
300             if (!isset($data[$field]) && isset($this->defaults[$field])) {
301                 $data[$field] = $this->defaults[$field];
302             }
303         }
304         $data['shortname'] = $this->shortname;
305         return $data;
306     }
308     /**
309      * Assemble the course data based on defaults.
310      *
311      * This returns the final data to be passed to update_course().
312      *
313      * @param array $data current data.
314      * @param bool $usedefaults are defaults allowed?
315      * @param bool $missingonly ignore fields which are already set.
316      * @return array
317      */
318     protected function get_final_update_data($data, $usedefaults = false, $missingonly = false) {
319         global $DB;
320         $newdata = array();
321         $existingdata = $DB->get_record('course', array('shortname' => $this->shortname));
322         foreach (self::$validfields as $field) {
323             if ($missingonly) {
324                 if (!is_null($existingdata->$field) and $existingdata->$field !== '') {
325                     continue;
326                 }
327             }
328             if (isset($data[$field])) {
329                 $newdata[$field] = $data[$field];
330             } else if ($usedefaults && isset($this->defaults[$field])) {
331                 $newdata[$field] = $this->defaults[$field];
332             }
333         }
334         $newdata['id'] =  $existingdata->id;
335         return $newdata;
336     }
338     /**
339      * Return the ID of the processed course.
340      *
341      * @return int|null
342      */
343     public function get_id() {
344         if (!$this->processstarted) {
345             throw new coding_exception('The course has not been processed yet!');
346         }
347         return $this->id;
348     }
350     /**
351      * Get the directory of the object to restore.
352      *
353      * @return string|false|null subdirectory in $CFG->tempdir/backup/..., false when an error occured
354      *                           and null when there is simply nothing.
355      */
356     protected function get_restore_content_dir() {
357         $backupfile = null;
358         $shortname = null;
360         if (!empty($this->options['backupfile'])) {
361             $backupfile = $this->options['backupfile'];
362         } else if (!empty($this->options['templatecourse']) || is_numeric($this->options['templatecourse'])) {
363             $shortname = $this->options['templatecourse'];
364         }
366         $errors = array();
367         $dir = tool_uploadcourse_helper::get_restore_content_dir($backupfile, $shortname, $errors);
368         if (!empty($errors)) {
369             foreach ($errors as $key => $message) {
370                 $this->error($key, $message);
371             }
372             return false;
373         } else if ($dir === false) {
374             // We want to return null when nothing was wrong, but nothing was found.
375             $dir = null;
376         }
378         if (empty($dir) && !empty($this->importoptions['restoredir'])) {
379             $dir = $this->importoptions['restoredir'];
380         }
382         return $dir;
383     }
385     /**
386      * Return the errors found during preparation.
387      *
388      * @return array
389      */
390     public function get_statuses() {
391         return $this->statuses;
392     }
394     /**
395      * Return whether there were errors with this course.
396      *
397      * @return boolean
398      */
399     public function has_errors() {
400         return !empty($this->errors);
401     }
403     /**
404      * Validates and prepares the data.
405      *
406      * @return bool false is any error occured.
407      */
408     public function prepare() {
409         global $DB, $SITE;
410         $this->prepared = true;
412         // Validate the shortname.
413         if (!empty($this->shortname) || is_numeric($this->shortname)) {
414             if ($this->shortname !== clean_param($this->shortname, PARAM_TEXT)) {
415                 $this->error('invalidshortname', new lang_string('invalidshortname', 'tool_uploadcourse'));
416                 return false;
417             }
418         }
420         $exists = $this->exists();
422         // Do we want to delete the course?
423         if ($this->options['delete']) {
424             if (!$exists) {
425                 $this->error('cannotdeletecoursenotexist', new lang_string('cannotdeletecoursenotexist', 'tool_uploadcourse'));
426                 return false;
427             } else if (!$this->can_delete()) {
428                 $this->error('coursedeletionnotallowed', new lang_string('coursedeletionnotallowed', 'tool_uploadcourse'));
429                 return false;
430             }
432             $this->do = self::DO_DELETE;
433             return true;
434         }
436         // Can we create/update the course under those conditions?
437         if ($exists) {
438             if ($this->mode === tool_uploadcourse_processor::MODE_CREATE_NEW) {
439                 $this->error('courseexistsanduploadnotallowed',
440                     new lang_string('courseexistsanduploadnotallowed', 'tool_uploadcourse'));
441                 return false;
442             } else if ($this->can_update()) {
443                 // We can never allow for any front page changes!
444                 if ($this->shortname == $SITE->shortname) {
445                     $this->error('cannotupdatefrontpage', new lang_string('cannotupdatefrontpage', 'tool_uploadcourse'));
446                     return false;
447                 }
448             }
449         } else {
450             if (!$this->can_create()) {
451                 $this->error('coursedoesnotexistandcreatenotallowed',
452                     new lang_string('coursedoesnotexistandcreatenotallowed', 'tool_uploadcourse'));
453                 return false;
454             }
455         }
457         // Basic data.
458         $coursedata = array();
459         foreach ($this->rawdata as $field => $value) {
460             if (!in_array($field, self::$validfields)) {
461                 continue;
462             } else if ($field == 'shortname') {
463                 // Let's leave it apart from now, use $this->shortname only.
464                 continue;
465             }
466             $coursedata[$field] = $value;
467         }
469         $mode = $this->mode;
470         $updatemode = $this->updatemode;
471         $usedefaults = $this->can_use_defaults();
473         // Resolve the category, and fail if not found.
474         $errors = array();
475         $catid = tool_uploadcourse_helper::resolve_category($this->rawdata, $errors);
476         if (empty($errors)) {
477             $coursedata['category'] = $catid;
478         } else {
479             foreach ($errors as $key => $message) {
480                 $this->error($key, $message);
481             }
482             return false;
483         }
485         // If the course does not exist, or will be forced created.
486         if (!$exists || $mode === tool_uploadcourse_processor::MODE_CREATE_ALL) {
488             // Mandatory fields upon creation.
489             $errors = array();
490             foreach (self::$mandatoryfields as $field) {
491                 if ((!isset($coursedata[$field]) || $coursedata[$field] === '') &&
492                         (!isset($this->defaults[$field]) || $this->defaults[$field] === '')) {
493                     $errors[] = $field;
494                 }
495             }
496             if (!empty($errors)) {
497                 $this->error('missingmandatoryfields', new lang_string('missingmandatoryfields', 'tool_uploadcourse',
498                     implode(', ', $errors)));
499                 return false;
500             }
501         }
503         // Should the course be renamed?
504         if (!empty($this->options['rename']) || is_numeric($this->options['rename'])) {
505             if (!$this->can_update()) {
506                 $this->error('canonlyrenameinupdatemode', new lang_string('canonlyrenameinupdatemode', 'tool_uploadcourse'));
507                 return false;
508             } else if (!$exists) {
509                 $this->error('cannotrenamecoursenotexist', new lang_string('cannotrenamecoursenotexist', 'tool_uploadcourse'));
510                 return false;
511             } else if (!$this->can_rename()) {
512                 $this->error('courserenamingnotallowed', new lang_string('courserenamingnotallowed', 'tool_uploadcourse'));
513                 return false;
514             } else if ($this->options['rename'] !== clean_param($this->options['rename'], PARAM_TEXT)) {
515                 $this->error('invalidshortname', new lang_string('invalidshortname', 'tool_uploadcourse'));
516                 return false;
517             } else if ($this->exists($this->options['rename'])) {
518                 $this->error('cannotrenameshortnamealreadyinuse',
519                     new lang_string('cannotrenameshortnamealreadyinuse', 'tool_uploadcourse'));
520                 return false;
521             } else if (isset($coursedata['idnumber']) &&
522                     $DB->count_records_select('course', 'idnumber = :idn AND shortname != :sn',
523                     array('idn' => $coursedata['idnumber'], 'sn' => $this->shortname)) > 0) {
524                 $this->error('cannotrenameidnumberconflict', new lang_string('cannotrenameidnumberconflict', 'tool_uploadcourse'));
525                 return false;
526             }
527             $coursedata['shortname'] = $this->options['rename'];
528             $this->status('courserenamed', new lang_string('courserenamed', 'tool_uploadcourse',
529                 array('from' => $this->shortname, 'to' => $coursedata['shortname'])));
530         }
532         // Should we generate a shortname?
533         if (empty($this->shortname) && !is_numeric($this->shortname)) {
534             if (empty($this->importoptions['shortnametemplate'])) {
535                 $this->error('missingshortnamenotemplate', new lang_string('missingshortnamenotemplate', 'tool_uploadcourse'));
536                 return false;
537             } else if (!$this->can_only_create()) {
538                 $this->error('cannotgenerateshortnameupdatemode',
539                     new lang_string('cannotgenerateshortnameupdatemode', 'tool_uploadcourse'));
540                 return false;
541             } else {
542                 $newshortname = tool_uploadcourse_helper::generate_shortname($coursedata,
543                     $this->importoptions['shortnametemplate']);
544                 if (is_null($newshortname)) {
545                     $this->error('generatedshortnameinvalid', new lang_string('generatedshortnameinvalid', 'tool_uploadcourse'));
546                     return false;
547                 } else if ($this->exists($newshortname)) {
548                     if ($mode === tool_uploadcourse_processor::MODE_CREATE_NEW) {
549                         $this->error('generatedshortnamealreadyinuse',
550                             new lang_string('generatedshortnamealreadyinuse', 'tool_uploadcourse'));
551                         return false;
552                     }
553                     $exists = true;
554                 }
555                 $this->status('courseshortnamegenerated', new lang_string('courseshortnamegenerated', 'tool_uploadcourse',
556                     $newshortname));
557                 $this->shortname = $newshortname;
558             }
559         }
561         // If exists, but we only want to create courses, increment the shortname.
562         if ($exists && $mode === tool_uploadcourse_processor::MODE_CREATE_ALL) {
563             $original = $this->shortname;
564             $this->shortname = tool_uploadcourse_helper::increment_shortname($this->shortname);
565             $exists = false;
566             if ($this->shortname != $original) {
567                 $this->status('courseshortnameincremented', new lang_string('courseshortnameincremented', 'tool_uploadcourse',
568                     array('from' => $original, 'to' => $this->shortname)));
569                 if (isset($coursedata['idnumber'])) {
570                     $originalidn = $coursedata['idnumber'];
571                     $coursedata['idnumber'] = tool_uploadcourse_helper::increment_idnumber($coursedata['idnumber']);
572                     if ($originalidn != $coursedata['idnumber']) {
573                         $this->status('courseidnumberincremented', new lang_string('courseidnumberincremented', 'tool_uploadcourse',
574                             array('from' => $originalidn, 'to' => $coursedata['idnumber'])));
575                     }
576                 }
577             }
578         }
580         // If the course does not exist, ensure that the ID number is not taken.
581         if (!$exists && isset($coursedata['idnumber'])) {
582             if ($DB->count_records_select('course', 'idnumber = :idn', array('idn' => $coursedata['idnumber'])) > 0) {
583                 $this->error('idnumberalreadyinuse', new lang_string('idnumberalreadyinuse', 'tool_uploadcourse'));
584                 return false;
585             }
586         }
588         // Ultimate check mode vs. existence.
589         switch ($mode) {
590             case tool_uploadcourse_processor::MODE_CREATE_NEW:
591             case tool_uploadcourse_processor::MODE_CREATE_ALL:
592                 if ($exists) {
593                     $this->error('courseexistsanduploadnotallowed',
594                         new lang_string('courseexistsanduploadnotallowed', 'tool_uploadcourse'));
595                     return false;
596                 }
597                 break;
598             case tool_uploadcourse_processor::MODE_UPDATE_ONLY:
599                 if (!$exists) {
600                     $this->error('coursedoesnotexistandcreatenotallowed',
601                         new lang_string('coursedoesnotexistandcreatenotallowed', 'tool_uploadcourse'));
602                     return false;
603                 }
604                 // No break!
605             case tool_uploadcourse_processor::MODE_CREATE_OR_UPDATE:
606                 if ($exists) {
607                     if ($updatemode === tool_uploadcourse_processor::UPDATE_NOTHING) {
608                         $this->error('updatemodedoessettonothing',
609                             new lang_string('updatemodedoessettonothing', 'tool_uploadcourse'));
610                         return false;
611                     }
612                 }
613                 break;
614             default:
615                 // O_o Huh?! This should really never happen here!
616                 $this->error('unknownimportmode', new lang_string('unknownimportmode', 'tool_uploadcourse'));
617                 return false;
618         }
620         // Get final data.
621         if ($exists) {
622             $missingonly = ($updatemode === tool_uploadcourse_processor::UPDATE_MISSING_WITH_DATA_OR_DEFAUTLS);
623             $coursedata = $this->get_final_update_data($coursedata, $usedefaults, $missingonly);
625             // Make sure we are not trying to mess with the front page, though we should never get here!
626             if ($coursedata['id'] == $SITE->id) {
627                 $this->error('cannotupdatefrontpage', new lang_string('cannotupdatefrontpage', 'tool_uploadcourse'));
628                 return false;
629             }
631             $this->do = self::DO_UPDATE;
632         } else {
633             $coursedata = $this->get_final_create_data($coursedata);
634             $this->do = self::DO_CREATE;
635         }
637         // Course start date.
638         if (!empty($coursedata['startdate'])) {
639             $coursedata['startdate'] = strtotime($coursedata['startdate']);
640         }
642         // Add role renaming.
643         $errors = array();
644         $rolenames = tool_uploadcourse_helper::get_role_names($this->rawdata, $errors);
645         if (!empty($errors)) {
646             foreach ($errors as $key => $message) {
647                 $this->error($key, $message);
648             }
649             return false;
650         }
651         foreach ($rolenames as $rolekey => $rolename) {
652             $coursedata[$rolekey] = $rolename;
653         }
655         // Some validation.
656         if (!empty($coursedata['format']) && !in_array($coursedata['format'], tool_uploadcourse_helper::get_course_formats())) {
657             $this->error('invalidcourseformat', new lang_string('invalidcourseformat', 'tool_uploadcourse'));
658             return false;
659         }
661         // Getting the enrolment data.
662         $errors = array();
663         $this->enrolmentdata = tool_uploadcourse_helper::get_enrolment_data($this->rawdata, $errors);
664         if (!empty($errors)) {
665             foreach ($errors as $key => $message) {
666                 $this->error($key, $message);
667             }
668             return false;
669         }
671         // Saving data.
672         $this->data = $coursedata;
674         // Restore data.
675         // TODO Speed up things by not really extracting the backup just yet, but checking that
676         // the backup file or shortname passed are valid. Extraction should happen in proceed().
677         $this->restoredata = $this->get_restore_content_dir();
678         if ($this->restoredata === false) {
679             return false;
680         }
682         // We can only reset courses when allowed and we are updating the course.
683         if ($this->importoptions['reset'] || $this->options['reset']) {
684             if ($this->do !== self::DO_UPDATE) {
685                 $this->error('canonlyresetcourseinupdatemode',
686                     new lang_string('canonlyresetcourseinupdatemode', 'tool_uploadcourse'));
687                 return false;
688             } else if (!$this->can_reset()) {
689                 $this->error('courseresetnotallowed', new lang_string('courseresetnotallowed', 'tool_uploadcourse'));
690                 return false;
691             }
692         }
694         return true;
695     }
697     /**
698      * Proceed with the import of the course.
699      *
700      * @return void
701      */
702     public function proceed() {
703         global $CFG, $USER;
705         if (!$this->prepared) {
706             throw new coding_exception('The course has not been prepared.');
707         } else if ($this->has_errors()) {
708             throw new moodle_exception('Cannot proceed, errors were detected.');
709         } else if ($this->processstarted) {
710             throw new coding_exception('The process has already been started.');
711         }
712         $this->processstarted = true;
714         if ($this->do === self::DO_DELETE) {
715             if ($this->delete()) {
716                 $this->status('coursedeleted', new lang_string('coursedeleted', 'tool_uploadcourse'));
717             } else {
718                 $this->error('errorwhiledeletingcourse', new lang_string('errorwhiledeletingcourse', 'tool_uploadcourse'));
719             }
720             return true;
721         } else if ($this->do === self::DO_CREATE) {
722             $course = create_course((object) $this->data);
723             $this->id = $course->id;
724             $this->status('coursecreated', new lang_string('coursecreated', 'tool_uploadcourse'));
725         } else if ($this->do === self::DO_UPDATE) {
726             $course = (object) $this->data;
727             update_course($course);
728             $this->id = $course->id;
729             $this->status('courseupdated', new lang_string('courseupdated', 'tool_uploadcourse'));
730         } else {
731             // Strangely the outcome has not been defined, or is unknown!
732             throw new coding_exception('Unknown outcome!');
733         }
735         // Restore a course.
736         if (!empty($this->restoredata)) {
737             $rc = new restore_controller($this->restoredata, $course->id, backup::INTERACTIVE_NO,
738                 backup::MODE_IMPORT, $USER->id, backup::TARGET_CURRENT_ADDING);
740             // Check if the format conversion must happen first.
741             if ($rc->get_status() == backup::STATUS_REQUIRE_CONV) {
742                 $rc->convert();
743             }
744             if ($rc->execute_precheck()) {
745                 $rc->execute_plan();
746                 $this->status('courserestored', new lang_string('courserestored', 'tool_uploadcourse'));
747             } else {
748                 $this->error('errorwhilerestoringcourse', new lang_string('errorwhilerestoringthecourse', 'tool_uploadcourse'));
749             }
750             $rc->destroy();
751             unset($rc); // File logging is a mess, we can only try to rely on gc to close handles.
752         }
754         // Proceed with enrolment data.
755         $this->process_enrolment_data($course);
757         // Reset the course.
758         if ($this->importoptions['reset'] || $this->options['reset']) {
759             if ($this->do === self::DO_UPDATE && $this->can_reset()) {
760                 $this->reset($course);
761                 $this->status('coursereset', new lang_string('coursereset', 'tool_uploadcourse'));
762             }
763         }
765         // Mark context as dirty.
766         $context = context_course::instance($course->id);
767         $context->mark_dirty();
768     }
770     /**
771      * Add the enrolment data for the course.
772      *
773      * @param object $course course record.
774      * @return void
775      */
776     protected function process_enrolment_data($course) {
777         global $DB;
779         $enrolmentdata = $this->enrolmentdata;
780         if (empty($enrolmentdata)) {
781             return;
782         }
784         $cannotaddmethods = array();
785         $enrolmentplugins = tool_uploadcourse_helper::get_enrolment_plugins();
786         $instances = enrol_get_instances($course->id, false);
787         foreach ($enrolmentdata as $enrolmethod => $method) {
789             $plugin = $enrolmentplugins[$enrolmethod];
791             // TODO MDL-48362 Abstract the logic to prevent it to be tied to the
792             // user interface. Ideally a plugin should have a method that returns
793             // whether or not a new instance can be added to the course rather than
794             // using enrol_plugin::get_newinstance_link() to figure that out.
795             $canadd = $plugin->get_newinstance_link($course->id);
797             // TODO MDL-43820 Handle multiple instances of the same type.
798             $instance = null;
799             foreach ($instances as $i) {
800                 if ($i->enrol == $enrolmethod) {
801                     $instance = $i;
802                     break;
803                 }
804             }
806             $todelete = isset($method['delete']) && $method['delete'];
807             $todisable = isset($method['disable']) && $method['disable'];
808             unset($method['delete']);
809             unset($method['disable']);
811             if (!empty($instance) && $todelete) {
812                 // Remove the enrolment method.
813                 foreach ($instances as $instance) {
814                     if ($instance->enrol == $enrolmethod) {
815                         $plugin = $enrolmentplugins[$instance->enrol];
816                         $plugin->delete_instance($instance);
817                         break;
818                     }
819                 }
820             } else if (!empty($instance) && $todisable) {
821                 // Disable the enrolment.
822                 foreach ($instances as $instance) {
823                     if ($instance->enrol == $enrolmethod) {
824                         $plugin = $enrolmentplugins[$instance->enrol];
825                         $plugin->update_status($instance, ENROL_INSTANCE_DISABLED);
826                         $enrol_updated = true;
827                         break;
828                     }
829                 }
830             } else {
831                 if (empty($instance)) {
833                     // Check if we can create a new instance of this enrolment method.
834                     if (!$canadd) {
835                         $cannotaddmethods[] = $enrolmethod;
836                         continue;
837                     }
839                     // Some plugins do not implement enrol_plugin::add_default_instance(),
840                     // but we will try anyway and call enrol_plugin::add_instance() if needed.
841                     $id = $plugin->add_default_instance($course);
842                     if (empty($id)) {
843                         $id = $plugin->add_instance($course);
844                     }
846                     $instance = new stdClass();
847                     $instance->id = $id;
848                     $instance->roleid = $plugin->get_config('roleid');
849                     $instance->status = ENROL_INSTANCE_ENABLED;
850                 } else {
851                     $plugin->update_status($instance, ENROL_INSTANCE_ENABLED);
852                 }
854                 // Now update values.
855                 foreach ($method as $k => $v) {
856                     if (in_array($k, self::$enrolmentspecialfields)) {
857                         // Skip the special import keys.
858                         continue;
859                     }
860                     $instance->{$k} = $v;
861                 }
863                 // Sort out the start, end and date.
864                 if (isset($method['startdate'])) {
865                     $instance->enrolstartdate = strtotime($method['startdate']);
866                 } else if (!isset($instance->enrolstartdate)) {
867                     $instance->enrolstartdate = 0;
868                 }
869                 if (isset($method['enddate'])) {
870                     $instance->enrolenddate = strtotime($method['enddate']);
871                 } else if (!isset($instance->enrolenddate)) {
872                     $instance->enrolenddate = 0;
873                 }
875                 // Is the enrolment period set?
876                 if (isset($method['enrolperiod'])) {
877                     if (empty($method['enrolperiod'])) {
878                         // Let's just make sure that it's 0.
879                         $method['enrolperiod'] = 0;
880                     } else if (preg_match('/^\d+$/', $method['enrolperiod'])) {
881                         // Cast integers to integers.
882                         $method['enrolperiod'] = (int) $method['enrolperiod'];
883                     } else {
884                         // Try and convert period to seconds.
885                         $method['enrolperiod'] = strtotime('1970-01-01 GMT + ' . $method['enrolperiod']);
886                     }
887                     $instance->enrolperiod = $method['enrolperiod'];
888                 }
889                 if ($instance->enrolstartdate > 0 && isset($method['enrolperiod'])) {
890                     $instance->enrolenddate = $instance->enrolstartdate + $method['enrolperiod'];
891                 }
892                 if ($instance->enrolenddate > 0) {
893                     $instance->enrolperiod = $instance->enrolenddate - $instance->enrolstartdate;
894                 }
895                 if ($instance->enrolenddate < $instance->enrolstartdate) {
896                     $instance->enrolenddate = $instance->enrolstartdate;
897                 }
899                 // Sort out the given role. This does not filter the roles allowed in the course.
900                 if (isset($method['role'])) {
901                     $roleids = tool_uploadcourse_helper::get_role_ids();
902                     if (isset($roleids[$method['role']])) {
903                         $instance->roleid = $roleids[$method['role']];
904                     }
905                 }
907                 $instance->timemodified = time();
908                 $DB->update_record('enrol', $instance);
909             }
910         }
912         if (!empty($cannotaddmethods)) {
913             $this->error('cannotaddenrolmentmethods', new lang_string('cannotaddenrolmentmethods', 'tool_uploadcourse',
914                 implode(', ', $cannotaddmethods)));
915         }
916     }
918     /**
919      * Reset the current course.
920      *
921      * This does not reset any of the content of the activities.
922      *
923      * @param stdClass $course the course object of the course to reset.
924      * @return array status array of array component, item, error.
925      */
926     protected function reset($course) {
927         global $DB;
929         $resetdata = new stdClass();
930         $resetdata->id = $course->id;
931         $resetdata->reset_start_date = time();
932         $resetdata->reset_events = true;
933         $resetdata->reset_notes = true;
934         $resetdata->delete_blog_associations = true;
935         $resetdata->reset_completion = true;
936         $resetdata->reset_roles_overrides = true;
937         $resetdata->reset_roles_local = true;
938         $resetdata->reset_groups_members = true;
939         $resetdata->reset_groups_remove = true;
940         $resetdata->reset_groupings_members = true;
941         $resetdata->reset_groupings_remove = true;
942         $resetdata->reset_gradebook_items = true;
943         $resetdata->reset_gradebook_grades = true;
944         $resetdata->reset_comments = true;
946         if (empty($course->startdate)) {
947             $course->startdate = $DB->get_field_select('course', 'startdate', 'id = :id', array('id' => $course->id));
948         }
949         $resetdata->reset_start_date_old = $course->startdate;
951         // Add roles.
952         $roles = tool_uploadcourse_helper::get_role_ids();
953         $resetdata->unenrol_users = array_values($roles);
954         $resetdata->unenrol_users[] = 0;    // Enrolled without role.
956         return reset_course_userdata($resetdata);
957     }
959     /**
960      * Log a status
961      *
962      * @param string $code status code.
963      * @param lang_string $message status message.
964      * @return void
965      */
966     protected function status($code, lang_string $message) {
967         if (array_key_exists($code, $this->statuses)) {
968             throw new coding_exception('Status code already defined');
969         }
970         $this->statuses[$code] = $message;
971     }