2 // This file is part of Moodle - http://moodle.org/
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.
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.
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/>.
18 * Library to handle drag and drop course uploads
22 * @copyright 2012 Davo smith
23 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
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');
33 * Add the Javascript to enable drag and drop upload to a course page
35 * @param object $course The currently displayed course
36 * @param array $modnames The list of enabled (visible) modules on this site
39 function dndupload_add_to_course($course, $modnames) {
42 $showstatus = optional_param('notifyeditingon', false, PARAM_BOOL
);
45 $handler = new dndupload_handler($course, $modnames);
46 $jsdata = $handler->get_js_data();
47 if (empty($jsdata->types
) && empty($jsdata->filehandlers
)) {
48 return; // No valid handlers - don't enable drag and drop.
51 // Add the javascript to the page.
53 'name' => 'coursedndupload',
54 'fullpath' => new moodle_url('/course/dndupload.js'),
56 array('addfilehere', 'moodle'),
57 array('dndworkingfiletextlink', 'moodle'),
58 array('dndworkingfilelink', 'moodle'),
59 array('dndworkingfiletext', 'moodle'),
60 array('dndworkingfile', 'moodle'),
61 array('dndworkingtextlink', 'moodle'),
62 array('dndworkingtext', 'moodle'),
63 array('dndworkinglink', 'moodle'),
64 array('filetoolarge', 'moodle'),
65 array('actionchoice', 'moodle'),
66 array('servererror', 'moodle'),
67 array('upload', 'moodle'),
68 array('cancel', 'moodle')
70 'requires' => array('node', 'event', 'panel', 'json', 'anim')
73 array('courseid' => $course->id
,
74 'maxbytes' => get_max_upload_file_size($CFG->maxbytes
, $course->maxbytes
),
75 'handlers' => $handler->get_js_data(),
76 'showstatus' => $showstatus)
79 $PAGE->requires
->js_init_call('M.course_dndupload.init', $vars, true, $jsmodule);
84 * Stores all the information about the available dndupload handlers
87 * @copyright 2012 Davo Smith
88 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
90 class dndupload_handler
{
93 * @var array A list of all registered mime types that can be dropped onto a course
94 * along with the modules that will handle them.
96 protected $types = array();
99 * @var array A list of the different file types (extensions) that different modules
102 protected $filehandlers = array();
105 * Gather a list of dndupload handlers from the different mods
107 * @param object $course The course this is being added to (to check course_allowed_module() )
109 public function __construct($course, $modnames = null) {
112 // Add some default types to handle.
113 // Note: 'Files' type is hard-coded into the Javascript as this needs to be ...
114 // ... treated a little differently.
115 $this->add_type('url', array('url', 'text/uri-list', 'text/x-moz-url'), get_string('addlinkhere', 'moodle'),
116 get_string('nameforlink', 'moodle'), 10);
117 $this->add_type('text/html', array('text/html'), get_string('addpagehere', 'moodle'),
118 get_string('nameforpage', 'moodle'), 20);
119 $this->add_type('text', array('text', 'text/plain'), get_string('addpagehere', 'moodle'),
120 get_string('nameforpage', 'moodle'), 30);
122 // Loop through all modules to find handlers.
123 $mods = get_plugin_list_with_function('mod', 'dndupload_register');
124 foreach ($mods as $component => $funcname) {
125 list($modtype, $modname) = normalize_component($component);
126 if ($modnames && !array_key_exists($modname, $modnames)) {
127 continue; // Module is deactivated (hidden) at the site level.
129 if (!course_allowed_module($course, $modname)) {
130 continue; // User does not have permission to add this module to the course.
136 if (isset($resp['files'])) {
137 foreach ($resp['files'] as $file) {
138 $this->add_file_handler($file['extension'], $modname, $file['message']);
141 if (isset($resp['addtypes'])) {
142 foreach ($resp['addtypes'] as $type) {
143 if (isset($type['priority'])) {
144 $priority = $type['priority'];
148 $this->add_type($type['identifier'], $type['datatransfertypes'],
149 $type['addmessage'], $type['namemessage'], $priority);
152 if (isset($resp['types'])) {
153 foreach ($resp['types'] as $type) {
154 $this->add_type_handler($type['identifier'], $modname, $type['message']);
161 * Used to add a new mime type that can be drag and dropped onto a
162 * course displayed in a browser window
164 * @param string $identifier The name that this type will be known as
165 * @param array $datatransfertypes An array of the different types in the browser
166 * 'dataTransfer.types' object that will map to this type
167 * @param string $addmessage The message to display in the browser when this type is being
168 * dragged onto the page
169 * @param string $namemessage The message to pop up when asking for the name to give the
170 * course module instance when it is created
171 * @param int $priority Controls the order in which types are checked by the browser (mainly
172 * needed to check for 'text' last as that is usually given as fallback)
174 public function add_type($identifier, $datatransfertypes, $addmessage, $namemessage, $priority=100) {
175 if ($this->is_known_type($identifier)) {
176 throw new coding_exception("Type $identifier is already registered");
180 $add->identifier
= $identifier;
181 $add->datatransfertypes
= $datatransfertypes;
182 $add->addmessage
= $addmessage;
183 $add->namemessage
= $namemessage;
184 $add->priority
= $priority;
185 $add->handlers
= array();
187 $this->types
[$identifier] = $add;
191 * Used to declare that a particular module will handle a particular type
194 * @param string $type The name of the type (as declared in add_type)
195 * @param string $module The name of the module to handle this type
196 * @param string $message The message to show the user if more than one handler is registered
197 * for a type and the user needs to make a choice between them
199 public function add_type_handler($type, $module, $message) {
200 if (!$this->is_known_type($type)) {
201 throw new coding_exception("Trying to add handler for unknown type $type");
206 $add->module
= $module;
207 $add->message
= $message;
209 $this->types
[$type]->handlers
[] = $add;
213 * Used to declare that a particular module will handle a particular type
216 * @param string $extension The file extension to handle ('*' for all types)
217 * @param string $module The name of the module to handle this type
218 * @param string $message The message to show the user if more than one handler is registered
219 * for a type and the user needs to make a choice between them
221 public function add_file_handler($extension, $module, $message) {
222 $extension = strtolower($extension);
225 $add->extension
= $extension;
226 $add->module
= $module;
227 $add->message
= $message;
229 $this->filehandlers
[] = $add;
233 * Check to see if the type has been registered
235 * @param string $type The identifier of the type you are interested in
236 * @return bool True if the type is registered
238 public function is_known_type($type) {
239 return array_key_exists($type, $this->types
);
243 * Check to see if the module in question has registered to handle the
246 * @param string $module The name of the module
247 * @param string $type The identifier of the type
248 * @return bool True if the module has registered to handle that type
250 public function has_type_handler($module, $type) {
251 if (!$this->is_known_type($type)) {
252 throw new coding_exception("Checking for handler for unknown type $type");
254 foreach ($this->types
[$type]->handlers
as $handler) {
255 if ($handler->module
== $module) {
263 * Check to see if the module in question has registered to handle files
264 * with the given extension (or to handle all file types)
266 * @param string $module The name of the module
267 * @param string $extension The extension of the uploaded file
268 * @return bool True if the module has registered to handle files with
269 * that extension (or to handle all file types)
271 public function has_file_handler($module, $extension) {
272 foreach ($this->filehandlers
as $handler) {
273 if ($handler->module
== $module) {
274 if ($handler->extension
== '*' ||
$handler->extension
== $extension) {
283 * Gets a list of the file types that are handled by a particular module
285 * @param string $module The name of the module to check
286 * @return array of file extensions or string '*'
288 public function get_handled_file_types($module) {
290 foreach ($this->filehandlers
as $handler) {
291 if ($handler->module
== $module) {
292 if ($handler->extension
== '*') {
295 // Prepending '.' as otherwise mimeinfo fails.
296 $types[] = '.'.$handler->extension
;
304 * Returns an object to pass onto the javascript code with data about all the
305 * registered file / type handlers
307 * @return object Data to pass on to Javascript code
309 public function get_js_data() {
314 // Sort the types by priority.
315 uasort($this->types
, array($this, 'type_compare'));
317 $ret->types
= array();
318 if (!empty($CFG->dndallowtextandlinks
)) {
319 foreach ($this->types
as $type) {
320 if (empty($type->handlers
)) {
321 continue; // Skip any types without registered handlers.
323 $ret->types
[] = $type;
327 $ret->filehandlers
= $this->filehandlers
;
328 $uploadrepo = repository
::get_instances(array('type' => 'upload'));
329 if (empty($uploadrepo)) {
330 $ret->filehandlers
= array(); // No upload repo => no file handlers.
337 * Comparison function used when sorting types by priority
338 * @param object $type1 first type to compare
339 * @param object $type2 second type to compare
340 * @return integer -1 for $type1 < $type2; 1 for $type1 > $type2; 0 for equal
342 protected function type_compare($type1, $type2) {
343 if ($type1->priority
< $type2->priority
) {
346 if ($type1->priority
> $type2->priority
) {
355 * Processes the upload, creating the course module and returning the result
358 * @copyright 2012 Davo Smith
359 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
361 class dndupload_ajax_processor
{
363 /** Returned when no error has occurred */
366 /** @var object The course that we are uploading to */
367 protected $course = null;
369 /** @var context_course The course context for capability checking */
370 protected $context = null;
372 /** @var int The section number we are uploading to */
373 protected $section = null;
375 /** @var string The type of upload (e.g. 'Files', 'text/plain') */
376 protected $type = null;
378 /** @var object The details of the module type that will be created */
379 protected $module= null;
381 /** @var object The course module that has been created */
382 protected $cm = null;
384 /** @var dndupload_handler used to check the allowed file types */
385 protected $dnduploadhandler = null;
387 /** @var string The name to give the new activity instance */
388 protected $displayname = null;
391 * Set up some basic information needed to handle the upload
393 * @param int $courseid The ID of the course we are uploading to
394 * @param int $section The section number we are uploading to
395 * @param string $type The type of upload (as reported by the browser)
396 * @param string $modulename The name of the module requested to handle this upload
398 public function __construct($courseid, $section, $type, $modulename) {
401 if (!defined('AJAX_SCRIPT')) {
402 throw new coding_exception('dndupload_ajax_processor should only be used within AJAX requests');
405 $this->course
= $DB->get_record('course', array('id' => $courseid), '*', MUST_EXIST
);
407 require_login($this->course
, false);
408 $this->context
= context_course
::instance($this->course
->id
);
410 if (!is_number($section) ||
$section < 0) {
411 throw new coding_exception("Invalid section number $section");
413 $this->section
= $section;
416 if (!$this->module
= $DB->get_record('modules', array('name' => $modulename))) {
417 throw new coding_exception("Module $modulename does not exist");
420 $this->dnduploadhandler
= new dndupload_handler($this->course
);
424 * Check if this upload is a 'file' upload
426 * @return bool true if it is a 'file' upload, false otherwise
428 protected function is_file_upload() {
429 return ($this->type
== 'Files');
433 * Process the upload - creating the module in the course and returning the result to the browser
435 * @param string $displayname optional the name (from the browser) to give the course module instance
436 * @param string $content optional the content of the upload (for non-file uploads)
438 public function process($displayname = null, $content = null) {
439 require_capability('moodle/course:manageactivities', $this->context
);
441 if ($this->is_file_upload()) {
442 require_capability('moodle/course:managefiles', $this->context
);
443 if ($content != null) {
444 throw new moodle_exception('fileuploadwithcontent', 'moodle');
447 if (empty($content)) {
448 throw new moodle_exception('dnduploadwithoutcontent', 'moodle');
454 $this->displayname
= $displayname;
456 if ($this->is_file_upload()) {
457 $this->handle_file_upload();
459 $this->handle_other_upload($content);
464 * Handle uploads containing files - create the course module, ask the upload repository
465 * to process the file, ask the mod to set itself up, then return the result to the browser
467 protected function handle_file_upload() {
470 // Add the file to a draft file area.
471 $draftitemid = file_get_unused_draft_itemid();
472 $maxbytes = get_max_upload_file_size($CFG->maxbytes
, $this->course
->maxbytes
);
473 $types = $this->dnduploadhandler
->get_handled_file_types($this->module
->name
);
474 $repo = repository
::get_instances(array('type' => 'upload'));
476 throw new moodle_exception('errornouploadrepo', 'moodle');
478 $repo = reset($repo); // Get the first (and only) upload repo.
479 $details = $repo->process_upload(null, $maxbytes, $types, '/', $draftitemid);
480 if (empty($this->displayname
)) {
481 $this->displayname
= $this->display_name_from_file($details['file']);
484 // Create a course module to hold the new instance.
485 $this->create_course_module();
487 // Ask the module to set itself up.
488 $moduledata = $this->prepare_module_data($draftitemid);
489 $instanceid = plugin_callback('mod', $this->module
->name
, 'dndupload', 'handle', array($moduledata), 'invalidfunction');
490 if ($instanceid === 'invalidfunction') {
491 throw new coding_exception("{$this->module->name} does not support drag and drop upload (missing {$this->module->name}_dndupload_handle function");
494 // Finish setting up the course module.
495 $this->finish_setup_course_module($instanceid);
499 * Handle uploads not containing file - create the course module, ask the mod to
500 * set itself up, then return the result to the browser
502 * @param string $content the content uploaded to the browser
504 protected function handle_other_upload($content) {
505 // Check this plugin is registered to handle this type of upload
506 if (!$this->dnduploadhandler
->has_type_handler($this->module
->name
, $this->type
)) {
507 $info = (object)array('modname' => $this->module
->name
, 'type' => $this->type
);
508 throw new moodle_exception('moddoesnotsupporttype', 'moodle', $info);
511 // Create a course module to hold the new instance.
512 $this->create_course_module();
514 // Ask the module to set itself up.
515 $moduledata = $this->prepare_module_data(null, $content);
516 $instanceid = plugin_callback('mod', $this->module
->name
, 'dndupload', 'handle', array($moduledata), 'invalidfunction');
517 if ($instanceid === 'invalidfunction') {
518 throw new coding_exception("{$this->module->name} does not support drag and drop upload (missing {$this->module->name}_dndupload_handle function");
521 // Finish setting up the course module.
522 $this->finish_setup_course_module($instanceid);
526 * Generate the name of the mod instance from the name of the file
527 * (remove the extension and convert underscore => space
529 * @param string $filename the filename of the uploaded file
530 * @return string the display name to use
532 protected function display_name_from_file($filename) {
533 $pos = textlib
::strrpos($filename, '.');
534 if ($pos) { // Want to skip if $pos === 0 OR $pos === false.
535 $filename = textlib
::substr($filename, 0, $pos);
537 return str_replace('_', ' ', $filename);
541 * Create the coursemodule to hold the file/content that has been uploaded
543 protected function create_course_module() {
544 if (!course_allowed_module($this->course
, $this->module
->name
)) {
545 throw new coding_exception("The module {$this->module->name} is not allowed to be added to this course");
548 $this->cm
= new stdClass();
549 $this->cm
->course
= $this->course
->id
;
550 $this->cm
->section
= $this->section
;
551 $this->cm
->module
= $this->module
->id
;
552 $this->cm
->modulename
= $this->module
->name
;
553 $this->cm
->instance
= 0; // This will be filled in after we create the instance.
554 $this->cm
->visible
= 1;
555 $this->cm
->groupmode
= $this->course
->groupmode
;
556 $this->cm
->groupingid
= $this->course
->defaultgroupingid
;
558 if (!$this->cm
->id
= add_course_module($this->cm
)) {
559 throw new coding_exception("Unable to create the course module");
561 // The following are used inside some few core functions, so may as well set them here.
562 $this->cm
->coursemodule
= $this->cm
->id
;
563 $groupbuttons = ($this->course
->groupmode
or (!$this->course
->groupmodeforce
));
564 if ($groupbuttons and plugin_supports('mod', $this->module
->name
, FEATURE_GROUPS
, 0)) {
565 $this->cm
->groupmodelink
= (!$this->course
->groupmodeforce
);
567 $this->cm
->groupmodelink
= false;
568 $this->cm
->groupmode
= false;
573 * Gather together all the details to pass on to the mod, so that it can initialise it's
574 * own database tables
576 * @param int $draftitemid optional the id of the draft area containing the file (for file uploads)
577 * @param string $content optional the content dropped onto the course (for non-file uploads)
578 * @return object data to pass on to the mod, containing:
579 * string $type the 'type' as registered with dndupload_handler (or 'Files')
580 * object $course the course the upload was for
581 * int $draftitemid optional the id of the draft area containing the files
582 * int $coursemodule id of the course module that has already been created
583 * string $displayname the name to use for this activity (can be overriden by the mod)
585 protected function prepare_module_data($draftitemid = null, $content = null) {
586 $data = new stdClass();
587 $data->type
= $this->type
;
588 $data->course
= $this->course
;
590 $data->draftitemid
= $draftitemid;
591 } else if ($content) {
592 $data->content
= $content;
594 $data->coursemodule
= $this->cm
->id
;
595 $data->displayname
= $this->displayname
;
600 * Called after the mod has set itself up, to finish off any course module settings
601 * (set instance id, add to correct section, set visibility, etc.) and send the response
603 * @param int $instanceid id returned by the mod when it was created
605 protected function finish_setup_course_module($instanceid) {
609 // Something has gone wrong - undo everything we can.
610 delete_course_module($this->cm
->id
);
611 throw new moodle_exception('errorcreatingactivity', 'moodle', '', $this->module
->name
);
614 $DB->set_field('course_modules', 'instance', $instanceid, array('id' => $this->cm
->id
));
616 $sectionid = add_mod_to_section($this->cm
);
617 $DB->set_field('course_modules', 'section', $sectionid, array('id' => $this->cm
->id
));
619 set_coursemodule_visible($this->cm
->id
, true);
621 // Rebuild the course cache and retrieve the final info about this module.
622 rebuild_course_cache($this->course
->id
, true);
623 $this->course
->modinfo
= null; // Otherwise we will just get the old version back again.
624 $info = get_fast_modinfo($this->course
);
625 if (!isset($info->cms
[$this->cm
->id
])) {
626 // The course module has not been properly created in the course - undo everything.
627 delete_course_module($this->cm
->id
);
628 throw new moodle_exception('errorcreatingactivity', 'moodle', '', $this->module
->name
);
630 $mod = $info->cms
[$this->cm
->id
];
631 $mod->groupmodelink
= $this->cm
->groupmodelink
;
632 $mod->groupmode
= $this->cm
->groupmode
;
634 // Trigger mod_created event with information about this module.
635 $eventdata = new stdClass();
636 $eventdata->modulename
= $mod->modname
;
637 $eventdata->name
= $mod->name
;
638 $eventdata->cmid
= $mod->id
;
639 $eventdata->courseid
= $this->course
->id
;
640 $eventdata->userid
= $USER->id
;
641 events_trigger('mod_created', $eventdata);
643 add_to_log($this->course
->id
, "course", "add mod",
644 "../mod/{$mod->modname}/view.php?id=$mod->id",
645 "{$mod->modname} $instanceid");
646 add_to_log($this->course
->id
, $mod->modname
, "add",
647 "view.php?id=$mod->id",
648 "$instanceid", $mod->id
);
650 $this->send_response($mod);
654 * Send the details of the newly created activity back to the client browser
656 * @param cm_info $mod details of the mod just created
658 protected function send_response($mod) {
661 $resp = new stdClass();
662 $resp->error
= self
::ERROR_OK
;
663 $resp->icon
= $mod->get_icon_url()->out();
664 $resp->name
= $mod->name
;
665 $resp->link
= $mod->get_url()->out();
666 $resp->elementid
= 'module-'.$mod->id
;
667 $resp->commands
= make_editing_buttons($mod, true, true, 0, $mod->sectionnum
);
668 $resp->onclick
= $mod->get_on_click();
670 // if using groupings, then display grouping name
671 if (!empty($mod->groupingid
) && has_capability('moodle/course:managegroups', $this->context
)) {
672 $groupings = groups_get_all_groupings($this->course
->id
);
673 $resp->groupingname
= format_string($groupings[$mod->groupingid
]->name
);
676 echo $OUTPUT->header();
677 echo json_encode($resp);