[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3   * Deleted file in the 'filearchive' table.
   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   * Class representing a row of the 'filearchive' table
  26   *
  27   * @ingroup FileAbstraction
  28   */
  29  class ArchivedFile {
  30      /** @var int Filearchive row ID */
  31      private $id;
  32  
  33      /** @var string File name */
  34      private $name;
  35  
  36      /** @var string FileStore storage group */
  37      private $group;
  38  
  39      /** @var string FileStore SHA-1 key */
  40      private $key;
  41  
  42      /** @var int File size in bytes */
  43      private $size;
  44  
  45      /** @var int Size in bytes */
  46      private $bits;
  47  
  48      /** @var int Width */
  49      private $width;
  50  
  51      /** @var int Height */
  52      private $height;
  53  
  54      /** @var string Metadata string */
  55      private $metadata;
  56  
  57      /** @var string MIME type */
  58      private $mime;
  59  
  60      /** @var string Media type */
  61      private $media_type;
  62  
  63      /** @var string Upload description */
  64      private $description;
  65  
  66      /** @var int User ID of uploader */
  67      private $user;
  68  
  69      /** @var string User name of uploader */
  70      private $user_text;
  71  
  72      /** @var string Time of upload */
  73      private $timestamp;
  74  
  75      /** @var bool Whether or not all this has been loaded from the database (loadFromXxx) */
  76      private $dataLoaded;
  77  
  78      /** @var int Bitfield akin to rev_deleted */
  79      private $deleted;
  80  
  81      /** @var string SHA-1 hash of file content */
  82      private $sha1;
  83  
  84      /** @var string Number of pages of a multipage document, or false for
  85       * documents which aren't multipage documents
  86       */
  87      private $pageCount;
  88  
  89      /** @var string Original base filename */
  90      private $archive_name;
  91  
  92      /** @var MediaHandler */
  93      protected $handler;
  94  
  95      /** @var Title */
  96      protected $title; # image title
  97  
  98      /**
  99       * @throws MWException
 100       * @param Title $title
 101       * @param int $id
 102       * @param string $key
 103       */
 104  	function __construct( $title, $id = 0, $key = '' ) {
 105          $this->id = -1;
 106          $this->title = false;
 107          $this->name = false;
 108          $this->group = 'deleted'; // needed for direct use of constructor
 109          $this->key = '';
 110          $this->size = 0;
 111          $this->bits = 0;
 112          $this->width = 0;
 113          $this->height = 0;
 114          $this->metadata = '';
 115          $this->mime = "unknown/unknown";
 116          $this->media_type = '';
 117          $this->description = '';
 118          $this->user = 0;
 119          $this->user_text = '';
 120          $this->timestamp = null;
 121          $this->deleted = 0;
 122          $this->dataLoaded = false;
 123          $this->exists = false;
 124          $this->sha1 = '';
 125  
 126          if ( $title instanceof Title ) {
 127              $this->title = File::normalizeTitle( $title, 'exception' );
 128              $this->name = $title->getDBkey();
 129          }
 130  
 131          if ( $id ) {
 132              $this->id = $id;
 133          }
 134  
 135          if ( $key ) {
 136              $this->key = $key;
 137          }
 138  
 139          if ( !$id && !$key && !( $title instanceof Title ) ) {
 140              throw new MWException( "No specifications provided to ArchivedFile constructor." );
 141          }
 142      }
 143  
 144      /**
 145       * Loads a file object from the filearchive table
 146       * @throws MWException
 147       * @return bool|null True on success or null
 148       */
 149  	public function load() {
 150          if ( $this->dataLoaded ) {
 151              return true;
 152          }
 153          $conds = array();
 154  
 155          if ( $this->id > 0 ) {
 156              $conds['fa_id'] = $this->id;
 157          }
 158          if ( $this->key ) {
 159              $conds['fa_storage_group'] = $this->group;
 160              $conds['fa_storage_key'] = $this->key;
 161          }
 162          if ( $this->title ) {
 163              $conds['fa_name'] = $this->title->getDBkey();
 164          }
 165  
 166          if ( !count( $conds ) ) {
 167              throw new MWException( "No specific information for retrieving archived file" );
 168          }
 169  
 170          if ( !$this->title || $this->title->getNamespace() == NS_FILE ) {
 171              $this->dataLoaded = true; // set it here, to have also true on miss
 172              $dbr = wfGetDB( DB_SLAVE );
 173              $row = $dbr->selectRow(
 174                  'filearchive',
 175                  self::selectFields(),
 176                  $conds,
 177                  __METHOD__,
 178                  array( 'ORDER BY' => 'fa_timestamp DESC' )
 179              );
 180              if ( !$row ) {
 181                  // this revision does not exist?
 182                  return null;
 183              }
 184  
 185              // initialize fields for filestore image object
 186              $this->loadFromRow( $row );
 187          } else {
 188              throw new MWException( 'This title does not correspond to an image page.' );
 189          }
 190          $this->exists = true;
 191  
 192          return true;
 193      }
 194  
 195      /**
 196       * Loads a file object from the filearchive table
 197       *
 198       * @param stdClass $row
 199       * @return ArchivedFile
 200       */
 201  	public static function newFromRow( $row ) {
 202          $file = new ArchivedFile( Title::makeTitle( NS_FILE, $row->fa_name ) );
 203          $file->loadFromRow( $row );
 204  
 205          return $file;
 206      }
 207  
 208      /**
 209       * Fields in the filearchive table
 210       * @return array
 211       */
 212  	static function selectFields() {
 213          return array(
 214              'fa_id',
 215              'fa_name',
 216              'fa_archive_name',
 217              'fa_storage_key',
 218              'fa_storage_group',
 219              'fa_size',
 220              'fa_bits',
 221              'fa_width',
 222              'fa_height',
 223              'fa_metadata',
 224              'fa_media_type',
 225              'fa_major_mime',
 226              'fa_minor_mime',
 227              'fa_description',
 228              'fa_user',
 229              'fa_user_text',
 230              'fa_timestamp',
 231              'fa_deleted',
 232              'fa_deleted_timestamp', /* Used by LocalFileRestoreBatch */
 233              'fa_sha1',
 234          );
 235      }
 236  
 237      /**
 238       * Load ArchivedFile object fields from a DB row.
 239       *
 240       * @param stdClass $row Object database row
 241       * @since 1.21
 242       */
 243  	public function loadFromRow( $row ) {
 244          $this->id = intval( $row->fa_id );
 245          $this->name = $row->fa_name;
 246          $this->archive_name = $row->fa_archive_name;
 247          $this->group = $row->fa_storage_group;
 248          $this->key = $row->fa_storage_key;
 249          $this->size = $row->fa_size;
 250          $this->bits = $row->fa_bits;
 251          $this->width = $row->fa_width;
 252          $this->height = $row->fa_height;
 253          $this->metadata = $row->fa_metadata;
 254          $this->mime = "$row->fa_major_mime/$row->fa_minor_mime";
 255          $this->media_type = $row->fa_media_type;
 256          $this->description = $row->fa_description;
 257          $this->user = $row->fa_user;
 258          $this->user_text = $row->fa_user_text;
 259          $this->timestamp = $row->fa_timestamp;
 260          $this->deleted = $row->fa_deleted;
 261          if ( isset( $row->fa_sha1 ) ) {
 262              $this->sha1 = $row->fa_sha1;
 263          } else {
 264              // old row, populate from key
 265              $this->sha1 = LocalRepo::getHashFromKey( $this->key );
 266          }
 267          if ( !$this->title ) {
 268              $this->title = Title::makeTitleSafe( NS_FILE, $row->fa_name );
 269          }
 270      }
 271  
 272      /**
 273       * Return the associated title object
 274       *
 275       * @return Title
 276       */
 277  	public function getTitle() {
 278          if ( !$this->title ) {
 279              $this->load();
 280          }
 281          return $this->title;
 282      }
 283  
 284      /**
 285       * Return the file name
 286       *
 287       * @return string
 288       */
 289  	public function getName() {
 290          if ( $this->name === false ) {
 291              $this->load();
 292          }
 293  
 294          return $this->name;
 295      }
 296  
 297      /**
 298       * @return int
 299       */
 300  	public function getID() {
 301          $this->load();
 302  
 303          return $this->id;
 304      }
 305  
 306      /**
 307       * @return bool
 308       */
 309  	public function exists() {
 310          $this->load();
 311  
 312          return $this->exists;
 313      }
 314  
 315      /**
 316       * Return the FileStore key
 317       * @return string
 318       */
 319  	public function getKey() {
 320          $this->load();
 321  
 322          return $this->key;
 323      }
 324  
 325      /**
 326       * Return the FileStore key (overriding base File class)
 327       * @return string
 328       */
 329  	public function getStorageKey() {
 330          return $this->getKey();
 331      }
 332  
 333      /**
 334       * Return the FileStore storage group
 335       * @return string
 336       */
 337  	public function getGroup() {
 338          return $this->group;
 339      }
 340  
 341      /**
 342       * Return the width of the image
 343       * @return int
 344       */
 345  	public function getWidth() {
 346          $this->load();
 347  
 348          return $this->width;
 349      }
 350  
 351      /**
 352       * Return the height of the image
 353       * @return int
 354       */
 355  	public function getHeight() {
 356          $this->load();
 357  
 358          return $this->height;
 359      }
 360  
 361      /**
 362       * Get handler-specific metadata
 363       * @return string
 364       */
 365  	public function getMetadata() {
 366          $this->load();
 367  
 368          return $this->metadata;
 369      }
 370  
 371      /**
 372       * Return the size of the image file, in bytes
 373       * @return int
 374       */
 375  	public function getSize() {
 376          $this->load();
 377  
 378          return $this->size;
 379      }
 380  
 381      /**
 382       * Return the bits of the image file, in bytes
 383       * @return int
 384       */
 385  	public function getBits() {
 386          $this->load();
 387  
 388          return $this->bits;
 389      }
 390  
 391      /**
 392       * Returns the MIME type of the file.
 393       * @return string
 394       */
 395  	public function getMimeType() {
 396          $this->load();
 397  
 398          return $this->mime;
 399      }
 400  
 401      /**
 402       * Get a MediaHandler instance for this file
 403       * @return MediaHandler
 404       */
 405  	function getHandler() {
 406          if ( !isset( $this->handler ) ) {
 407              $this->handler = MediaHandler::getHandler( $this->getMimeType() );
 408          }
 409  
 410          return $this->handler;
 411      }
 412  
 413      /**
 414       * Returns the number of pages of a multipage document, or false for
 415       * documents which aren't multipage documents
 416       * @return bool|int
 417       */
 418  	function pageCount() {
 419          if ( !isset( $this->pageCount ) ) {
 420              if ( $this->getHandler() && $this->handler->isMultiPage( $this ) ) {
 421                  $this->pageCount = $this->handler->pageCount( $this );
 422              } else {
 423                  $this->pageCount = false;
 424              }
 425          }
 426  
 427          return $this->pageCount;
 428      }
 429  
 430      /**
 431       * Return the type of the media in the file.
 432       * Use the value returned by this function with the MEDIATYPE_xxx constants.
 433       * @return string
 434       */
 435  	public function getMediaType() {
 436          $this->load();
 437  
 438          return $this->media_type;
 439      }
 440  
 441      /**
 442       * Return upload timestamp.
 443       *
 444       * @return string
 445       */
 446  	public function getTimestamp() {
 447          $this->load();
 448  
 449          return wfTimestamp( TS_MW, $this->timestamp );
 450      }
 451  
 452      /**
 453       * Get the SHA-1 base 36 hash of the file
 454       *
 455       * @return string
 456       * @since 1.21
 457       */
 458  	function getSha1() {
 459          $this->load();
 460  
 461          return $this->sha1;
 462      }
 463  
 464      /**
 465       * Returns ID or name of user who uploaded the file
 466       *
 467       * @note Prior to MediaWiki 1.23, this method always
 468       *   returned the user id, and was inconsistent with
 469       *   the rest of the file classes.
 470       * @param string $type 'text' or 'id'
 471       * @return int|string
 472       * @throws MWException
 473       */
 474  	public function getUser( $type = 'text' ) {
 475          $this->load();
 476  
 477          if ( $type == 'text' ) {
 478              return $this->user_text;
 479          } elseif ( $type == 'id' ) {
 480              return $this->user;
 481          }
 482  
 483          throw new MWException( "Unknown type '$type'." );
 484      }
 485  
 486      /**
 487       * Return the user name of the uploader.
 488       *
 489       * @deprecated since 1.23 Use getUser( 'text' ) instead.
 490       * @return string
 491       */
 492  	public function getUserText() {
 493          wfDeprecated( __METHOD__, '1.23' );
 494          $this->load();
 495          if ( $this->isDeleted( File::DELETED_USER ) ) {
 496              return 0;
 497          } else {
 498              return $this->user_text;
 499          }
 500      }
 501  
 502      /**
 503       * Return upload description.
 504       *
 505       * @return string
 506       */
 507  	public function getDescription() {
 508          $this->load();
 509          if ( $this->isDeleted( File::DELETED_COMMENT ) ) {
 510              return 0;
 511          } else {
 512              return $this->description;
 513          }
 514      }
 515  
 516      /**
 517       * Return the user ID of the uploader.
 518       *
 519       * @return int
 520       */
 521  	public function getRawUser() {
 522          $this->load();
 523  
 524          return $this->user;
 525      }
 526  
 527      /**
 528       * Return the user name of the uploader.
 529       *
 530       * @return string
 531       */
 532  	public function getRawUserText() {
 533          $this->load();
 534  
 535          return $this->user_text;
 536      }
 537  
 538      /**
 539       * Return upload description.
 540       *
 541       * @return string
 542       */
 543  	public function getRawDescription() {
 544          $this->load();
 545  
 546          return $this->description;
 547      }
 548  
 549      /**
 550       * Returns the deletion bitfield
 551       * @return int
 552       */
 553  	public function getVisibility() {
 554          $this->load();
 555  
 556          return $this->deleted;
 557      }
 558  
 559      /**
 560       * for file or revision rows
 561       *
 562       * @param int $field One of DELETED_* bitfield constants
 563       * @return bool
 564       */
 565  	public function isDeleted( $field ) {
 566          $this->load();
 567  
 568          return ( $this->deleted & $field ) == $field;
 569      }
 570  
 571      /**
 572       * Determine if the current user is allowed to view a particular
 573       * field of this FileStore image file, if it's marked as deleted.
 574       * @param int $field
 575       * @param null|User $user User object to check, or null to use $wgUser
 576       * @return bool
 577       */
 578  	public function userCan( $field, User $user = null ) {
 579          $this->load();
 580  
 581          $title = $this->getTitle();
 582          return Revision::userCanBitfield( $this->deleted, $field, $user, $title ? : null );
 583      }
 584  }