7c7756cd3a9ebd653777cb01b093ab81c2e8a612
[moodle.git] / course / dnduploadlib.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  * Library to handle drag and drop course uploads
19  *
20  * @package    core
21  * @subpackage lib
22  * @copyright  2012 Davo smith
23  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
24  */
26 defined('MOODLE_INTERNAL') || die();
28 require_once($CFG->dirroot.'/repository/lib.php');
29 require_once($CFG->dirroot.'/repository/upload/lib.php');
30 require_once($CFG->dirroot.'/course/lib.php');
32 /**
33  * Add the Javascript to enable drag and drop upload to a course page
34  *
35  * @param object $course The currently displayed course
36  * @param array $modnames The list of enabled (visible) modules on this site
37  * @return void
38  */
39 function dndupload_add_to_course($course, $modnames) {
40     global $CFG, $PAGE;
42     // Get all handlers.
43     $handler = new dndupload_handler($course, $modnames);
44     $jsdata = $handler->get_js_data();
45     if (empty($jsdata->types) && empty($jsdata->filehandlers)) {
46         return; // No valid handlers - don't enable drag and drop.
47     }
49     // Add the javascript to the page.
50     $jsmodule = array(
51         'name' => 'coursedndupload',
52         'fullpath' => new moodle_url('/course/dndupload.js'),
53         'strings' => array(
54             array('addfilehere', 'moodle'),
55             array('dndworking', 'moodle'),
56             array('filetoolarge', 'moodle'),
57             array('actionchoice', 'moodle'),
58             array('servererror', 'moodle'),
59             array('upload', 'moodle'),
60             array('cancel', 'moodle')
61         ),
62         'requires' => array('node', 'event', 'panel', 'json')
63     );
64     $vars = array(
65         array('courseid' => $course->id,
66               'maxbytes' => get_max_upload_file_size($CFG->maxbytes, $course->maxbytes),
67               'handlers' => $handler->get_js_data())
68     );
70     $PAGE->requires->js_init_call('M.course_dndupload.init', $vars, true, $jsmodule);
71 }
74 /**
75  * Stores all the information about the available dndupload handlers
76  *
77  * @package    core
78  * @copyright  2012 Davo Smith
79  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
80  */
81 class dndupload_handler {
83     /**
84      * @var array A list of all registered mime types that can be dropped onto a course
85      *            along with the modules that will handle them.
86      */
87     protected $types = array();
89     /**
90      * @var array  A list of the different file types (extensions) that different modules
91      *             will handle.
92      */
93     protected $filehandlers = array();
95     /**
96      * Gather a list of dndupload handlers from the different mods
97      *
98      * @param object $course The course this is being added to (to check course_allowed_module() )
99      */
100     public function __construct($course, $modnames = null) {
101         global $CFG;
103         // Add some default types to handle.
104         // Note: 'Files' type is hard-coded into the Javascript as this needs to be ...
105         // ... treated a little differently.
106         $this->add_type('url', array('url', 'text/uri-list'), get_string('addlinkhere', 'moodle'),
107                         get_string('nameforlink', 'moodle'), 10);
108         $this->add_type('text/html', array('text/html'), get_string('addpagehere', 'moodle'),
109                         get_string('nameforpage', 'moodle'), 20);
110         $this->add_type('text', array('text', 'text/plain'), get_string('addpagehere', 'moodle'),
111                         get_string('nameforpage', 'moodle'), 30);
113         // Loop through all modules to find handlers.
114         $mods = get_plugin_list_with_function('mod', 'dndupload_register');
115         foreach ($mods as $component => $funcname) {
116             list($modtype, $modname) = normalize_component($component);
117             if ($modnames && !array_key_exists($modname, $modnames)) {
118                 continue; // Module is deactivated (hidden) at the site level.
119             }
120             if (!course_allowed_module($course, $modname)) {
121                 continue; // User does not have permission to add this module to the course.
122             }
123             $resp = $funcname();
124             if (!$resp) {
125                 continue;
126             }
127             if (isset($resp['files'])) {
128                 foreach ($resp['files'] as $file) {
129                     $this->add_file_handler($file['extension'], $modname, $file['message']);
130                 }
131             }
132             if (isset($resp['addtypes'])) {
133                 foreach ($resp['addtypes'] as $type) {
134                     if (isset($type['priority'])) {
135                         $priority = $type['priority'];
136                     } else {
137                         $priority = 100;
138                     }
139                     $this->add_type($type['identifier'], $type['datatransfertypes'],
140                                     $type['addmessage'], $type['namemessage'], $priority);
141                 }
142             }
143             if (isset($resp['types'])) {
144                 foreach ($resp['types'] as $type) {
145                     $this->add_type_handler($type['identifier'], $modname, $type['message']);
146                 }
147             }
148         }
149     }
151     /**
152      * Used to add a new mime type that can be drag and dropped onto a
153      * course displayed in a browser window
154      *
155      * @param string $identifier The name that this type will be known as
156      * @param array $datatransfertypes An array of the different types in the browser
157      *                                 'dataTransfer.types' object that will map to this type
158      * @param string $addmessage The message to display in the browser when this type is being
159      *                           dragged onto the page
160      * @param string $namemessage The message to pop up when asking for the name to give the
161      *                            course module instance when it is created
162      * @param int $priority Controls the order in which types are checked by the browser (mainly
163      *                      needed to check for 'text' last as that is usually given as fallback)
164      */
165     public function add_type($identifier, $datatransfertypes, $addmessage, $namemessage, $priority=100) {
166         if ($this->is_known_type($identifier)) {
167             throw new coding_exception("Type $identifier is already registered");
168         }
170         $add = new stdClass;
171         $add->identifier = $identifier;
172         $add->datatransfertypes = $datatransfertypes;
173         $add->addmessage = $addmessage;
174         $add->namemessage = $namemessage;
175         $add->priority = $priority;
176         $add->handlers = array();
178         $this->types[$identifier] = $add;
179     }
181     /**
182      * Used to declare that a particular module will handle a particular type
183      * of dropped data
184      *
185      * @param string $type The name of the type (as declared in add_type)
186      * @param string $module The name of the module to handle this type
187      * @param string $message The message to show the user if more than one handler is registered
188      *                        for a type and the user needs to make a choice between them
189      */
190     public function add_type_handler($type, $module, $message) {
191         if (!$this->is_known_type($type)) {
192             throw new coding_exception("Trying to add handler for unknown type $type");
193         }
195         $add = new stdClass;
196         $add->type = $type;
197         $add->module = $module;
198         $add->message = $message;
200         $this->types[$type]->handlers[] = $add;
201     }
203     /**
204      * Used to declare that a particular module will handle a particular type
205      * of dropped file
206      *
207      * @param string $extension The file extension to handle ('*' for all types)
208      * @param string $module The name of the module to handle this type
209      * @param string $message The message to show the user if more than one handler is registered
210      *                        for a type and the user needs to make a choice between them
211      */
212     public function add_file_handler($extension, $module, $message) {
213         $extension = strtolower($extension);
215         $add = new stdClass;
216         $add->extension = $extension;
217         $add->module = $module;
218         $add->message = $message;
220         $this->filehandlers[] = $add;
221     }
223     /**
224      * Check to see if the type has been registered
225      *
226      * @param string $type The identifier of the type you are interested in
227      * @return bool True if the type is registered
228      */
229     public function is_known_type($type) {
230         return array_key_exists($type, $this->types);
231     }
233     /**
234      * Check to see if the module in question has registered to handle the
235      * type given
236      *
237      * @param string $module The name of the module
238      * @param string $type The identifier of the type
239      * @return bool True if the module has registered to handle that type
240      */
241     public function has_type_handler($module, $type) {
242         if (!$this->is_known_type($type)) {
243             throw new coding_exception("Checking for handler for unknown type $type");
244         }
245         foreach ($this->types[$type]->handlers as $handler) {
246             if ($handler->module == $module) {
247                 return true;
248             }
249         }
250         return false;
251     }
253     /**
254      * Check to see if the module in question has registered to handle files
255      * with the given extension (or to handle all file types)
256      *
257      * @param string $module The name of the module
258      * @param string $extension The extension of the uploaded file
259      * @return bool True if the module has registered to handle files with
260      *              that extension (or to handle all file types)
261      */
262     public function has_file_handler($module, $extension) {
263         foreach ($this->filehandlers as $handler) {
264             if ($handler->module == $module) {
265                 if ($handler->extension == '*' || $handler->extension == $extension) {
266                     return true;
267                 }
268             }
269         }
270         return false;
271     }
273     /**
274      * Gets a list of the file types that are handled by a particular module
275      *
276      * @param string $module The name of the module to check
277      * @return array of file extensions or string '*'
278      */
279     public function get_handled_file_types($module) {
280         $types = array();
281         foreach ($this->filehandlers as $handler) {
282             if ($handler->module == $module) {
283                 if ($handler->extension == '*') {
284                     return '*';
285                 } else {
286                     // Prepending '.' as otherwise mimeinfo fails.
287                     $types[] = '.'.$handler->extension;
288                 }
289             }
290         }
291         return $types;
292     }
294     /**
295      * Returns an object to pass onto the javascript code with data about all the
296      * registered file / type handlers
297      *
298      * @return object Data to pass on to Javascript code
299      */
300     public function get_js_data() {
301         $ret = new stdClass;
303         // Sort the types by priority.
304         uasort($this->types, array($this, 'type_compare'));
306         $ret->types = array();
307         foreach ($this->types as $type) {
308             if (empty($type->handlers)) {
309                 continue; // Skip any types without registered handlers.
310             }
311             $ret->types[] = $type;
312         }
314         $ret->filehandlers = $this->filehandlers;
315         $uploadrepo = repository::get_instances(array('type' => 'upload'));
316         if (empty($uploadrepo)) {
317             $ret->filehandlers = array(); // No upload repo => no file handlers.
318         }
320         return $ret;
321     }
323     /**
324      * Comparison function used when sorting types by priority
325      * @param object $type1 first type to compare
326      * @param object $type2 second type to compare
327      * @return integer -1 for $type1 < $type2; 1 for $type1 > $type2; 0 for equal
328      */
329     protected function type_compare($type1, $type2) {
330         if ($type1->priority < $type2->priority) {
331             return -1;
332         }
333         if ($type1->priority > $type2->priority) {
334             return 1;
335         }
336         return 0;
337     }
341 /**
342  * Processes the upload, creating the course module and returning the result
343  *
344  * @package    core
345  * @copyright  2012 Davo Smith
346  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
347  */
348 class dndupload_ajax_processor {
350     /** Returned when no error has occurred */
351     const ERROR_OK = 0;
353     /** @var object The course that we are uploading to */
354     protected $course = null;
356     /** @var context_course The course context for capability checking */
357     protected $context = null;
359     /** @var int The section number we are uploading to */
360     protected $section = null;
362     /** @var string The type of upload (e.g. 'Files', 'text/plain') */
363     protected $type = null;
365     /** @var object The details of the module type that will be created */
366     protected $module= null;
368     /** @var object The course module that has been created */
369     protected $cm = null;
371     /** @var dndupload_handler used to check the allowed file types */
372     protected $dnduploadhandler = null;
374     /** @var string The name to give the new activity instance */
375     protected $displayname = null;
377     /**
378      * Set up some basic information needed to handle the upload
379      *
380      * @param int $courseid The ID of the course we are uploading to
381      * @param int $section The section number we are uploading to
382      * @param string $type The type of upload (as reported by the browser)
383      * @param string $modulename The name of the module requested to handle this upload
384      */
385     public function __construct($courseid, $section, $type, $modulename) {
386         global $DB;
388         if (!defined('AJAX_SCRIPT')) {
389             throw new coding_exception('dndupload_ajax_processor should only be used within AJAX requests');
390         }
392         $this->course = $DB->get_record('course', array('id' => $courseid), '*', MUST_EXIST);
394         require_login($this->course, false);
395         $this->context = context_course::instance($this->course->id);
397         if (!is_number($section) || $section < 0) {
398             throw new coding_exception("Invalid section number $section");
399         }
400         $this->section = $section;
401         $this->type = $type;
403         if (!$this->module = $DB->get_record('modules', array('name' => $modulename))) {
404             throw new coding_exception("Module $modulename does not exist");
405         }
407         $this->dnduploadhandler = new dndupload_handler($this->course);
408     }
410     /**
411      * Check if this upload is a 'file' upload
412      *
413      * @return bool true if it is a 'file' upload, false otherwise
414      */
415     protected function is_file_upload() {
416         return ($this->type == 'Files');
417     }
419     /**
420      * Process the upload - creating the module in the course and returning the result to the browser
421      *
422      * @param string $displayname optional the name (from the browser) to give the course module instance
423      * @param string $content optional the content of the upload (for non-file uploads)
424      */
425     public function process($displayname = null, $content = null) {
426         require_capability('moodle/course:manageactivities', $this->context);
428         if ($this->is_file_upload()) {
429             require_capability('moodle/course:managefiles', $this->context);
430             if ($content != null) {
431                 throw new moodle_exception('fileuploadwithcontent', 'moodle');
432             }
433         }
435         require_sesskey();
437         $this->displayname = $displayname;
439         if ($this->is_file_upload()) {
440             $this->handle_file_upload();
441         } else {
442             $this->handle_other_upload($content);
443         }
444     }
446     /**
447      * Handle uploads containing files - create the course module, ask the upload repository
448      * to process the file, ask the mod to set itself up, then return the result to the browser
449      */
450     protected function handle_file_upload() {
451         global $CFG;
453         // Add the file to a draft file area.
454         $draftitemid = file_get_unused_draft_itemid();
455         $maxbytes = get_max_upload_file_size($CFG->maxbytes, $this->course->maxbytes);
456         $types = $this->dnduploadhandler->get_handled_file_types($this->module->name);
457         $repo = repository::get_instances(array('type' => 'upload'));
458         if (empty($repo)) {
459             throw new moodle_exception('errornouploadrepo', 'moodle');
460         }
461         $repo = reset($repo); // Get the first (and only) upload repo.
462         $details = $repo->process_upload(null, $maxbytes, $types, '/', $draftitemid);
463         if (empty($this->displayname)) {
464             $this->displayname = $this->display_name_from_file($details['file']);
465         }
467         // Create a course module to hold the new instance.
468         $this->create_course_module();
470         // Ask the module to set itself up.
471         $moduledata = $this->prepare_module_data($draftitemid);
472         $instanceid = plugin_callback('mod', $this->module->name, 'dndupload', 'handle', array($moduledata), 'invalidfunction');
473         if ($instanceid === 'invalidfunction') {
474             throw new coding_exception("{$this->module->name} does not support drag and drop upload (missing {$this->module->name}_dndupload_handle function");
475         }
477         // Finish setting up the course module.
478         $this->finish_setup_course_module($instanceid);
479     }
481     /**
482      * Handle uploads not containing file - create the course module, ask the mod to
483      * set itself up, then return the result to the browser
484      *
485      * @param string $content the content uploaded to the browser
486      */
487     protected function handle_other_upload($content) {
488         // Check this plugin is registered to handle this type of upload
489         if (!$this->dnduploadhandler->has_type_handler($this->module->name, $this->type)) {
490             $info = (object)array('modname' => $this->module->name, 'type' => $this->type);
491             throw new moodle_exception('moddoesnotsupporttype', 'moodle', $info);
492         }
494         // Create a course module to hold the new instance.
495         $this->create_course_module();
497         // Ask the module to set itself up.
498         $moduledata = $this->prepare_module_data(null, $content);
499         $instanceid = plugin_callback('mod', $this->module->name, 'dndupload', 'handle', array($moduledata), 'invalidfunction');
500         if ($instanceid === 'invalidfunction') {
501             throw new coding_exception("{$this->module->name} does not support drag and drop upload (missing {$this->module->name}_dndupload_handle function");
502         }
504         // Finish setting up the course module.
505         $this->finish_setup_course_module($instanceid);
506     }
508     /**
509      * Generate the name of the mod instance from the name of the file
510      * (remove the extension and convert underscore => space
511      *
512      * @param string $filename the filename of the uploaded file
513      * @return string the display name to use
514      */
515     protected function display_name_from_file($filename) {
516         $pos = textlib::strrpos($filename, '.');
517         if ($pos) { // Want to skip if $pos === 0 OR $pos === false.
518             $filename = textlib::substr($filename, 0, $pos);
519         }
520         return str_replace('_', ' ', $filename);
521     }
523     /**
524      * Create the coursemodule to hold the file/content that has been uploaded
525      */
526     protected function create_course_module() {
527         if (!course_allowed_module($this->course, $this->module->name)) {
528             throw new coding_exception("The module {$this->module->name} is not allowed to be added to this course");
529         }
531         $this->cm = new stdClass();
532         $this->cm->course = $this->course->id;
533         $this->cm->section = $this->section;
534         $this->cm->module = $this->module->id;
535         $this->cm->modulename = $this->module->name;
536         $this->cm->instance = 0; // This will be filled in after we create the instance.
537         $this->cm->visible = 1;
538         $this->cm->groupmode = $this->course->groupmode;
539         $this->cm->groupingid = $this->course->defaultgroupingid;
541         if (!$this->cm->id = add_course_module($this->cm)) {
542             throw new coding_exception("Unable to create the course module");
543         }
544         // The following are used inside some few core functions, so may as well set them here.
545         $this->cm->coursemodule = $this->cm->id;
546         $this->cm->groupmodelink = (!$this->course->groupmodeforce);
547     }
549     /**
550      * Gather together all the details to pass on to the mod, so that it can initialise it's
551      * own database tables
552      *
553      * @param int $draftitemid optional the id of the draft area containing the file (for file uploads)
554      * @param string $content optional the content dropped onto the course (for non-file uploads)
555      * @return object data to pass on to the mod, containing:
556      *              string $type the 'type' as registered with dndupload_handler (or 'Files')
557      *              object $course the course the upload was for
558      *              int $draftitemid optional the id of the draft area containing the files
559      *              int $coursemodule id of the course module that has already been created
560      *              string $displayname the name to use for this activity (can be overriden by the mod)
561      */
562     protected function prepare_module_data($draftitemid = null, $content = null) {
563         $data = new stdClass();
564         $data->type = $this->type;
565         $data->course = $this->course;
566         if ($draftitemid) {
567             $data->draftitemid = $draftitemid;
568         } else if ($content) {
569             $data->content = $content;
570         }
571         $data->coursemodule = $this->cm->id;
572         $data->displayname = $this->displayname;
573         return $data;
574     }
576     /**
577      * Called after the mod has set itself up, to finish off any course module settings
578      * (set instance id, add to correct section, set visibility, etc.) and send the response
579      *
580      * @param int $instanceid id returned by the mod when it was created
581      */
582     protected function finish_setup_course_module($instanceid) {
583         global $DB, $USER;
585         if (!$instanceid) {
586             // Something has gone wrong - undo everything we can.
587             delete_course_module($this->cm->id);
588             throw new moodle_exception('errorcreatingactivity', 'moodle', '', $this->module->name);
589         }
591         $DB->set_field('course_modules', 'instance', $instanceid, array('id' => $this->cm->id));
593         $sectionid = add_mod_to_section($this->cm);
594         $DB->set_field('course_modules', 'section', $sectionid, array('id' => $this->cm->id));
596         set_coursemodule_visible($this->cm->id, true);
598         // Rebuild the course cache and retrieve the final info about this module.
599         rebuild_course_cache($this->course->id, true);
600         $this->course->modinfo = null; // Otherwise we will just get the old version back again.
601         $info = get_fast_modinfo($this->course);
602         if (!isset($info->cms[$this->cm->id])) {
603             // The course module has not been properly created in the course - undo everything.
604             delete_course_module($this->cm->id);
605             throw new moodle_exception('errorcreatingactivity', 'moodle', '', $this->module->name);
606         }
607         $mod = $info->cms[$this->cm->id];
609         // Trigger mod_created event with information about this module.
610         $eventdata = new stdClass();
611         $eventdata->modulename = $mod->modname;
612         $eventdata->name       = $mod->name;
613         $eventdata->cmid       = $mod->id;
614         $eventdata->courseid   = $this->course->id;
615         $eventdata->userid     = $USER->id;
616         events_trigger('mod_created', $eventdata);
618         add_to_log($this->course->id, "course", "add mod",
619                    "../mod/{$mod->modname}/view.php?id=$mod->id",
620                    "{$mod->modname} $instanceid");
621         add_to_log($this->course->id, $mod->modname, "add",
622                    "view.php?id=$mod->id",
623                    "$instanceid", $mod->id);
625         if ($this->cm->groupmodelink && plugin_supports('mod', $mod->modname, FEATURE_GROUPS, 0)) {
626             $mod->groupmodelink = $this->cm->groupmodelink;
627         } else {
628             $mod->groupmodelink = false;
629         }
631         $this->send_response($mod);
632     }
634     /**
635      * Send the details of the newly created activity back to the client browser
636      *
637      * @param cm_info $mod details of the mod just created
638      */
639     protected function send_response($mod) {
640         global $OUTPUT;
642         $resp = new stdClass();
643         $resp->error = self::ERROR_OK;
644         $resp->icon = $mod->get_icon_url()->out();
645         $resp->name = $mod->name;
646         $resp->link = $mod->get_url()->out();
647         $resp->elementid = 'module-'.$mod->id;
648         $resp->commands = make_editing_buttons($mod, true, true, 0, $mod->sectionnum);
649         $resp->onclick = $mod->get_on_click();
651         echo $OUTPUT->header();
652         echo json_encode($resp);
653         die();
654     }