[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3   *
   4   *
   5   * Created on July 6, 2007
   6   *
   7   * Copyright © 2006 Yuri Astrakhan "<Firstname><Lastname>@gmail.com"
   8   *
   9   * This program is free software; you can redistribute it and/or modify
  10   * it under the terms of the GNU General Public License as published by
  11   * the Free Software Foundation; either version 2 of the License, or
  12   * (at your option) any later version.
  13   *
  14   * This program is distributed in the hope that it will be useful,
  15   * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17   * GNU General Public License for more details.
  18   *
  19   * You should have received a copy of the GNU General Public License along
  20   * with this program; if not, write to the Free Software Foundation, Inc.,
  21   * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  22   * http://www.gnu.org/copyleft/gpl.html
  23   *
  24   * @file
  25   */
  26  
  27  /**
  28   * A query action to get image information and upload history.
  29   *
  30   * @ingroup API
  31   */
  32  class ApiQueryImageInfo extends ApiQueryBase {
  33      const TRANSFORM_LIMIT = 50;
  34      private static $transformCount = 0;
  35  
  36  	public function __construct( ApiQuery $query, $moduleName, $prefix = 'ii' ) {
  37          // We allow a subclass to override the prefix, to create a related API
  38          // module. Some other parts of MediaWiki construct this with a null
  39          // $prefix, which used to be ignored when this only took two arguments
  40          if ( is_null( $prefix ) ) {
  41              $prefix = 'ii';
  42          }
  43          parent::__construct( $query, $moduleName, $prefix );
  44      }
  45  
  46  	public function execute() {
  47          $params = $this->extractRequestParams();
  48  
  49          $prop = array_flip( $params['prop'] );
  50  
  51          $scale = $this->getScale( $params );
  52  
  53          $opts = array(
  54              'version' => $params['metadataversion'],
  55              'language' => $params['extmetadatalanguage'],
  56              'multilang' => $params['extmetadatamultilang'],
  57              'extmetadatafilter' => $params['extmetadatafilter'],
  58              'revdelUser' => $this->getUser(),
  59          );
  60  
  61          $pageIds = $this->getPageSet()->getAllTitlesByNamespace();
  62          if ( !empty( $pageIds[NS_FILE] ) ) {
  63              $titles = array_keys( $pageIds[NS_FILE] );
  64              asort( $titles ); // Ensure the order is always the same
  65  
  66              $fromTitle = null;
  67              if ( !is_null( $params['continue'] ) ) {
  68                  $cont = explode( '|', $params['continue'] );
  69                  $this->dieContinueUsageIf( count( $cont ) != 2 );
  70                  $fromTitle = strval( $cont[0] );
  71                  $fromTimestamp = $cont[1];
  72                  // Filter out any titles before $fromTitle
  73                  foreach ( $titles as $key => $title ) {
  74                      if ( $title < $fromTitle ) {
  75                          unset( $titles[$key] );
  76                      } else {
  77                          break;
  78                      }
  79                  }
  80              }
  81  
  82              $user = $this->getUser();
  83              $findTitles = array_map( function ( $title ) use ( $user ) {
  84                  return array(
  85                      'title' => $title,
  86                      'private' => $user,
  87                  );
  88              }, $titles );
  89  
  90              if ( $params['localonly'] ) {
  91                  $images = RepoGroup::singleton()->getLocalRepo()->findFiles( $findTitles );
  92              } else {
  93                  $images = RepoGroup::singleton()->findFiles( $findTitles );
  94              }
  95  
  96              $result = $this->getResult();
  97              foreach ( $titles as $title ) {
  98                  $pageId = $pageIds[NS_FILE][$title];
  99                  $start = $title === $fromTitle ? $fromTimestamp : $params['start'];
 100  
 101                  if ( !isset( $images[$title] ) ) {
 102                      if ( isset( $prop['uploadwarning'] ) ) {
 103                          // Uploadwarning needs info about non-existing files
 104                          $images[$title] = wfLocalFile( $title );
 105                      } else {
 106                          $result->addValue(
 107                              array( 'query', 'pages', intval( $pageId ) ),
 108                              'imagerepository', ''
 109                          );
 110                          // The above can't fail because it doesn't increase the result size
 111                          continue;
 112                      }
 113                  }
 114  
 115                  /** @var $img File */
 116                  $img = $images[$title];
 117  
 118                  if ( self::getTransformCount() >= self::TRANSFORM_LIMIT ) {
 119                      if ( count( $pageIds[NS_FILE] ) == 1 ) {
 120                          // See the 'the user is screwed' comment below
 121                          $this->setContinueEnumParameter( 'start',
 122                              $start !== null ? $start : wfTimestamp( TS_ISO_8601, $img->getTimestamp() )
 123                          );
 124                      } else {
 125                          $this->setContinueEnumParameter( 'continue',
 126                              $this->getContinueStr( $img, $start ) );
 127                      }
 128                      break;
 129                  }
 130  
 131                  $fit = $result->addValue(
 132                      array( 'query', 'pages', intval( $pageId ) ),
 133                      'imagerepository', $img->getRepoName()
 134                  );
 135                  if ( !$fit ) {
 136                      if ( count( $pageIds[NS_FILE] ) == 1 ) {
 137                          // The user is screwed. imageinfo can't be solely
 138                          // responsible for exceeding the limit in this case,
 139                          // so set a query-continue that just returns the same
 140                          // thing again. When the violating queries have been
 141                          // out-continued, the result will get through
 142                          $this->setContinueEnumParameter( 'start',
 143                              $start !== null ? $start : wfTimestamp( TS_ISO_8601, $img->getTimestamp() )
 144                          );
 145                      } else {
 146                          $this->setContinueEnumParameter( 'continue',
 147                              $this->getContinueStr( $img, $start ) );
 148                      }
 149                      break;
 150                  }
 151  
 152                  // Check if we can make the requested thumbnail, and get transform parameters.
 153                  $finalThumbParams = $this->mergeThumbParams( $img, $scale, $params['urlparam'] );
 154  
 155                  // Get information about the current version first
 156                  // Check that the current version is within the start-end boundaries
 157                  $gotOne = false;
 158                  if (
 159                      ( is_null( $start ) || $img->getTimestamp() <= $start ) &&
 160                      ( is_null( $params['end'] ) || $img->getTimestamp() >= $params['end'] )
 161                  ) {
 162                      $gotOne = true;
 163  
 164                      $fit = $this->addPageSubItem( $pageId,
 165                          self::getInfo( $img, $prop, $result,
 166                              $finalThumbParams, $opts
 167                          )
 168                      );
 169                      if ( !$fit ) {
 170                          if ( count( $pageIds[NS_FILE] ) == 1 ) {
 171                              // See the 'the user is screwed' comment above
 172                              $this->setContinueEnumParameter( 'start',
 173                                  wfTimestamp( TS_ISO_8601, $img->getTimestamp() ) );
 174                          } else {
 175                              $this->setContinueEnumParameter( 'continue',
 176                                  $this->getContinueStr( $img ) );
 177                          }
 178                          break;
 179                      }
 180                  }
 181  
 182                  // Now get the old revisions
 183                  // Get one more to facilitate query-continue functionality
 184                  $count = ( $gotOne ? 1 : 0 );
 185                  $oldies = $img->getHistory( $params['limit'] - $count + 1, $start, $params['end'] );
 186                  /** @var $oldie File */
 187                  foreach ( $oldies as $oldie ) {
 188                      if ( ++$count > $params['limit'] ) {
 189                          // We've reached the extra one which shows that there are
 190                          // additional pages to be had. Stop here...
 191                          // Only set a query-continue if there was only one title
 192                          if ( count( $pageIds[NS_FILE] ) == 1 ) {
 193                              $this->setContinueEnumParameter( 'start',
 194                                  wfTimestamp( TS_ISO_8601, $oldie->getTimestamp() ) );
 195                          }
 196                          break;
 197                      }
 198                      $fit = self::getTransformCount() < self::TRANSFORM_LIMIT &&
 199                          $this->addPageSubItem( $pageId,
 200                              self::getInfo( $oldie, $prop, $result,
 201                                  $finalThumbParams, $opts
 202                              )
 203                          );
 204                      if ( !$fit ) {
 205                          if ( count( $pageIds[NS_FILE] ) == 1 ) {
 206                              $this->setContinueEnumParameter( 'start',
 207                                  wfTimestamp( TS_ISO_8601, $oldie->getTimestamp() ) );
 208                          } else {
 209                              $this->setContinueEnumParameter( 'continue',
 210                                  $this->getContinueStr( $oldie ) );
 211                          }
 212                          break;
 213                      }
 214                  }
 215                  if ( !$fit ) {
 216                      break;
 217                  }
 218              }
 219          }
 220      }
 221  
 222      /**
 223       * From parameters, construct a 'scale' array
 224       * @param array $params Parameters passed to api.
 225       * @return array|null Key-val array of 'width' and 'height', or null
 226       */
 227  	public function getScale( $params ) {
 228          $p = $this->getModulePrefix();
 229  
 230          if ( $params['urlwidth'] != -1 ) {
 231              $scale = array();
 232              $scale['width'] = $params['urlwidth'];
 233              $scale['height'] = $params['urlheight'];
 234          } elseif ( $params['urlheight'] != -1 ) {
 235              // Height is specified but width isn't
 236              // Don't set $scale['width']; this signals mergeThumbParams() to fill it with the image's width
 237              $scale = array();
 238              $scale['height'] = $params['urlheight'];
 239          } else {
 240              if ( $params['urlparam'] ) {
 241                  // Audio files might not have a width/height.
 242                  $scale = array();
 243              } else {
 244                  $scale = null;
 245              }
 246          }
 247  
 248          return $scale;
 249      }
 250  
 251      /** Validate and merge scale parameters with handler thumb parameters, give error if invalid.
 252       *
 253       * We do this later than getScale, since we need the image
 254       * to know which handler, since handlers can make their own parameters.
 255       * @param File $image Image that params are for.
 256       * @param array $thumbParams Thumbnail parameters from getScale
 257       * @param string $otherParams String of otherParams (iiurlparam).
 258       * @return array Array of parameters for transform.
 259       */
 260  	protected function mergeThumbParams( $image, $thumbParams, $otherParams ) {
 261          if ( $thumbParams === null ) {
 262              // No scaling requested
 263              return null;
 264          }
 265          if ( !isset( $thumbParams['width'] ) && isset( $thumbParams['height'] ) ) {
 266              // We want to limit only by height in this situation, so pass the
 267              // image's full width as the limiting width. But some file types
 268              // don't have a width of their own, so pick something arbitrary so
 269              // thumbnailing the default icon works.
 270              if ( $image->getWidth() <= 0 ) {
 271                  $thumbParams['width'] = max( $this->getConfig()->get( 'ThumbLimits' ) );
 272              } else {
 273                  $thumbParams['width'] = $image->getWidth();
 274              }
 275          }
 276  
 277          if ( !$otherParams ) {
 278              $this->checkParameterNormalise( $image, $thumbParams );
 279              return $thumbParams;
 280          }
 281          $p = $this->getModulePrefix();
 282  
 283          $h = $image->getHandler();
 284          if ( !$h ) {
 285              $this->setWarning( 'Could not create thumbnail because ' .
 286                  $image->getName() . ' does not have an associated image handler' );
 287  
 288              return $thumbParams;
 289          }
 290  
 291          $paramList = $h->parseParamString( $otherParams );
 292          if ( !$paramList ) {
 293              // Just set a warning (instead of dieUsage), as in many cases
 294              // we could still render the image using width and height parameters,
 295              // and this type of thing could happen between different versions of
 296              // handlers.
 297              $this->setWarning( "Could not parse {$p}urlparam for " . $image->getName()
 298                  . '. Using only width and height' );
 299              $this->checkParameterNormalise( $image, $thumbParams );
 300              return $thumbParams;
 301          }
 302  
 303          if ( isset( $paramList['width'] ) && isset( $thumbParams['width'] ) ) {
 304              if ( intval( $paramList['width'] ) != intval( $thumbParams['width'] ) ) {
 305                  $this->setWarning( "Ignoring width value set in {$p}urlparam ({$paramList['width']}) "
 306                      . "in favor of width value derived from {$p}urlwidth/{$p}urlheight "
 307                      . "({$thumbParams['width']})" );
 308              }
 309          }
 310  
 311          foreach ( $paramList as $name => $value ) {
 312              if ( !$h->validateParam( $name, $value ) ) {
 313                  $this->dieUsage( "Invalid value for {$p}urlparam ($name=$value)", "urlparam" );
 314              }
 315          }
 316  
 317          $finalParams = $thumbParams + $paramList;
 318          $this->checkParameterNormalise( $image, $finalParams );
 319          return $finalParams;
 320      }
 321  
 322      /**
 323       * Verify that the final image parameters can be normalised.
 324       *
 325       * This doesn't use the normalised parameters, since $file->transform
 326       * expects the pre-normalised parameters, but doing the normalisation
 327       * allows us to catch certain error conditions early (such as missing
 328       * required parameter).
 329       *
 330       * @param $image File
 331       * @param $finalParams array List of parameters to transform image with
 332       */
 333  	protected function checkParameterNormalise( $image, $finalParams ) {
 334          $h = $image->getHandler();
 335          if ( !$h ) {
 336              return;
 337          }
 338          // Note: normaliseParams modifies the array in place, but we aren't interested
 339          // in the actual normalised version, only if we can actually normalise them,
 340          // so we use the functions scope to throw away the normalisations.
 341          if ( !$h->normaliseParams( $image, $finalParams ) ) {
 342              $this->dieUsage( "Could not normalise image parameters for " . $image->getName(), "urlparamnormal" );
 343          }
 344      }
 345  
 346      /**
 347       * Get result information for an image revision
 348       *
 349       * @param File $file
 350       * @param array $prop Array of properties to get (in the keys)
 351       * @param ApiResult $result
 352       * @param array $thumbParams Containing 'width' and 'height' items, or null
 353       * @param array|bool|string $opts Options for data fetching.
 354       *   This is an array consisting of the keys:
 355       *    'version': The metadata version for the metadata option
 356       *    'language': The language for extmetadata property
 357       *    'multilang': Return all translations in extmetadata property
 358       *    'revdelUser': User to use when checking whether to show revision-deleted fields.
 359       * @return array Result array
 360       */
 361  	static function getInfo( $file, $prop, $result, $thumbParams = null, $opts = false ) {
 362          global $wgContLang;
 363  
 364          $anyHidden = false;
 365  
 366          if ( !$opts || is_string( $opts ) ) {
 367              $opts = array(
 368                  'version' => $opts ?: 'latest',
 369                  'language' => $wgContLang,
 370                  'multilang' => false,
 371                  'extmetadatafilter' => array(),
 372                  'revdelUser' => null,
 373              );
 374          }
 375          $version = $opts['version'];
 376          $vals = array();
 377          // Timestamp is shown even if the file is revdelete'd in interface
 378          // so do same here.
 379          if ( isset( $prop['timestamp'] ) ) {
 380              $vals['timestamp'] = wfTimestamp( TS_ISO_8601, $file->getTimestamp() );
 381          }
 382  
 383          // Handle external callers who don't pass revdelUser
 384          if ( isset( $opts['revdelUser'] ) && $opts['revdelUser'] ) {
 385              $revdelUser = $opts['revdelUser'];
 386              $canShowField = function ( $field ) use ( $file, $revdelUser ) {
 387                  return $file->userCan( $field, $revdelUser );
 388              };
 389          } else {
 390              $canShowField = function ( $field ) use ( $file ) {
 391                  return !$file->isDeleted( $field );
 392              };
 393          }
 394  
 395          $user = isset( $prop['user'] );
 396          $userid = isset( $prop['userid'] );
 397  
 398          if ( $user || $userid ) {
 399              if ( $file->isDeleted( File::DELETED_USER ) ) {
 400                  $vals['userhidden'] = '';
 401                  $anyHidden = true;
 402              }
 403              if ( $canShowField( File::DELETED_USER ) ) {
 404                  if ( $user ) {
 405                      $vals['user'] = $file->getUser();
 406                  }
 407                  if ( $userid ) {
 408                      $vals['userid'] = $file->getUser( 'id' );
 409                  }
 410                  if ( !$file->getUser( 'id' ) ) {
 411                      $vals['anon'] = '';
 412                  }
 413              }
 414          }
 415  
 416          // This is shown even if the file is revdelete'd in interface
 417          // so do same here.
 418          if ( isset( $prop['size'] ) || isset( $prop['dimensions'] ) ) {
 419              $vals['size'] = intval( $file->getSize() );
 420              $vals['width'] = intval( $file->getWidth() );
 421              $vals['height'] = intval( $file->getHeight() );
 422  
 423              $pageCount = $file->pageCount();
 424              if ( $pageCount !== false ) {
 425                  $vals['pagecount'] = $pageCount;
 426              }
 427  
 428              // length as in how many seconds long a video is.
 429              $length = $file->getLength();
 430              if ( $length ) {
 431                  // Call it duration, because "length" can be ambiguous.
 432                  $vals['duration'] = (float)$length;
 433              }
 434          }
 435  
 436          $pcomment = isset( $prop['parsedcomment'] );
 437          $comment = isset( $prop['comment'] );
 438  
 439          if ( $pcomment || $comment ) {
 440              if ( $file->isDeleted( File::DELETED_COMMENT ) ) {
 441                  $vals['commenthidden'] = '';
 442                  $anyHidden = true;
 443              }
 444              if ( $canShowField( File::DELETED_COMMENT ) ) {
 445                  if ( $pcomment ) {
 446                      $vals['parsedcomment'] = Linker::formatComment(
 447                          $file->getDescription( File::RAW ), $file->getTitle() );
 448                  }
 449                  if ( $comment ) {
 450                      $vals['comment'] = $file->getDescription( File::RAW );
 451                  }
 452              }
 453          }
 454  
 455          $canonicaltitle = isset( $prop['canonicaltitle'] );
 456          $url = isset( $prop['url'] );
 457          $sha1 = isset( $prop['sha1'] );
 458          $meta = isset( $prop['metadata'] );
 459          $extmetadata = isset( $prop['extmetadata'] );
 460          $commonmeta = isset( $prop['commonmetadata'] );
 461          $mime = isset( $prop['mime'] );
 462          $mediatype = isset( $prop['mediatype'] );
 463          $archive = isset( $prop['archivename'] );
 464          $bitdepth = isset( $prop['bitdepth'] );
 465          $uploadwarning = isset( $prop['uploadwarning'] );
 466  
 467          if ( $uploadwarning ) {
 468              $vals['html'] = SpecialUpload::getExistsWarning( UploadBase::getExistsWarning( $file ) );
 469          }
 470  
 471          if ( $file->isDeleted( File::DELETED_FILE ) ) {
 472              $vals['filehidden'] = '';
 473              $anyHidden = true;
 474          }
 475  
 476          if ( $anyHidden && $file->isDeleted( File::DELETED_RESTRICTED ) ) {
 477              $vals['suppressed'] = true;
 478          }
 479  
 480          if ( !$canShowField( File::DELETED_FILE ) ) {
 481              //Early return, tidier than indenting all following things one level
 482              return $vals;
 483          }
 484  
 485          if ( $canonicaltitle ) {
 486              $vals['canonicaltitle'] = $file->getTitle()->getPrefixedText();
 487          }
 488  
 489          if ( $url ) {
 490              if ( !is_null( $thumbParams ) ) {
 491                  $mto = $file->transform( $thumbParams );
 492                  self::$transformCount++;
 493                  if ( $mto && !$mto->isError() ) {
 494                      $vals['thumburl'] = wfExpandUrl( $mto->getUrl(), PROTO_CURRENT );
 495  
 496                      // bug 23834 - If the URL's are the same, we haven't resized it, so shouldn't give the wanted
 497                      // thumbnail sizes for the thumbnail actual size
 498                      if ( $mto->getUrl() !== $file->getUrl() ) {
 499                          $vals['thumbwidth'] = intval( $mto->getWidth() );
 500                          $vals['thumbheight'] = intval( $mto->getHeight() );
 501                      } else {
 502                          $vals['thumbwidth'] = intval( $file->getWidth() );
 503                          $vals['thumbheight'] = intval( $file->getHeight() );
 504                      }
 505  
 506                      if ( isset( $prop['thumbmime'] ) && $file->getHandler() ) {
 507                          list( , $mime ) = $file->getHandler()->getThumbType(
 508                              $mto->getExtension(), $file->getMimeType(), $thumbParams );
 509                          $vals['thumbmime'] = $mime;
 510                      }
 511                  } elseif ( $mto && $mto->isError() ) {
 512                      $vals['thumberror'] = $mto->toText();
 513                  }
 514              }
 515              $vals['url'] = wfExpandUrl( $file->getFullURL(), PROTO_CURRENT );
 516              $vals['descriptionurl'] = wfExpandUrl( $file->getDescriptionUrl(), PROTO_CURRENT );
 517          }
 518  
 519          if ( $sha1 ) {
 520              $vals['sha1'] = wfBaseConvert( $file->getSha1(), 36, 16, 40 );
 521          }
 522  
 523          if ( $meta ) {
 524              wfSuppressWarnings();
 525              $metadata = unserialize( $file->getMetadata() );
 526              wfRestoreWarnings();
 527              if ( $metadata && $version !== 'latest' ) {
 528                  $metadata = $file->convertMetadataVersion( $metadata, $version );
 529              }
 530              $vals['metadata'] = $metadata ? self::processMetaData( $metadata, $result ) : null;
 531          }
 532          if ( $commonmeta ) {
 533              $metaArray = $file->getCommonMetaArray();
 534              $vals['commonmetadata'] = $metaArray ? self::processMetaData( $metaArray, $result ) : array();
 535          }
 536  
 537          if ( $extmetadata ) {
 538              // Note, this should return an array where all the keys
 539              // start with a letter, and all the values are strings.
 540              // Thus there should be no issue with format=xml.
 541              $format = new FormatMetadata;
 542              $format->setSingleLanguage( !$opts['multilang'] );
 543              $format->getContext()->setLanguage( $opts['language'] );
 544              $extmetaArray = $format->fetchExtendedMetadata( $file );
 545              if ( $opts['extmetadatafilter'] ) {
 546                  $extmetaArray = array_intersect_key(
 547                      $extmetaArray, array_flip( $opts['extmetadatafilter'] )
 548                  );
 549              }
 550              $vals['extmetadata'] = $extmetaArray;
 551          }
 552  
 553          if ( $mime ) {
 554              $vals['mime'] = $file->getMimeType();
 555          }
 556  
 557          if ( $mediatype ) {
 558              $vals['mediatype'] = $file->getMediaType();
 559          }
 560  
 561          if ( $archive && $file->isOld() ) {
 562              $vals['archivename'] = $file->getArchiveName();
 563          }
 564  
 565          if ( $bitdepth ) {
 566              $vals['bitdepth'] = $file->getBitDepth();
 567          }
 568  
 569          return $vals;
 570      }
 571  
 572      /**
 573       * Get the count of image transformations performed
 574       *
 575       * If this is >= TRANSFORM_LIMIT, you should probably stop processing images.
 576       *
 577       * @return int Count
 578       */
 579  	static function getTransformCount() {
 580          return self::$transformCount;
 581      }
 582  
 583      /**
 584       *
 585       * @param array $metadata
 586       * @param ApiResult $result
 587       * @return array
 588       */
 589  	public static function processMetaData( $metadata, $result ) {
 590          $retval = array();
 591          if ( is_array( $metadata ) ) {
 592              foreach ( $metadata as $key => $value ) {
 593                  $r = array( 'name' => $key );
 594                  if ( is_array( $value ) ) {
 595                      $r['value'] = self::processMetaData( $value, $result );
 596                  } else {
 597                      $r['value'] = $value;
 598                  }
 599                  $retval[] = $r;
 600              }
 601          }
 602          $result->setIndexedTagName( $retval, 'metadata' );
 603  
 604          return $retval;
 605      }
 606  
 607  	public function getCacheMode( $params ) {
 608          if ( $this->userCanSeeRevDel() ) {
 609              return 'private';
 610          }
 611  
 612          return 'public';
 613      }
 614  
 615      /**
 616       * @param File $img
 617       * @param null|string $start
 618       * @return string
 619       */
 620  	protected function getContinueStr( $img, $start = null ) {
 621          if ( $start === null ) {
 622              $start = $img->getTimestamp();
 623          }
 624  
 625          return $img->getOriginalTitle()->getDBkey() . '|' . $start;
 626      }
 627  
 628  	public function getAllowedParams() {
 629          global $wgContLang;
 630  
 631          return array(
 632              'prop' => array(
 633                  ApiBase::PARAM_ISMULTI => true,
 634                  ApiBase::PARAM_DFLT => 'timestamp|user',
 635                  ApiBase::PARAM_TYPE => self::getPropertyNames()
 636              ),
 637              'limit' => array(
 638                  ApiBase::PARAM_TYPE => 'limit',
 639                  ApiBase::PARAM_DFLT => 1,
 640                  ApiBase::PARAM_MIN => 1,
 641                  ApiBase::PARAM_MAX => ApiBase::LIMIT_BIG1,
 642                  ApiBase::PARAM_MAX2 => ApiBase::LIMIT_BIG2
 643              ),
 644              'start' => array(
 645                  ApiBase::PARAM_TYPE => 'timestamp'
 646              ),
 647              'end' => array(
 648                  ApiBase::PARAM_TYPE => 'timestamp'
 649              ),
 650              'urlwidth' => array(
 651                  ApiBase::PARAM_TYPE => 'integer',
 652                  ApiBase::PARAM_DFLT => -1
 653              ),
 654              'urlheight' => array(
 655                  ApiBase::PARAM_TYPE => 'integer',
 656                  ApiBase::PARAM_DFLT => -1
 657              ),
 658              'metadataversion' => array(
 659                  ApiBase::PARAM_TYPE => 'string',
 660                  ApiBase::PARAM_DFLT => '1',
 661              ),
 662              'extmetadatalanguage' => array(
 663                  ApiBase::PARAM_TYPE => 'string',
 664                  ApiBase::PARAM_DFLT => $wgContLang->getCode(),
 665              ),
 666              'extmetadatamultilang' => array(
 667                  ApiBase::PARAM_TYPE => 'boolean',
 668                  ApiBase::PARAM_DFLT => false,
 669              ),
 670              'extmetadatafilter' => array(
 671                  ApiBase::PARAM_TYPE => 'string',
 672                  ApiBase::PARAM_ISMULTI => true,
 673              ),
 674              'urlparam' => array(
 675                  ApiBase::PARAM_DFLT => '',
 676                  ApiBase::PARAM_TYPE => 'string',
 677              ),
 678              'continue' => null,
 679              'localonly' => false,
 680          );
 681      }
 682  
 683      /**
 684       * Returns all possible parameters to iiprop
 685       *
 686       * @param array $filter List of properties to filter out
 687       *
 688       * @return array
 689       */
 690  	public static function getPropertyNames( $filter = array() ) {
 691          return array_diff( array_keys( self::getProperties() ), $filter );
 692      }
 693  
 694      /**
 695       * Returns array key value pairs of properties and their descriptions
 696       *
 697       * @param string $modulePrefix
 698       * @return array
 699       */
 700  	private static function getProperties( $modulePrefix = '' ) {
 701          return array(
 702              'timestamp' =>      ' timestamp     - Adds timestamp for the uploaded version',
 703              'user' =>           ' user          - Adds the user who uploaded the image version',
 704              'userid' =>         ' userid        - Add the user ID that uploaded the image version',
 705              'comment' =>        ' comment       - Comment on the version',
 706              'parsedcomment' =>  ' parsedcomment - Parse the comment on the version',
 707              'canonicaltitle' => ' canonicaltitle - Adds the canonical title of the image file',
 708              'url' =>            ' url           - Gives URL to the image and the description page',
 709              'size' =>           ' size          - Adds the size of the image in bytes, ' .
 710                  'its height and its width. Page count and duration are added if applicable',
 711              'dimensions' =>     ' dimensions    - Alias for size', // B/C with Allimages
 712              'sha1' =>           ' sha1          - Adds SHA-1 hash for the image',
 713              'mime' =>           ' mime          - Adds MIME type of the image',
 714              'thumbmime' =>      ' thumbmime     - Adds MIME type of the image thumbnail' .
 715                  ' (requires url and param ' . $modulePrefix . 'urlwidth)',
 716              'mediatype' =>      ' mediatype     - Adds the media type of the image',
 717              'metadata' =>       ' metadata      - Lists Exif metadata for the version of the image',
 718              'commonmetadata' => ' commonmetadata - Lists file format generic metadata ' .
 719                  'for the version of the image',
 720              'extmetadata' =>    ' extmetadata   - Lists formatted metadata combined ' .
 721                  'from multiple sources. Results are HTML formatted.',
 722              'archivename' =>    ' archivename   - Adds the file name of the archive ' .
 723                  'version for non-latest versions',
 724              'bitdepth' =>       ' bitdepth      - Adds the bit depth of the version',
 725              'uploadwarning' =>  ' uploadwarning - Used by the Special:Upload page to ' .
 726                  'get information about an existing file. Not intended for use outside MediaWiki core',
 727          );
 728      }
 729  
 730      /**
 731       * Returns the descriptions for the properties provided by getPropertyNames()
 732       *
 733       * @param array $filter List of properties to filter out
 734       * @param string $modulePrefix
 735       * @return array
 736       */
 737  	public static function getPropertyDescriptions( $filter = array(), $modulePrefix = '' ) {
 738          return array_merge(
 739              array( 'What image information to get:' ),
 740              array_values( array_diff_key( self::getProperties( $modulePrefix ), array_flip( $filter ) ) )
 741          );
 742      }
 743  
 744      /**
 745       * Return the API documentation for the parameters.
 746       * @return array Parameter documentation.
 747       */
 748  	public function getParamDescription() {
 749          $p = $this->getModulePrefix();
 750  
 751          return array(
 752              'prop' => self::getPropertyDescriptions( array(), $p ),
 753              'urlwidth' => array(
 754                  "If {$p}prop=url is set, a URL to an image scaled to this width will be returned.",
 755                  'For performance reasons if this option is used, ' .
 756                      'no more than ' . self::TRANSFORM_LIMIT . ' scaled images will be returned.'
 757              ),
 758              'urlheight' => "Similar to {$p}urlwidth.",
 759              'urlparam' => array(
 760                  "A handler specific parameter string. For example, pdf's ",
 761                  "might use 'page15-100px'."
 762              ),
 763              'limit' => 'How many image revisions to return per image',
 764              'start' => 'Timestamp to start listing from',
 765              'end' => 'Timestamp to stop listing at',
 766              'metadataversion'
 767                  => array( "Version of metadata to use. if 'latest' is specified, use latest version.",
 768                  "Defaults to '1' for backwards compatibility" ),
 769              'extmetadatalanguage' => array(
 770                  'What language to fetch extmetadata in. This affects both which',
 771                  'translation to fetch, if multiple are available, as well as how things',
 772                  'like numbers and various values are formatted.'
 773              ),
 774              'extmetadatamultilang'
 775                  =>'If translations for extmetadata property are available, fetch all of them.',
 776              'extmetadatafilter'
 777                  => "If specified and non-empty, only these keys will be returned for {$p}prop=extmetadata",
 778              'continue' => 'If the query response includes a continue value, ' .
 779                  'use it here to get another page of results',
 780              'localonly' => 'Look only for files in the local repository',
 781          );
 782      }
 783  
 784  	public function getDescription() {
 785          return 'Returns image information and upload history.';
 786      }
 787  
 788  	public function getExamples() {
 789          return array(
 790              'api.php?action=query&titles=File:Albert%20Einstein%20Head.jpg&prop=imageinfo',
 791              'api.php?action=query&titles=File:Test.jpg&prop=imageinfo&iilimit=50&' .
 792                  'iiend=20071231235959&iiprop=timestamp|user|url',
 793          );
 794      }
 795  
 796  	public function getHelpUrls() {
 797          return 'https://www.mediawiki.org/wiki/API:Properties#imageinfo_.2F_ii';
 798      }
 799  }