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/>.
  16
  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  */
  25
  26 defined('MOODLE_INTERNAL') || die();
  27
  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');
  31
  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;
  41
  42     $showstatus = optional_param('notifyeditingon', false, PARAM_BOOL);
  43
  44     // Get all handlers.
  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.
  49     }
  50
  51     // Add the javascript to the page.
  52     $jsmodule = array(
  53         'name' => 'coursedndupload',
  54         'fullpath' => '/course/dndupload.js',
  55         'strings' => array(
  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')
  69         ),
  70         'requires' => array('node', 'event', 'json', 'anim')
  71     );
  72     $vars = array(
  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)
  77     );
  78
  79     $PAGE->requires->js_init_call('M.course_dndupload.init', $vars, true, $jsmodule);
  80 }
  81
  82
  83 /**
  84  * Stores all the information about the available dndupload handlers
  85  *
  86  * @package    core
  87  * @copyright  2012 Davo Smith
  88  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  89  */
  90 class dndupload_handler {
  91
  92     /**
  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.
  95      */
  96     protected $types = array();
  97
  98     /**
  99      * @var array  A list of the different file types (extensions) that different modules
 100      *             will handle.
 101      */
 102     protected $filehandlers = array();
 103
 104     /**
 105      * Gather a list of dndupload handlers from the different mods
 106      *
 107      * @param object $course The course this is being added to (to check course_allowed_module() )
 108      */
 109     public function __construct($course, $modnames = null) {
 110         global $CFG, $PAGE;
 111
 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->register_type('url', array('url', 'text/uri-list', 'text/x-moz-url'), get_string('addlinkhere', 'moodle'),
 116                         get_string('nameforlink', 'moodle'), get_string('whatforlink', 'moodle'), 10);
 117         $this->register_type('text/html', array('text/html'), get_string('addpagehere', 'moodle'),
 118                         get_string('nameforpage', 'moodle'), get_string('whatforpage', 'moodle'), 20);
 119         $this->register_type('text', array('text', 'text/plain'), get_string('addpagehere', 'moodle'),
 120                         get_string('nameforpage', 'moodle'), get_string('whatforpage', 'moodle'), 30);
 121
 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) = core_component::normalize_component($component);
 126             if ($modnames && !array_key_exists($modname, $modnames)) {
 127                 continue; // Module is deactivated (hidden) at the site level.
 128             }
 129             if (!course_allowed_module($course, $modname)) {
 130                 continue; // User does not have permission to add this module to the course.
 131             }
 132             $resp = $funcname();
 133             if (!$resp) {
 134                 continue;
 135             }
 136             if (isset($resp['files'])) {
 137                 foreach ($resp['files'] as $file) {
 138                     $this->register_file_handler($file['extension'], $modname, $file['message']);
 139                 }
 140             }
 141             if (isset($resp['addtypes'])) {
 142                 foreach ($resp['addtypes'] as $type) {
 143                     if (isset($type['priority'])) {
 144                         $priority = $type['priority'];
 145                     } else {
 146                         $priority = 100;
 147                     }
 148                     if (!isset($type['handlermessage'])) {
 149                         $type['handlermessage'] = '';
 150                     }
 151                     $this->register_type($type['identifier'], $type['datatransfertypes'],
 152                                     $type['addmessage'], $type['namemessage'], $type['handlermessage'], $priority);
 153                 }
 154             }
 155             if (isset($resp['types'])) {
 156                 foreach ($resp['types'] as $type) {
 157                     $noname = !empty($type['noname']);
 158                     $this->register_type_handler($type['identifier'], $modname, $type['message'], $noname);
 159                 }
 160             }
 161             $PAGE->requires->string_for_js('pluginname', $modname);
 162         }
 163     }
 164
 165     /**
 166      * No external code should be directly adding new types - they should be added via a 'addtypes' array, returned
 167      * by MODNAME_dndupload_register.
 168      *
 169      * @deprecated deprecated since Moodle 2.5
 170      * @param string $identifier
 171      * @param array $datatransfertypes
 172      * @param string $addmessage
 173      * @param string $namemessage
 174      * @param int $priority
 175      */
 176     public function add_type($identifier, $datatransfertypes, $addmessage, $namemessage, $priority=100) {
 177         debugging('add_type() is deprecated. Plugins should be using the MODNAME_dndupload_register callback.');
 178         $this->register_type($identifier, $datatransfertypes, $addmessage, $namemessage, '', $priority);
 179     }
 180
 181     /**
 182      * Used to add a new mime type that can be drag and dropped onto a
 183      * course displayed in a browser window
 184      *
 185      * @param string $identifier The name that this type will be known as
 186      * @param array $datatransfertypes An array of the different types in the browser
 187      *                                 'dataTransfer.types' object that will map to this type
 188      * @param string $addmessage The message to display in the browser when this type is being
 189      *                           dragged onto the page
 190      * @param string $namemessage The message to pop up when asking for the name to give the
 191      *                            course module instance when it is created
 192      * @param string $handlermessage The message to pop up when asking which module should handle this type
 193      * @param int $priority Controls the order in which types are checked by the browser (mainly
 194      *                      needed to check for 'text' last as that is usually given as fallback)
 195      */
 196     protected function register_type($identifier, $datatransfertypes, $addmessage, $namemessage, $handlermessage, $priority=100) {
 197         if ($this->is_known_type($identifier)) {
 198             throw new coding_exception("Type $identifier is already registered");
 199         }
 200
 201         $add = new stdClass;
 202         $add->identifier = $identifier;
 203         $add->datatransfertypes = $datatransfertypes;
 204         $add->addmessage = $addmessage;
 205         $add->namemessage = $namemessage;
 206         $add->handlermessage = $handlermessage;
 207         $add->priority = $priority;
 208         $add->handlers = array();
 209
 210         $this->types[$identifier] = $add;
 211     }
 212
 213     /**
 214      * No external code should be directly adding new type handlers - they should be added via a 'addtypes' array, returned
 215      * by MODNAME_dndupload_register.
 216      *
 217      * @deprecated deprecated since Moodle 2.5
 218      * @param string $type The name of the type (as declared in add_type)
 219      * @param string $module The name of the module to handle this type
 220      * @param string $message The message to show the user if more than one handler is registered
 221      *                        for a type and the user needs to make a choice between them
 222      * @param bool $noname If true, the 'name' dialog should be disabled in the pop-up.
 223      * @throws coding_exception
 224      */
 225     public function add_type_handler($type, $module, $message, $noname) {
 226         debugging('add_type_handler() is deprecated. Plugins should be using the MODNAME_dndupload_register callback.');
 227         $this->register_type_handler($type, $module, $message, $noname);
 228     }
 229
 230     /**
 231      * Used to declare that a particular module will handle a particular type
 232      * of dropped data
 233      *
 234      * @param string $type The name of the type (as declared in register_type)
 235      * @param string $module The name of the module to handle this type
 236      * @param string $message The message to show the user if more than one handler is registered
 237      *                        for a type and the user needs to make a choice between them
 238      * @param bool $noname If true, the 'name' dialog should be disabled in the pop-up.
 239      * @throws coding_exception
 240      */
 241     protected function register_type_handler($type, $module, $message, $noname) {
 242         if (!$this->is_known_type($type)) {
 243             throw new coding_exception("Trying to add handler for unknown type $type");
 244         }
 245
 246         $add = new stdClass;
 247         $add->type = $type;
 248         $add->module = $module;
 249         $add->message = $message;
 250         $add->noname = $noname ? 1 : 0;
 251
 252         $this->types[$type]->handlers[] = $add;
 253     }
 254
 255     /**
 256      * No external code should be directly adding new file handlers - they should be added via a 'files' array, returned
 257      * by MODNAME_dndupload_register.
 258      *
 259      * @deprecated deprecated since Moodle 2.5
 260      * @param string $extension The file extension to handle ('*' for all types)
 261      * @param string $module The name of the module to handle this type
 262      * @param string $message The message to show the user if more than one handler is registered
 263      *                        for a type and the user needs to make a choice between them
 264      */
 265     public function add_file_handler($extension, $module, $message) {
 266         debugging('add_file_handler() is deprecated. Plugins should be using the MODNAME_dndupload_register callback.');
 267         $this->register_file_handler($extension, $module, $message);
 268     }
 269
 270     /**
 271      * Used to declare that a particular module will handle a particular type
 272      * of dropped file
 273      *
 274      * @param string $extension The file extension to handle ('*' for all types)
 275      * @param string $module The name of the module to handle this type
 276      * @param string $message The message to show the user if more than one handler is registered
 277      *                        for a type and the user needs to make a choice between them
 278      */
 279     protected function register_file_handler($extension, $module, $message) {
 280         $extension = strtolower($extension);
 281
 282         $add = new stdClass;
 283         $add->extension = $extension;
 284         $add->module = $module;
 285         $add->message = $message;
 286
 287         $this->filehandlers[] = $add;
 288     }
 289
 290     /**
 291      * Check to see if the type has been registered
 292      *
 293      * @param string $type The identifier of the type you are interested in
 294      * @return bool True if the type is registered
 295      */
 296     public function is_known_type($type) {
 297         return array_key_exists($type, $this->types);
 298     }
 299
 300     /**
 301      * Check to see if the module in question has registered to handle the
 302      * type given
 303      *
 304      * @param string $module The name of the module
 305      * @param string $type The identifier of the type
 306      * @return bool True if the module has registered to handle that type
 307      */
 308     public function has_type_handler($module, $type) {
 309         if (!$this->is_known_type($type)) {
 310             throw new coding_exception("Checking for handler for unknown type $type");
 311         }
 312         foreach ($this->types[$type]->handlers as $handler) {
 313             if ($handler->module == $module) {
 314                 return true;
 315             }
 316         }
 317         return false;
 318     }
 319
 320     /**
 321      * Check to see if the module in question has registered to handle files
 322      * with the given extension (or to handle all file types)
 323      *
 324      * @param string $module The name of the module
 325      * @param string $extension The extension of the uploaded file
 326      * @return bool True if the module has registered to handle files with
 327      *              that extension (or to handle all file types)
 328      */
 329     public function has_file_handler($module, $extension) {
 330         foreach ($this->filehandlers as $handler) {
 331             if ($handler->module == $module) {
 332                 if ($handler->extension == '*' || $handler->extension == $extension) {
 333                     return true;
 334                 }
 335             }
 336         }
 337         return false;
 338     }
 339
 340     /**
 341      * Gets a list of the file types that are handled by a particular module
 342      *
 343      * @param string $module The name of the module to check
 344      * @return array of file extensions or string '*'
 345      */
 346     public function get_handled_file_types($module) {
 347         $types = array();
 348         foreach ($this->filehandlers as $handler) {
 349             if ($handler->module == $module) {
 350                 if ($handler->extension == '*') {
 351                     return '*';
 352                 } else {
 353                     // Prepending '.' as otherwise mimeinfo fails.
 354                     $types[] = '.'.$handler->extension;
 355                 }
 356             }
 357         }
 358         return $types;
 359     }
 360
 361     /**
 362      * Returns an object to pass onto the javascript code with data about all the
 363      * registered file / type handlers
 364      *
 365      * @return object Data to pass on to Javascript code
 366      */
 367     public function get_js_data() {
 368         global $CFG;
 369
 370         $ret = new stdClass;
 371
 372         // Sort the types by priority.
 373         uasort($this->types, array($this, 'type_compare'));
 374
 375         $ret->types = array();
 376         if (!empty($CFG->dndallowtextandlinks)) {
 377             foreach ($this->types as $type) {
 378                 if (empty($type->handlers)) {
 379                     continue; // Skip any types without registered handlers.
 380                 }
 381                 $ret->types[] = $type;
 382             }
 383         }
 384
 385         $ret->filehandlers = $this->filehandlers;
 386         $uploadrepo = repository::get_instances(array('type' => 'upload'));
 387         if (empty($uploadrepo)) {
 388             $ret->filehandlers = array(); // No upload repo => no file handlers.
 389         }
 390
 391         return $ret;
 392     }
 393
 394     /**
 395      * Comparison function used when sorting types by priority
 396      * @param object $type1 first type to compare
 397      * @param object $type2 second type to compare
 398      * @return integer -1 for $type1 < $type2; 1 for $type1 > $type2; 0 for equal
 399      */
 400     protected function type_compare($type1, $type2) {
 401         if ($type1->priority < $type2->priority) {
 402             return -1;
 403         }
 404         if ($type1->priority > $type2->priority) {
 405             return 1;
 406         }
 407         return 0;
 408     }
 409
 410 }
 411
 412 /**
 413  * Processes the upload, creating the course module and returning the result
 414  *
 415  * @package    core
 416  * @copyright  2012 Davo Smith
 417  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 418  */
 419 class dndupload_ajax_processor {
 420
 421     /** Returned when no error has occurred */
 422     const ERROR_OK = 0;
 423
 424     /** @var object The course that we are uploading to */
 425     protected $course = null;
 426
 427     /** @var context_course The course context for capability checking */
 428     protected $context = null;
 429
 430     /** @var int The section number we are uploading to */
 431     protected $section = null;
 432
 433     /** @var string The type of upload (e.g. 'Files', 'text/plain') */
 434     protected $type = null;
 435
 436     /** @var object The details of the module type that will be created */
 437     protected $module= null;
 438
 439     /** @var object The course module that has been created */
 440     protected $cm = null;
 441
 442     /** @var dndupload_handler used to check the allowed file types */
 443     protected $dnduploadhandler = null;
 444
 445     /** @var string The name to give the new activity instance */
 446     protected $displayname = null;
 447
 448     /**
 449      * Set up some basic information needed to handle the upload
 450      *
 451      * @param int $courseid The ID of the course we are uploading to
 452      * @param int $section The section number we are uploading to
 453      * @param string $type The type of upload (as reported by the browser)
 454      * @param string $modulename The name of the module requested to handle this upload
 455      */
 456     public function __construct($courseid, $section, $type, $modulename) {
 457         global $DB;
 458
 459         if (!defined('AJAX_SCRIPT')) {
 460             throw new coding_exception('dndupload_ajax_processor should only be used within AJAX requests');
 461         }
 462
 463         $this->course = $DB->get_record('course', array('id' => $courseid), '*', MUST_EXIST);
 464
 465         require_login($this->course, false);
 466         $this->context = context_course::instance($this->course->id);
 467
 468         if (!is_number($section) || $section < 0) {
 469             throw new coding_exception("Invalid section number $section");
 470         }
 471         $this->section = $section;
 472         $this->type = $type;
 473
 474         if (!$this->module = $DB->get_record('modules', array('name' => $modulename))) {
 475             throw new coding_exception("Module $modulename does not exist");
 476         }
 477
 478         $this->dnduploadhandler = new dndupload_handler($this->course);
 479     }
 480
 481     /**
 482      * Check if this upload is a 'file' upload
 483      *
 484      * @return bool true if it is a 'file' upload, false otherwise
 485      */
 486     protected function is_file_upload() {
 487         return ($this->type == 'Files');
 488     }
 489
 490     /**
 491      * Process the upload - creating the module in the course and returning the result to the browser
 492      *
 493      * @param string $displayname optional the name (from the browser) to give the course module instance
 494      * @param string $content optional the content of the upload (for non-file uploads)
 495      */
 496     public function process($displayname = null, $content = null) {
 497         require_capability('moodle/course:manageactivities', $this->context);
 498
 499         if ($this->is_file_upload()) {
 500             require_capability('moodle/course:managefiles', $this->context);
 501             if ($content != null) {
 502                 throw new moodle_exception('fileuploadwithcontent', 'moodle');
 503             }
 504         } else {
 505             if (empty($content)) {
 506                 throw new moodle_exception('dnduploadwithoutcontent', 'moodle');
 507             }
 508         }
 509
 510         require_sesskey();
 511
 512         $this->displayname = $displayname;
 513
 514         if ($this->is_file_upload()) {
 515             $this->handle_file_upload();
 516         } else {
 517             $this->handle_other_upload($content);
 518         }
 519     }
 520
 521     /**
 522      * Handle uploads containing files - create the course module, ask the upload repository
 523      * to process the file, ask the mod to set itself up, then return the result to the browser
 524      */
 525     protected function handle_file_upload() {
 526         global $CFG;
 527
 528         // Add the file to a draft file area.
 529         $draftitemid = file_get_unused_draft_itemid();
 530         $maxbytes = get_max_upload_file_size($CFG->maxbytes, $this->course->maxbytes);
 531         $types = $this->dnduploadhandler->get_handled_file_types($this->module->name);
 532         $repo = repository::get_instances(array('type' => 'upload'));
 533         if (empty($repo)) {
 534             throw new moodle_exception('errornouploadrepo', 'moodle');
 535         }
 536         $repo = reset($repo); // Get the first (and only) upload repo.
 537         $details = $repo->process_upload(null, $maxbytes, $types, '/', $draftitemid);
 538         if (empty($this->displayname)) {
 539             $this->displayname = $this->display_name_from_file($details['file']);
 540         }
 541
 542         // Create a course module to hold the new instance.
 543         $this->create_course_module();
 544
 545         // Ask the module to set itself up.
 546         $moduledata = $this->prepare_module_data($draftitemid);
 547         $instanceid = plugin_callback('mod', $this->module->name, 'dndupload', 'handle', array($moduledata), 'invalidfunction');
 548         if ($instanceid === 'invalidfunction') {
 549             throw new coding_exception("{$this->module->name} does not support drag and drop upload (missing {$this->module->name}_dndupload_handle function");
 550         }
 551
 552         // Finish setting up the course module.
 553         $this->finish_setup_course_module($instanceid);
 554     }
 555
 556     /**
 557      * Handle uploads not containing file - create the course module, ask the mod to
 558      * set itself up, then return the result to the browser
 559      *
 560      * @param string $content the content uploaded to the browser
 561      */
 562     protected function handle_other_upload($content) {
 563         // Check this plugin is registered to handle this type of upload
 564         if (!$this->dnduploadhandler->has_type_handler($this->module->name, $this->type)) {
 565             $info = (object)array('modname' => $this->module->name, 'type' => $this->type);
 566             throw new moodle_exception('moddoesnotsupporttype', 'moodle', $info);
 567         }
 568
 569         // Create a course module to hold the new instance.
 570         $this->create_course_module();
 571
 572         // Ask the module to set itself up.
 573         $moduledata = $this->prepare_module_data(null, $content);
 574         $instanceid = plugin_callback('mod', $this->module->name, 'dndupload', 'handle', array($moduledata), 'invalidfunction');
 575         if ($instanceid === 'invalidfunction') {
 576             throw new coding_exception("{$this->module->name} does not support drag and drop upload (missing {$this->module->name}_dndupload_handle function");
 577         }
 578
 579         // Finish setting up the course module.
 580         $this->finish_setup_course_module($instanceid);
 581     }
 582
 583     /**
 584      * Generate the name of the mod instance from the name of the file
 585      * (remove the extension and convert underscore => space
 586      *
 587      * @param string $filename the filename of the uploaded file
 588      * @return string the display name to use
 589      */
 590     protected function display_name_from_file($filename) {
 591         $pos = core_text::strrpos($filename, '.');
 592         if ($pos) { // Want to skip if $pos === 0 OR $pos === false.
 593             $filename = core_text::substr($filename, 0, $pos);
 594         }
 595         return str_replace('_', ' ', $filename);
 596     }
 597
 598     /**
 599      * Create the coursemodule to hold the file/content that has been uploaded
 600      */
 601     protected function create_course_module() {
 602         global $CFG;
 603
 604         if (!course_allowed_module($this->course, $this->module->name)) {
 605             throw new coding_exception("The module {$this->module->name} is not allowed to be added to this course");
 606         }
 607
 608         $this->cm = new stdClass();
 609         $this->cm->course = $this->course->id;
 610         $this->cm->section = $this->section;
 611         $this->cm->module = $this->module->id;
 612         $this->cm->modulename = $this->module->name;
 613         $this->cm->instance = 0; // This will be filled in after we create the instance.
 614         $this->cm->visible = 1;
 615         $this->cm->groupmode = $this->course->groupmode;
 616         $this->cm->groupingid = $this->course->defaultgroupingid;
 617
 618         // Set the correct default for completion tracking.
 619         $this->cm->completion = COMPLETION_TRACKING_NONE;
 620         $completion = new completion_info($this->course);
 621         if ($completion->is_enabled() && $CFG->completiondefault) {
 622             if (plugin_supports('mod', $this->cm->modulename, FEATURE_MODEDIT_DEFAULT_COMPLETION, true)) {
 623                 $this->cm->completion = COMPLETION_TRACKING_MANUAL;
 624             }
 625         }
 626
 627         if (!$this->cm->id = add_course_module($this->cm)) {
 628             throw new coding_exception("Unable to create the course module");
 629         }
 630         $this->cm->coursemodule = $this->cm->id;
 631     }
 632
 633     /**
 634      * Gather together all the details to pass on to the mod, so that it can initialise it's
 635      * own database tables
 636      *
 637      * @param int $draftitemid optional the id of the draft area containing the file (for file uploads)
 638      * @param string $content optional the content dropped onto the course (for non-file uploads)
 639      * @return object data to pass on to the mod, containing:
 640      *              string $type the 'type' as registered with dndupload_handler (or 'Files')
 641      *              object $course the course the upload was for
 642      *              int $draftitemid optional the id of the draft area containing the files
 643      *              int $coursemodule id of the course module that has already been created
 644      *              string $displayname the name to use for this activity (can be overriden by the mod)
 645      */
 646     protected function prepare_module_data($draftitemid = null, $content = null) {
 647         $data = new stdClass();
 648         $data->type = $this->type;
 649         $data->course = $this->course;
 650         if ($draftitemid) {
 651             $data->draftitemid = $draftitemid;
 652         } else if ($content) {
 653             $data->content = $content;
 654         }
 655         $data->coursemodule = $this->cm->id;
 656         $data->displayname = $this->displayname;
 657         return $data;
 658     }
 659
 660     /**
 661      * Called after the mod has set itself up, to finish off any course module settings
 662      * (set instance id, add to correct section, set visibility, etc.) and send the response
 663      *
 664      * @param int $instanceid id returned by the mod when it was created
 665      */
 666     protected function finish_setup_course_module($instanceid) {
 667         global $DB, $USER;
 668
 669         if (!$instanceid) {
 670             // Something has gone wrong - undo everything we can.
 671             course_delete_module($this->cm->id);
 672             throw new moodle_exception('errorcreatingactivity', 'moodle', '', $this->module->name);
 673         }
 674
 675         // Note the section visibility
 676         $visible = get_fast_modinfo($this->course)->get_section_info($this->section)->visible;
 677
 678         $DB->set_field('course_modules', 'instance', $instanceid, array('id' => $this->cm->id));
 679         // Rebuild the course cache after update action
 680         rebuild_course_cache($this->course->id, true);
 681
 682         $sectionid = course_add_cm_to_section($this->course, $this->cm->id, $this->section);
 683
 684         set_coursemodule_visible($this->cm->id, $visible);
 685         if (!$visible) {
 686             $DB->set_field('course_modules', 'visibleold', 1, array('id' => $this->cm->id));
 687         }
 688
 689         // retrieve the final info about this module.
 690         $info = get_fast_modinfo($this->course);
 691         if (!isset($info->cms[$this->cm->id])) {
 692             // The course module has not been properly created in the course - undo everything.
 693             course_delete_module($this->cm->id);
 694             throw new moodle_exception('errorcreatingactivity', 'moodle', '', $this->module->name);
 695         }
 696         $mod = $info->get_cm($this->cm->id);
 697
 698         // Trigger course module created event.
 699         $event = \core\event\course_module_created::create(array(
 700             'courseid' => $this->course->id,
 701             'context'  => context_module::instance($mod->id),
 702             'objectid' => $mod->id,
 703             'other'    => array(
 704                 'modulename' => $mod->modname,
 705                 'name'       => $mod->name,
 706                 'instanceid' => $instanceid
 707             )
 708         ));
 709         $event->trigger();
 710
 711         add_to_log($this->course->id, $mod->modname, "add",
 712                    "view.php?id=$mod->id",
 713                    "$instanceid", $mod->id);
 714
 715         $this->send_response($mod);
 716     }
 717
 718     /**
 719      * Send the details of the newly created activity back to the client browser
 720      *
 721      * @param cm_info $mod details of the mod just created
 722      */
 723     protected function send_response($mod) {
 724         global $OUTPUT, $PAGE;
 725         $courserenderer = $PAGE->get_renderer('core', 'course');
 726
 727         $resp = new stdClass();
 728         $resp->error = self::ERROR_OK;
 729         $resp->icon = $mod->get_icon_url()->out();
 730         $resp->name = $mod->name;
 731         if ($mod->has_view()) {
 732             $resp->link = $mod->get_url()->out();
 733         } else {
 734             $resp->link = null;
 735         }
 736         $resp->content = $mod->get_content();
 737         $resp->elementid = 'module-'.$mod->id;
 738         $actions = course_get_cm_edit_actions($mod, 0, $mod->sectionnum);
 739         $resp->commands = ' '. $courserenderer->course_section_cm_edit_actions($actions, $mod);
 740         $resp->onclick = $mod->get_on_click();
 741         $resp->visible = $mod->visible;
 742
 743         // If using groupings, then display grouping name.
 744         if (!empty($mod->groupingid) && has_capability('moodle/course:managegroups', $this->context)) {
 745             $groupings = groups_get_all_groupings($this->course->id);
 746             $resp->groupingname = format_string($groupings[$mod->groupingid]->name);
 747         }
 748
 749         echo $OUTPUT->header();
 750         echo json_encode($resp);
 751         die();
 752     }
 753 }