[Summary view]

Differences Between: [Versions 310 and 400] [Versions 311 and 400] [Versions 39 and 400] [Versions 400 and 401] [Versions 400 and 402] [Versions 400 and 403]

   1  <?php
   2  
   3  // This file is part of Moodle - http://moodle.org/
   4  //
   5  // Moodle is free software: you can redistribute it and/or modify
   6  // it under the terms of the GNU General Public License as published by
   7  // the Free Software Foundation, either version 3 of the License, or
   8  // (at your option) any later version.
   9  //
  10  // Moodle is distributed in the hope that it will be useful,
  11  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  // GNU General Public License for more details.
  14  //
  15  // You should have received a copy of the GNU General Public License
  16  // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  17  
  18  /**
  19   * Library of functions and constants for module label
  20   *
  21   * @package mod_label
  22   * @copyright  1999 onwards Martin Dougiamas  {@link http://moodle.com}
  23   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  24   */
  25  
  26  defined('MOODLE_INTERNAL') || die;
  27  
  28  /** LABEL_MAX_NAME_LENGTH = 50 */
  29  define("LABEL_MAX_NAME_LENGTH", 50);
  30  
  31  /**
  32   * @uses LABEL_MAX_NAME_LENGTH
  33   * @param object $label
  34   * @return string
  35   */
  36  function get_label_name($label) {
  37      $name = html_to_text(format_string($label->intro, true));
  38      $name = preg_replace('/@@PLUGINFILE@@\/[[:^space:]]+/i', '', $name);
  39      // Remove double space and also nbsp; characters.
  40      $name = preg_replace('/\s+/u', ' ', $name);
  41      $name = trim($name);
  42      if (core_text::strlen($name) > LABEL_MAX_NAME_LENGTH) {
  43          $name = core_text::substr($name, 0, LABEL_MAX_NAME_LENGTH) . "...";
  44      }
  45  
  46      if (empty($name)) {
  47          // arbitrary name
  48          $name = get_string('modulename','label');
  49      }
  50  
  51      return $name;
  52  }
  53  /**
  54   * Given an object containing all the necessary data,
  55   * (defined by the form in mod_form.php) this function
  56   * will create a new instance and return the id number
  57   * of the new instance.
  58   *
  59   * @global object
  60   * @param object $label
  61   * @return bool|int
  62   */
  63  function label_add_instance($label) {
  64      global $DB;
  65  
  66      $label->name = get_label_name($label);
  67      $label->timemodified = time();
  68  
  69      $id = $DB->insert_record("label", $label);
  70  
  71      $completiontimeexpected = !empty($label->completionexpected) ? $label->completionexpected : null;
  72      \core_completion\api::update_completion_date_event($label->coursemodule, 'label', $id, $completiontimeexpected);
  73  
  74      return $id;
  75  }
  76  
  77  /**
  78   * Sets the special label display on course page.
  79   *
  80   * @param cm_info $cm Course-module object
  81   */
  82  function label_cm_info_view(cm_info $cm) {
  83      $cm->set_custom_cmlist_item(true);
  84  }
  85  
  86  /**
  87   * Given an object containing all the necessary data,
  88   * (defined by the form in mod_form.php) this function
  89   * will update an existing instance with new data.
  90   *
  91   * @global object
  92   * @param object $label
  93   * @return bool
  94   */
  95  function label_update_instance($label) {
  96      global $DB;
  97  
  98      $label->name = get_label_name($label);
  99      $label->timemodified = time();
 100      $label->id = $label->instance;
 101  
 102      $completiontimeexpected = !empty($label->completionexpected) ? $label->completionexpected : null;
 103      \core_completion\api::update_completion_date_event($label->coursemodule, 'label', $label->id, $completiontimeexpected);
 104  
 105      return $DB->update_record("label", $label);
 106  }
 107  
 108  /**
 109   * Given an ID of an instance of this module,
 110   * this function will permanently delete the instance
 111   * and any data that depends on it.
 112   *
 113   * @global object
 114   * @param int $id
 115   * @return bool
 116   */
 117  function label_delete_instance($id) {
 118      global $DB;
 119  
 120      if (! $label = $DB->get_record("label", array("id"=>$id))) {
 121          return false;
 122      }
 123  
 124      $result = true;
 125  
 126      $cm = get_coursemodule_from_instance('label', $id);
 127      \core_completion\api::update_completion_date_event($cm->id, 'label', $label->id, null);
 128  
 129      if (! $DB->delete_records("label", array("id"=>$label->id))) {
 130          $result = false;
 131      }
 132  
 133      return $result;
 134  }
 135  
 136  /**
 137   * Given a course_module object, this function returns any
 138   * "extra" information that may be needed when printing
 139   * this activity in a course listing.
 140   * See get_array_of_activities() in course/lib.php
 141   *
 142   * @global object
 143   * @param object $coursemodule
 144   * @return cached_cm_info|null
 145   */
 146  function label_get_coursemodule_info($coursemodule) {
 147      global $DB;
 148  
 149      if ($label = $DB->get_record('label', array('id'=>$coursemodule->instance), 'id, name, intro, introformat')) {
 150          if (empty($label->name)) {
 151              // label name missing, fix it
 152              $label->name = "label{$label->id}";
 153              $DB->set_field('label', 'name', $label->name, array('id'=>$label->id));
 154          }
 155          $info = new cached_cm_info();
 156          // no filtering hre because this info is cached and filtered later
 157          $info->content = format_module_intro('label', $label, $coursemodule->id, false);
 158          $info->name  = $label->name;
 159          return $info;
 160      } else {
 161          return null;
 162      }
 163  }
 164  
 165  /**
 166   * This function is used by the reset_course_userdata function in moodlelib.
 167   *
 168   * @param object $data the data submitted from the reset course.
 169   * @return array status array
 170   */
 171  function label_reset_userdata($data) {
 172  
 173      // Any changes to the list of dates that needs to be rolled should be same during course restore and course reset.
 174      // See MDL-9367.
 175  
 176      return array();
 177  }
 178  
 179  /**
 180   * @uses FEATURE_IDNUMBER
 181   * @uses FEATURE_GROUPS
 182   * @uses FEATURE_GROUPINGS
 183   * @uses FEATURE_MOD_INTRO
 184   * @uses FEATURE_COMPLETION_TRACKS_VIEWS
 185   * @uses FEATURE_GRADE_HAS_GRADE
 186   * @uses FEATURE_GRADE_OUTCOMES
 187   * @param string $feature FEATURE_xx constant for requested feature
 188   * @return mixed True if module supports feature, false if not, null if doesn't know or string for the module purpose.
 189   */
 190  function label_supports($feature) {
 191      switch($feature) {
 192          case FEATURE_IDNUMBER:                return true;
 193          case FEATURE_GROUPS:                  return false;
 194          case FEATURE_GROUPINGS:               return false;
 195          case FEATURE_MOD_INTRO:               return true;
 196          case FEATURE_COMPLETION_TRACKS_VIEWS: return false;
 197          case FEATURE_GRADE_HAS_GRADE:         return false;
 198          case FEATURE_GRADE_OUTCOMES:          return false;
 199          case FEATURE_MOD_ARCHETYPE:           return MOD_ARCHETYPE_RESOURCE;
 200          case FEATURE_BACKUP_MOODLE2:          return true;
 201          case FEATURE_NO_VIEW_LINK:            return true;
 202          case FEATURE_MOD_PURPOSE:             return MOD_PURPOSE_CONTENT;
 203  
 204          default: return null;
 205      }
 206  }
 207  
 208  /**
 209   * Register the ability to handle drag and drop file uploads
 210   * @return array containing details of the files / types the mod can handle
 211   */
 212  function label_dndupload_register() {
 213      $strdnd = get_string('dnduploadlabel', 'mod_label');
 214      if (get_config('label', 'dndmedia')) {
 215          $mediaextensions = file_get_typegroup('extension', ['web_image', 'web_video', 'web_audio']);
 216          $files = array();
 217          foreach ($mediaextensions as $extn) {
 218              $extn = trim($extn, '.');
 219              $files[] = array('extension' => $extn, 'message' => $strdnd);
 220          }
 221          $ret = array('files' => $files);
 222      } else {
 223          $ret = array();
 224      }
 225  
 226      $strdndtext = get_string('dnduploadlabeltext', 'mod_label');
 227      return array_merge($ret, array('types' => array(
 228          array('identifier' => 'text/html', 'message' => $strdndtext, 'noname' => true),
 229          array('identifier' => 'text', 'message' => $strdndtext, 'noname' => true)
 230      )));
 231  }
 232  
 233  /**
 234   * Handle a file that has been uploaded
 235   * @param object $uploadinfo details of the file / content that has been uploaded
 236   * @return int instance id of the newly created mod
 237   */
 238  function label_dndupload_handle($uploadinfo) {
 239      global $USER;
 240  
 241      // Gather the required info.
 242      $data = new stdClass();
 243      $data->course = $uploadinfo->course->id;
 244      $data->name = $uploadinfo->displayname;
 245      $data->intro = '';
 246      $data->introformat = FORMAT_HTML;
 247      $data->coursemodule = $uploadinfo->coursemodule;
 248  
 249      // Extract the first (and only) file from the file area and add it to the label as an img tag.
 250      if (!empty($uploadinfo->draftitemid)) {
 251          $fs = get_file_storage();
 252          $draftcontext = context_user::instance($USER->id);
 253          $context = context_module::instance($uploadinfo->coursemodule);
 254          $files = $fs->get_area_files($draftcontext->id, 'user', 'draft', $uploadinfo->draftitemid, '', false);
 255          if ($file = reset($files)) {
 256              if (file_mimetype_in_typegroup($file->get_mimetype(), 'web_image')) {
 257                  // It is an image - resize it, if too big, then insert the img tag.
 258                  $config = get_config('label');
 259                  $data->intro = label_generate_resized_image($file, $config->dndresizewidth, $config->dndresizeheight);
 260              } else {
 261                  // We aren't supposed to be supporting non-image types here, but fallback to adding a link, just in case.
 262                  $url = moodle_url::make_draftfile_url($file->get_itemid(), $file->get_filepath(), $file->get_filename());
 263                  $data->intro = html_writer::link($url, $file->get_filename());
 264              }
 265              $data->intro = file_save_draft_area_files($uploadinfo->draftitemid, $context->id, 'mod_label', 'intro', 0,
 266                                                        null, $data->intro);
 267          }
 268      } else if (!empty($uploadinfo->content)) {
 269          $data->intro = $uploadinfo->content;
 270          if ($uploadinfo->type != 'text/html') {
 271              $data->introformat = FORMAT_PLAIN;
 272          }
 273      }
 274  
 275      return label_add_instance($data, null);
 276  }
 277  
 278  /**
 279   * Resize the image, if required, then generate an img tag and, if required, a link to the full-size image
 280   * @param stored_file $file the image file to process
 281   * @param int $maxwidth the maximum width allowed for the image
 282   * @param int $maxheight the maximum height allowed for the image
 283   * @return string HTML fragment to add to the label
 284   */
 285  function label_generate_resized_image(stored_file $file, $maxwidth, $maxheight) {
 286      global $CFG;
 287  
 288      $fullurl = moodle_url::make_draftfile_url($file->get_itemid(), $file->get_filepath(), $file->get_filename());
 289      $link = null;
 290      $attrib = array('alt' => $file->get_filename(), 'src' => $fullurl);
 291  
 292      if ($imginfo = $file->get_imageinfo()) {
 293          // Work out the new width / height, bounded by maxwidth / maxheight
 294          $width = $imginfo['width'];
 295          $height = $imginfo['height'];
 296          if (!empty($maxwidth) && $width > $maxwidth) {
 297              $height *= (float)$maxwidth / $width;
 298              $width = $maxwidth;
 299          }
 300          if (!empty($maxheight) && $height > $maxheight) {
 301              $width *= (float)$maxheight / $height;
 302              $height = $maxheight;
 303          }
 304  
 305          $attrib['width'] = $width;
 306          $attrib['height'] = $height;
 307  
 308          // If the size has changed and the image is of a suitable mime type, generate a smaller version
 309          if ($width != $imginfo['width']) {
 310              $mimetype = $file->get_mimetype();
 311              if ($mimetype === 'image/gif' or $mimetype === 'image/jpeg' or $mimetype === 'image/png') {
 312                  require_once($CFG->libdir.'/gdlib.php');
 313                  $data = $file->generate_image_thumbnail($width, $height);
 314  
 315                  if (!empty($data)) {
 316                      $fs = get_file_storage();
 317                      $record = array(
 318                          'contextid' => $file->get_contextid(),
 319                          'component' => $file->get_component(),
 320                          'filearea'  => $file->get_filearea(),
 321                          'itemid'    => $file->get_itemid(),
 322                          'filepath'  => '/',
 323                          'filename'  => 's_'.$file->get_filename(),
 324                      );
 325                      $smallfile = $fs->create_file_from_string($record, $data);
 326  
 327                      // Replace the image 'src' with the resized file and link to the original
 328                      $attrib['src'] = moodle_url::make_draftfile_url($smallfile->get_itemid(), $smallfile->get_filepath(),
 329                                                                      $smallfile->get_filename());
 330                      $link = $fullurl;
 331                  }
 332              }
 333          }
 334  
 335      } else {
 336          // Assume this is an image type that get_imageinfo cannot handle (e.g. SVG)
 337          $attrib['width'] = $maxwidth;
 338      }
 339  
 340      $attrib['class'] = "img-fluid";
 341      $img = html_writer::empty_tag('img', $attrib);
 342      if ($link) {
 343          return html_writer::link($link, $img);
 344      } else {
 345          return $img;
 346      }
 347  }
 348  
 349  /**
 350   * Check if the module has any update that affects the current user since a given time.
 351   *
 352   * @param  cm_info $cm course module data
 353   * @param  int $from the time to check updates from
 354   * @param  array $filter  if we need to check only specific updates
 355   * @return stdClass an object with the different type of areas indicating if they were updated or not
 356   * @since Moodle 3.2
 357   */
 358  function label_check_updates_since(cm_info $cm, $from, $filter = array()) {
 359      $updates = course_check_module_updates_since($cm, $from, array(), $filter);
 360      return $updates;
 361  }
 362  
 363  /**
 364   * This function receives a calendar event and returns the action associated with it, or null if there is none.
 365   *
 366   * This is used by block_myoverview in order to display the event appropriately. If null is returned then the event
 367   * is not displayed on the block.
 368   *
 369   * @param calendar_event $event
 370   * @param \core_calendar\action_factory $factory
 371   * @param int $userid User id to use for all capability checks, etc. Set to 0 for current user (default).
 372   * @return \core_calendar\local\event\entities\action_interface|null
 373   */
 374  function mod_label_core_calendar_provide_event_action(calendar_event $event,
 375                                                        \core_calendar\action_factory $factory,
 376                                                        int $userid = 0) {
 377      $cm = get_fast_modinfo($event->courseid, $userid)->instances['label'][$event->instance];
 378  
 379      if (!$cm->uservisible) {
 380          // The module is not visible to the user for any reason.
 381          return null;
 382      }
 383  
 384      $completion = new \completion_info($cm->get_course());
 385  
 386      $completiondata = $completion->get_data($cm, false, $userid);
 387  
 388      if ($completiondata->completionstate != COMPLETION_INCOMPLETE) {
 389          return null;
 390      }
 391  
 392      return $factory->create_instance(
 393          get_string('view'),
 394          new \moodle_url('/mod/label/view.php', ['id' => $cm->id]),
 395          1,
 396          true
 397      );
 398  }