includes/filerepo/file/ForeignAPIFile.php

   1 <?php
   2 /**
   3  * Foreign file accessible through api.php requests.
   4  *
   5  * This program 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 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program 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 along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  * http://www.gnu.org/copyleft/gpl.html
  19  *
  20  * @file
  21  * @ingroup FileAbstraction
  22  */
  23
  24 /**
  25  * Foreign file accessible through api.php requests.
  26  * Very hacky and inefficient, do not use :D
  27  *
  28  * @ingroup FileAbstraction
  29  */
  30 class ForeignAPIFile extends File {
  31         private $mExists;
  32
  33         protected $repoClass = 'ForeignApiRepo';
  34
  35         /**
  36          * @param $title
  37          * @param $repo ForeignApiRepo
  38          * @param $info
  39          * @param bool $exists
  40          */
  41         function __construct( $title, $repo, $info, $exists = false ) {
  42                 parent::__construct( $title, $repo );
  43
  44                 $this->mInfo = $info;
  45                 $this->mExists = $exists;
  46
  47                 $this->assertRepoDefined();
  48         }
  49
  50         /**
  51          * @param $title Title
  52          * @param $repo ForeignApiRepo
  53          * @return ForeignAPIFile|null
  54          */
  55         static function newFromTitle( Title $title, $repo ) {
  56                 $data = $repo->fetchImageQuery( array(
  57                         'titles' => 'File:' . $title->getDBkey(),
  58                         'iiprop' => self::getProps(),
  59                         'prop' => 'imageinfo',
  60                         'iimetadataversion' => MediaHandler::getMetadataVersion()
  61                 ) );
  62
  63                 $info = $repo->getImageInfo( $data );
  64
  65                 if ( $info ) {
  66                         $lastRedirect = isset( $data['query']['redirects'] )
  67                                 ? count( $data['query']['redirects'] ) - 1
  68                                 : -1;
  69                         if ( $lastRedirect >= 0 ) {
  70                                 $newtitle = Title::newFromText( $data['query']['redirects'][$lastRedirect]['to'] );
  71                                 $img = new self( $newtitle, $repo, $info, true );
  72                                 if ( $img ) {
  73                                         $img->redirectedFrom( $title->getDBkey() );
  74                                 }
  75                         } else {
  76                                 $img = new self( $title, $repo, $info, true );
  77                         }
  78                         return $img;
  79                 } else {
  80                         return null;
  81                 }
  82         }
  83
  84         /**
  85          * Get the property string for iiprop and aiprop
  86          * @return string
  87          */
  88         static function getProps() {
  89                 return 'timestamp|user|comment|url|size|sha1|metadata|mime';
  90         }
  91
  92         // Dummy functions...
  93
  94         /**
  95          * @return bool
  96          */
  97         public function exists() {
  98                 return $this->mExists;
  99         }
 100
 101         /**
 102          * @return bool
 103          */
 104         public function getPath() {
 105                 return false;
 106         }
 107
 108         /**
 109          * @param array $params
 110          * @param int $flags
 111          * @return bool|MediaTransformOutput
 112          */
 113         function transform( $params, $flags = 0 ) {
 114                 if ( !$this->canRender() ) {
 115                         // show icon
 116                         return parent::transform( $params, $flags );
 117                 }
 118
 119                 // Note, the this->canRender() check above implies
 120                 // that we have a handler, and it can do makeParamString.
 121                 $otherParams = $this->handler->makeParamString( $params );
 122
 123                 $thumbUrl = $this->repo->getThumbUrlFromCache(
 124                         $this->getName(),
 125                         isset( $params['width'] ) ? $params['width'] : -1,
 126                         isset( $params['height'] ) ? $params['height'] : -1,
 127                         $otherParams );
 128                 return $this->handler->getTransform( $this, 'bogus', $thumbUrl, $params );
 129         }
 130
 131         // Info we can get from API...
 132
 133         /**
 134          * @param $page int
 135          * @return int|number
 136          */
 137         public function getWidth( $page = 1 ) {
 138                 return isset( $this->mInfo['width'] ) ? intval( $this->mInfo['width'] ) : 0;
 139         }
 140
 141         /**
 142          * @param $page int
 143          * @return int
 144          */
 145         public function getHeight( $page = 1 ) {
 146                 return isset( $this->mInfo['height'] ) ? intval( $this->mInfo['height'] ) : 0;
 147         }
 148
 149         /**
 150          * @return bool|null|string
 151          */
 152         public function getMetadata() {
 153                 if ( isset( $this->mInfo['metadata'] ) ) {
 154                         return serialize( self::parseMetadata( $this->mInfo['metadata'] ) );
 155                 }
 156                 return null;
 157         }
 158
 159         /**
 160          * @param $metadata array
 161          * @return array
 162          */
 163         public static function parseMetadata( $metadata ) {
 164                 if ( !is_array( $metadata ) ) {
 165                         return $metadata;
 166                 }
 167                 $ret = array();
 168                 foreach ( $metadata as $meta ) {
 169                         $ret[$meta['name']] = self::parseMetadata( $meta['value'] );
 170                 }
 171                 return $ret;
 172         }
 173
 174         /**
 175          * @return bool|int|null
 176          */
 177         public function getSize() {
 178                 return isset( $this->mInfo['size'] ) ? intval( $this->mInfo['size'] ) : null;
 179         }
 180
 181         /**
 182          * @return null|string
 183          */
 184         public function getUrl() {
 185                 return isset( $this->mInfo['url'] ) ? strval( $this->mInfo['url'] ) : null;
 186         }
 187
 188         /**
 189          * @param string $method
 190          * @return int|null|string
 191          */
 192         public function getUser( $method = 'text' ) {
 193                 return isset( $this->mInfo['user'] ) ? strval( $this->mInfo['user'] ) : null;
 194         }
 195
 196         /**
 197          * @return null|string
 198          */
 199         public function getDescription( $audience = self::FOR_PUBLIC, User $user = null ) {
 200                 return isset( $this->mInfo['comment'] ) ? strval( $this->mInfo['comment'] ) : null;
 201         }
 202
 203         /**
 204          * @return null|String
 205          */
 206         function getSha1() {
 207                 return isset( $this->mInfo['sha1'] )
 208                         ? wfBaseConvert( strval( $this->mInfo['sha1'] ), 16, 36, 31 )
 209                         : null;
 210         }
 211
 212         /**
 213          * @return bool|Mixed|string
 214          */
 215         function getTimestamp() {
 216                 return wfTimestamp( TS_MW,
 217                         isset( $this->mInfo['timestamp'] )
 218                                 ? strval( $this->mInfo['timestamp'] )
 219                                 : null
 220                 );
 221         }
 222
 223         /**
 224          * @return string
 225          */
 226         function getMimeType() {
 227                 if ( !isset( $this->mInfo['mime'] ) ) {
 228                         $magic = MimeMagic::singleton();
 229                         $this->mInfo['mime'] = $magic->guessTypesForExtension( $this->getExtension() );
 230                 }
 231                 return $this->mInfo['mime'];
 232         }
 233
 234         /**
 235          * @todo FIXME: May guess wrong on file types that can be eg audio or video
 236          * @return int|string
 237          */
 238         function getMediaType() {
 239                 $magic = MimeMagic::singleton();
 240                 return $magic->getMediaType( null, $this->getMimeType() );
 241         }
 242
 243         /**
 244          * @return bool|string
 245          */
 246         function getDescriptionUrl() {
 247                 return isset( $this->mInfo['descriptionurl'] )
 248                         ? $this->mInfo['descriptionurl']
 249                         : false;
 250         }
 251
 252         /**
 253          * Only useful if we're locally caching thumbs anyway...
 254          * @param $suffix string
 255          * @return null|string
 256          */
 257         function getThumbPath( $suffix = '' ) {
 258                 if ( $this->repo->canCacheThumbs() ) {
 259                         $path = $this->repo->getZonePath( 'thumb' ) . '/' . $this->getHashPath( $this->getName() );
 260                         if ( $suffix ) {
 261                                 $path = $path . $suffix . '/';
 262                         }
 263                         return $path;
 264                 } else {
 265                         return null;
 266                 }
 267         }
 268
 269         /**
 270          * @return array
 271          */
 272         function getThumbnails() {
 273                 $dir = $this->getThumbPath( $this->getName() );
 274                 $iter = $this->repo->getBackend()->getFileList( array( 'dir' => $dir ) );
 275
 276                 $files = array();
 277                 foreach ( $iter as $file ) {
 278                         $files[] = $file;
 279                 }
 280
 281                 return $files;
 282         }
 283
 284         /**
 285          * @see File::purgeCache()
 286          */
 287         function purgeCache( $options = array() ) {
 288                 $this->purgeThumbnails( $options );
 289                 $this->purgeDescriptionPage();
 290         }
 291
 292         function purgeDescriptionPage() {
 293                 global $wgMemc, $wgContLang;
 294
 295                 $url = $this->repo->getDescriptionRenderUrl( $this->getName(), $wgContLang->getCode() );
 296                 $key = $this->repo->getLocalCacheKey( 'RemoteFileDescription', 'url', md5( $url ) );
 297
 298                 $wgMemc->delete( $key );
 299         }
 300
 301         /**
 302          * @param $options array
 303          */
 304         function purgeThumbnails( $options = array() ) {
 305                 global $wgMemc;
 306
 307                 $key = $this->repo->getLocalCacheKey( 'ForeignAPIRepo', 'ThumbUrl', $this->getName() );
 308                 $wgMemc->delete( $key );
 309
 310                 $files = $this->getThumbnails();
 311                 // Give media handler a chance to filter the purge list
 312                 $handler = $this->getHandler();
 313                 if ( $handler ) {
 314                         $handler->filterThumbnailPurgeList( $files, $options );
 315                 }
 316
 317                 $dir = $this->getThumbPath( $this->getName() );
 318                 $purgeList = array();
 319                 foreach ( $files as $file ) {
 320                         $purgeList[] = "{$dir}{$file}";
 321                 }
 322
 323                 # Delete the thumbnails
 324                 $this->repo->quickPurgeBatch( $purgeList );
 325                 # Clear out the thumbnail directory if empty
 326                 $this->repo->quickCleanDir( $dir );
 327         }
 328 }