[Summary view] [Print] [Text view]

   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   * Tag youtube block
  19   *
  20   * @package    block_tag_youtube
  21   * @copyright  1999 onwards Martin Dougiamas (http://dougiamas.com)
  22   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23   */
  24  
  25  define('DEFAULT_NUMBER_OF_VIDEOS', 5);
  26  
  27  class block_tag_youtube extends block_base {
  28  
  29      /**
  30       * @var Google_Service_Youtube
  31       */
  32      protected $service = null;
  33  
  34      function init() {
  35          $this->title = get_string('pluginname','block_tag_youtube');
  36          $this->config = new stdClass();
  37      }
  38  
  39      function applicable_formats() {
  40          return array('tag' => true);
  41      }
  42  
  43      /**
  44       * It can be configured.
  45       *
  46       * @return bool
  47       */
  48      public function has_config() {
  49          return true;
  50      }
  51  
  52      function specialization() {
  53          $this->title = !empty($this->config->title) ? $this->config->title : get_string('pluginname', 'block_tag_youtube');
  54          // Convert numeric categories (old YouTube API) to
  55          // textual ones (new Google Data API)
  56          $this->config->category = !empty($this->config->category) ? $this->category_map_old2new($this->config->category) : '0';
  57      }
  58  
  59      function instance_allow_multiple() {
  60          return true;
  61      }
  62  
  63      function get_content() {
  64          global $CFG;
  65  
  66          //note: do NOT include files at the top of this file
  67          require_once($CFG->libdir . '/filelib.php');
  68  
  69          if ($this->content !== NULL) {
  70              return $this->content;
  71          }
  72  
  73          $this->content = new stdClass();
  74          $this->content->footer = '';
  75  
  76          if (!$this->get_service()) {
  77              $this->content->text = $this->get_error_message();
  78              return $this->content;
  79          }
  80  
  81          $text = '';
  82          if(!empty($this->config->playlist)){
  83              //videos from a playlist
  84              $text = $this->get_videos_by_playlist();
  85          }
  86          else{
  87              if(!empty($this->config->category)){
  88                  //videos from category with tag
  89                  $text = $this->get_videos_by_tag_and_category();
  90              }
  91              else {
  92                  //videos with tag
  93                  $text = $this->get_videos_by_tag();
  94              }
  95          }
  96  
  97          $this->content->text = $text;
  98  
  99          return $this->content;
 100      }
 101  
 102      function get_videos_by_playlist(){
 103  
 104          if (!$service = $this->get_service()) {
 105              return $this->get_error_message();
 106          }
 107  
 108          $numberofvideos = DEFAULT_NUMBER_OF_VIDEOS;
 109          if( !empty($this->config->numberofvideos)) {
 110              $numberofvideos = $this->config->numberofvideos;
 111          }
 112  
 113          try {
 114              $response = $service->playlistItems->listPlaylistItems('id,snippet', array(
 115                  'playlistId' => $this->config->playlist,
 116                  'maxResults' => $numberofvideos
 117              ));
 118          } catch (Google_Service_Exception $e) {
 119              debugging('Google service exception: ' . $e->getMessage(), DEBUG_DEVELOPER);
 120              return $this->get_error_message(get_string('requesterror', 'block_tag_youtube'));
 121          }
 122  
 123          return $this->render_items($response);
 124      }
 125  
 126      function get_videos_by_tag(){
 127  
 128          if (!$service = $this->get_service()) {
 129              return $this->get_error_message();
 130          }
 131  
 132          $tagid = optional_param('id', 0, PARAM_INT);   // tag id - for backware compatibility
 133          $tag = optional_param('tag', '', PARAM_TAG); // tag
 134          $tc = optional_param('tc', 0, PARAM_INT); // Tag collection id.
 135  
 136          if ($tagid) {
 137              $tagobject = core_tag_tag::get($tagid);
 138          } else if ($tag) {
 139              $tagobject = core_tag_tag::get_by_name($tc, $tag);
 140          }
 141  
 142          if (empty($tagobject)) {
 143              return '';
 144          }
 145  
 146          $querytag = urlencode($tagobject->name);
 147  
 148          $numberofvideos = DEFAULT_NUMBER_OF_VIDEOS;
 149          if ( !empty($this->config->numberofvideos) ) {
 150              $numberofvideos = $this->config->numberofvideos;
 151          }
 152  
 153          try {
 154              $response = $service->search->listSearch('id,snippet', array(
 155                  'q' => $querytag,
 156                  'type' => 'video',
 157                  'maxResults' => $numberofvideos
 158              ));
 159          } catch (Google_Service_Exception $e) {
 160              debugging('Google service exception: ' . $e->getMessage(), DEBUG_DEVELOPER);
 161              return $this->get_error_message(get_string('requesterror', 'block_tag_youtube'));
 162          }
 163  
 164          return $this->render_items($response);
 165      }
 166  
 167      function get_videos_by_tag_and_category(){
 168  
 169          if (!$service = $this->get_service()) {
 170              return $this->get_error_message();
 171          }
 172  
 173          $tagid = optional_param('id', 0, PARAM_INT);   // tag id - for backware compatibility
 174          $tag = optional_param('tag', '', PARAM_TAG); // tag
 175          $tc = optional_param('tc', 0, PARAM_INT); // Tag collection id.
 176  
 177          if ($tagid) {
 178              $tagobject = core_tag_tag::get($tagid);
 179          } else if ($tag) {
 180              $tagobject = core_tag_tag::get_by_name($tc, $tag);
 181          }
 182  
 183          if (empty($tagobject)) {
 184              return '';
 185          }
 186  
 187          $querytag = urlencode($tagobject->name);
 188  
 189          $numberofvideos = DEFAULT_NUMBER_OF_VIDEOS;
 190          if( !empty($this->config->numberofvideos)) {
 191              $numberofvideos = $this->config->numberofvideos;
 192          }
 193  
 194          try {
 195              $response = $service->search->listSearch('id,snippet', array(
 196                  'q' => $querytag,
 197                  'type' => 'video',
 198                  'maxResults' => $numberofvideos,
 199                  'videoCategoryId' => $this->config->category
 200              ));
 201          } catch (Google_Service_Exception $e) {
 202              debugging('Google service exception: ' . $e->getMessage(), DEBUG_DEVELOPER);
 203              return $this->get_error_message(get_string('requesterror', 'block_tag_youtube'));
 204          }
 205  
 206          return $this->render_items($response);
 207      }
 208  
 209      /**
 210       * Sends a request to fetch data.
 211       *
 212       * @see block_tag_youtube::service
 213       * @deprecated since Moodle 2.8.8, 2.9.2 and 3.0 MDL-49085 - please do not use this function any more.
 214       * @param string $request
 215       * @throws coding_exception
 216       */
 217      public function fetch_request($request) {
 218          throw new coding_exception('Sorry, this function has been deprecated in Moodle 2.8.8, 2.9.2 and 3.0. Use block_tag_youtube::get_service instead.');
 219  
 220          $c = new curl(array('cache' => true, 'module_cache'=>'tag_youtube'));
 221          $c->setopt(array('CURLOPT_TIMEOUT' => 3, 'CURLOPT_CONNECTTIMEOUT' => 3));
 222  
 223          $response = $c->get($request);
 224  
 225          $xml = new SimpleXMLElement($response);
 226          return $this->render_video_list($xml);
 227      }
 228  
 229      /**
 230       * Renders the video list.
 231       *
 232       * @see block_tag_youtube::render_items
 233       * @deprecated since Moodle 2.8.8, 2.9.2 and 3.0 MDL-49085 - please do not use this function any more.
 234       * @param SimpleXMLElement $xml
 235       * @throws coding_exception
 236       */
 237      function render_video_list(SimpleXMLElement $xml){
 238          throw new coding_exception('Sorry, this function has been deprecated in Moodle 2.8.8, 2.9.2 and 3.0. Use block_tag_youtube::render_items instead.');
 239      }
 240  
 241      /**
 242       * Returns an error message.
 243       *
 244       * Useful when the block is not properly set or something goes wrong.
 245       *
 246       * @param string $message The message to display.
 247       * @return string HTML
 248       */
 249      protected function get_error_message($message = null) {
 250          global $OUTPUT;
 251  
 252          if (empty($message)) {
 253              $message = get_string('apierror', 'block_tag_youtube');
 254          }
 255          return $OUTPUT->notification($message);
 256      }
 257  
 258      /**
 259       * Gets the youtube service object.
 260       *
 261       * @return Google_Service_YouTube
 262       */
 263      protected function get_service() {
 264          global $CFG;
 265  
 266          if (!$apikey = get_config('block_tag_youtube', 'apikey')) {
 267              return false;
 268          }
 269  
 270          // Wrapped in an if in case we call different get_videos_* multiple times.
 271          if (!isset($this->service)) {
 272              require_once($CFG->libdir . '/google/lib.php');
 273              $client = get_google_client();
 274              $client->setDeveloperKey($apikey);
 275              $client->setScopes(array(Google_Service_YouTube::YOUTUBE_READONLY));
 276              $this->service = new Google_Service_YouTube($client);
 277          }
 278  
 279          return $this->service;
 280      }
 281  
 282      /**
 283       * Renders the list of items.
 284       *
 285       * @param array $videosdata
 286       * @return string HTML
 287       */
 288      protected function render_items($videosdata) {
 289  
 290          if (!$videosdata || empty($videosdata->items)) {
 291              if (!empty($videosdata->error)) {
 292                  debugging('Error fetching data from youtube: ' . $videosdata->error->message, DEBUG_DEVELOPER);
 293              }
 294              return '';
 295          }
 296  
 297          // If we reach that point we already know that the API key is set.
 298          $service = $this->get_service();
 299  
 300          $text = html_writer::start_tag('ul', array('class' => 'yt-video-entry unlist img-text'));
 301          foreach ($videosdata->items as $video) {
 302  
 303              // Link to the video included in the playlist if listing a playlist.
 304              if (!empty($video->snippet->resourceId)) {
 305                  $id = $video->snippet->resourceId->videoId;
 306                  $playlist = '&list=' . $video->snippet->playlistId;
 307              } else {
 308                  $id = $video->id->videoId;
 309                  $playlist = '';
 310              }
 311  
 312              $thumbnail = $video->snippet->getThumbnails()->getDefault();
 313              $url = 'http://www.youtube.com/watch?v=' . $id . $playlist;
 314  
 315              $videodetails = $service->videos->listVideos('id,contentDetails', array('id' => $id));
 316              if ($videodetails && !empty($videodetails->items)) {
 317  
 318                  // We fetch by id so we just use the first one.
 319                  $details = $videodetails->items[0];
 320                  $start = new DateTime('@0');
 321                  $start->add(new DateInterval($details->contentDetails->duration));
 322                  $seconds = $start->format('U');
 323              }
 324  
 325              $text .= html_writer::start_tag('li');
 326  
 327              $imgattrs = array('class' => 'youtube-thumb', 'src' => $thumbnail->url, 'alt' => $video->snippet->title);
 328              $thumbhtml = html_writer::empty_tag('img', $imgattrs);
 329              $link = html_writer::tag('a', $thumbhtml, array('href' => $url));
 330              $text .= html_writer::tag('div', $link, array('class' => 'clearfix'));
 331  
 332              $text .= html_writer::tag('span', html_writer::tag('a', $video->snippet->title, array('href' => $url)));
 333  
 334              if (!empty($seconds)) {
 335                  $text .= html_writer::tag('div', format_time($seconds));
 336              }
 337              $text .= html_writer::end_tag('li');
 338          }
 339          $text .= html_writer::end_tag('ul');
 340  
 341          return $text;
 342      }
 343  
 344      function get_categories() {
 345          // TODO: Right now using sticky categories from
 346          // http://gdata.youtube.com/schemas/2007/categories.cat
 347          // This should be performed from time to time by the block insead
 348          // and cached somewhere, avoiding deprecated ones and observing regions
 349          return array (
 350              '0' => get_string('anycategory', 'block_tag_youtube'),
 351              'Film'  => get_string('filmsanimation', 'block_tag_youtube'),
 352              'Autos' => get_string('autosvehicles', 'block_tag_youtube'),
 353              'Music' => get_string('music', 'block_tag_youtube'),
 354              'Animals'=> get_string('petsanimals', 'block_tag_youtube'),
 355              'Sports' => get_string('sports', 'block_tag_youtube'),
 356              'Travel' => get_string('travel', 'block_tag_youtube'),
 357              'Games'  => get_string('gadgetsgames', 'block_tag_youtube'),
 358              'Comedy' => get_string('comedy', 'block_tag_youtube'),
 359              'People' => get_string('peopleblogs', 'block_tag_youtube'),
 360              'News'   => get_string('newspolitics', 'block_tag_youtube'),
 361              'Entertainment' => get_string('entertainment', 'block_tag_youtube'),
 362              'Education' => get_string('education', 'block_tag_youtube'),
 363              'Howto'  => get_string('howtodiy', 'block_tag_youtube'),
 364              'Tech'   => get_string('scienceandtech', 'block_tag_youtube')
 365          );
 366      }
 367  
 368      /**
 369       * Provide conversion from old numeric categories available in youtube API
 370       * to the new ones available in the Google API
 371       *
 372       * @param int $oldcat old category code
 373       * @return mixed new category code or 0 (if no match found)
 374       *
 375       * TODO: Someday this should be applied on upgrade for all the existing
 376       * block instances so we won't need the mapping any more. That would imply
 377       * to implement restore handling to perform the conversion of old blocks.
 378       */
 379      function category_map_old2new($oldcat) {
 380          $oldoptions = array (
 381              0  => '0',
 382              1  => 'Film',
 383              2  => 'Autos',
 384              23 => 'Comedy',
 385              24 => 'Entertainment',
 386              10 => 'Music',
 387              25 => 'News',
 388              22 => 'People',
 389              15 => 'Animals',
 390              26 => 'Howto',
 391              17 => 'Sports',
 392              19 => 'Travel',
 393              20 => 'Games'
 394          );
 395          if (array_key_exists($oldcat, $oldoptions)) {
 396              return $oldoptions[$oldcat];
 397          } else {
 398              return $oldcat;
 399          }
 400      }
 401  }
 402