ForeignAPIFile.php

Go to the documentation of this file.

<?php
namespace MediaWiki\FileRepo\File;
 
use MediaHandler;
use MediaTransformOutput;
use MediaWiki\FileRepo\ForeignAPIRepo;
use MediaWiki\MediaWikiServices;
use MediaWiki\Permissions\Authority;
use MediaWiki\Title\Title;
use MediaWiki\User\UserIdentity;
use MediaWiki\User\UserIdentityValue;
 
class ForeignAPIFile extends File {
    private $mExists;
    private $mInfo;
 
    protected $repoClass = ForeignAPIRepo::class;
 
    public function __construct( $title, $repo, $info, $exists = false ) {
        parent::__construct( $title, $repo );
 
        $this->mInfo = $info;
        $this->mExists = $exists;
 
        $this->assertRepoDefined();
    }
 
    public static function newFromTitle( Title $title, $repo ) {
        $data = $repo->fetchImageQuery( [
            'titles' => 'File:' . $title->getDBkey(),
            'iiprop' => self::getProps(),
            'prop' => 'imageinfo',
            'iimetadataversion' => MediaHandler::getMetadataVersion(),
            // extmetadata is language-dependent, accessing the current language here
            // would be problematic, so we just get them all
            'iiextmetadatamultilang' => 1,
        ] );
 
        $info = $repo->getImageInfo( $data );
 
        if ( $info ) {
            $lastRedirect = count( $data['query']['redirects'] ?? [] ) - 1;
            if ( $lastRedirect >= 0 ) {
                // @phan-suppress-next-line PhanTypeArraySuspiciousNullable
                $newtitle = Title::newFromText( $data['query']['redirects'][$lastRedirect]['to'] );
                $img = new self( $newtitle, $repo, $info, true );
                $img->redirectedFrom( $title->getDBkey() );
            } else {
                $img = new self( $title, $repo, $info, true );
            }
 
            return $img;
        } else {
            return null;
        }
    }
 
    public static function getProps() {
        return 'timestamp|user|comment|url|size|sha1|metadata|mime|mediatype|extmetadata';
    }
 
    public function getRepo() {
        return $this->repo;
    }
 
    // Dummy functions...
 
    public function exists() {
        return $this->mExists;
    }
 
    public function getPath() {
        return false;
    }
 
    public function transform( $params, $flags = 0 ) {
        if ( !$this->canRender() ) {
            // show icon
            return parent::transform( $params, $flags );
        }
 
        // Note, the this->canRender() check above implies
        // that we have a handler, and it can do makeParamString.
        $otherParams = $this->handler->makeParamString( $params );
        $width = $params['width'] ?? -1;
        $height = $params['height'] ?? -1;
        $thumbUrl = false;
 
        if ( $width > 0 || $height > 0 ) {
            // Only query the remote if there are dimensions
            $thumbUrl = $this->repo->getThumbUrlFromCache(
                $this->getName(),
                $width,
                $height,
                $otherParams
            );
        } elseif ( $this->getMediaType() === MEDIATYPE_AUDIO ) {
            // This has no dimensions, but we still need to pass a value to getTransform()
            $thumbUrl = '/';
        }
        if ( $thumbUrl === false ) {
            global $wgLang;
 
            return $this->repo->getThumbError(
                $this->getName(),
                $width,
                $height,
                $otherParams,
                $wgLang->getCode()
            );
        }
 
        return $this->handler->getTransform( $this, 'bogus', $thumbUrl, $params );
    }
 
    // Info we can get from API...
 
    public function getWidth( $page = 1 ) {
        return (int)( $this->mInfo['width'] ?? 0 );
    }
 
    public function getHeight( $page = 1 ) {
        return (int)( $this->mInfo['height'] ?? 0 );
    }
 
    public function getMetadata() {
        if ( isset( $this->mInfo['metadata'] ) ) {
            return serialize( self::parseMetadata( $this->mInfo['metadata'] ) );
        }
 
        return false;
    }
 
    public function getMetadataArray(): array {
        if ( isset( $this->mInfo['metadata'] ) ) {
            return self::parseMetadata( $this->mInfo['metadata'] );
        }
 
        return [];
    }
 
    public function getExtendedMetadata() {
        return $this->mInfo['extmetadata'] ?? null;
    }
 
    public static function parseMetadata( $metadata ) {
        if ( !is_array( $metadata ) ) {
            return [ '_error' => $metadata ];
        }
        '@phan-var array[] $metadata';
        $ret = [];
        foreach ( $metadata as $meta ) {
            $ret[$meta['name']] = self::parseMetadataValue( $meta['value'] );
        }
 
        return $ret;
    }
 
    private static function parseMetadataValue( $metadata ) {
        if ( !is_array( $metadata ) ) {
            return $metadata;
        }
        '@phan-var array[] $metadata';
        $ret = [];
        foreach ( $metadata as $meta ) {
            $ret[$meta['name']] = self::parseMetadataValue( $meta['value'] );
        }
 
        return $ret;
    }
 
    public function getSize() {
        return isset( $this->mInfo['size'] ) ? intval( $this->mInfo['size'] ) : null;
    }
 
    public function getUrl() {
        return isset( $this->mInfo['url'] ) ? strval( $this->mInfo['url'] ) : null;
    }
 
    public function getDescriptionShortUrl() {
        if ( isset( $this->mInfo['descriptionshorturl'] ) ) {
            return $this->mInfo['descriptionshorturl'];
        } elseif ( isset( $this->mInfo['pageid'] ) ) {
            $url = $this->repo->makeUrl( [ 'curid' => $this->mInfo['pageid'] ] );
            if ( $url !== false ) {
                return $url;
            }
        }
        return null;
    }
 
    public function getUploader( int $audience = self::FOR_PUBLIC, ?Authority $performer = null ): ?UserIdentity {
        if ( isset( $this->mInfo['user'] ) ) {
            return UserIdentityValue::newExternal( $this->getRepoName(), $this->mInfo['user'] );
        }
        return null;
    }
 
    public function getDescription( $audience = self::FOR_PUBLIC, ?Authority $performer = null ) {
        return isset( $this->mInfo['comment'] ) ? strval( $this->mInfo['comment'] ) : null;
    }
 
    public function getSha1() {
        return isset( $this->mInfo['sha1'] )
            ? \Wikimedia\base_convert( strval( $this->mInfo['sha1'] ), 16, 36, 31 )
            : null;
    }
 
    public function getTimestamp() {
        return wfTimestamp( TS_MW,
            isset( $this->mInfo['timestamp'] )
                ? strval( $this->mInfo['timestamp'] )
                : null
        );
    }
 
    public function getMimeType() {
        if ( !isset( $this->mInfo['mime'] ) ) {
            $magic = MediaWikiServices::getInstance()->getMimeAnalyzer();
            $this->mInfo['mime'] = $magic->getMimeTypeFromExtensionOrNull( $this->getExtension() );
        }
 
        return $this->mInfo['mime'];
    }
 
    public function getMediaType() {
        if ( isset( $this->mInfo['mediatype'] ) ) {
            return $this->mInfo['mediatype'];
        }
        $magic = MediaWikiServices::getInstance()->getMimeAnalyzer();
 
        return $magic->getMediaType( null, $this->getMimeType() );
    }
 
    public function getDescriptionUrl() {
        return $this->mInfo['descriptionurl'] ?? false;
    }
 
    public function getThumbPath( $suffix = '' ) {
        if ( !$this->repo->canCacheThumbs() ) {
            return null;
        }
 
        $path = $this->repo->getZonePath( 'thumb' ) . '/' . $this->getHashPath();
        if ( $suffix ) {
            $path .= $suffix . '/';
        }
        return $path;
    }
 
    protected function getThumbnails() {
        $dir = $this->getThumbPath( $this->getName() );
        $iter = $this->repo->getBackend()->getFileList( [ 'dir' => $dir ] );
 
        $files = [];
        if ( $iter ) {
            foreach ( $iter as $file ) {
                $files[] = $file;
            }
        }
 
        return $files;
    }
 
    public function purgeCache( $options = [] ) {
        $this->purgeThumbnails( $options );
        $this->purgeDescriptionPage();
    }
 
    private function purgeDescriptionPage() {
        $services = MediaWikiServices::getInstance();
        $langCode = $services->getContentLanguageCode()->toString();
 
        // Key must match File::getDescriptionText
        $key = $this->repo->getLocalCacheKey( 'file-remote-description', $langCode, md5( $this->getName() ) );
        $services->getMainWANObjectCache()->delete( $key );
    }
 
    public function purgeThumbnails( $options = [] ) {
        $key = $this->repo->getLocalCacheKey( 'file-thumb-url', sha1( $this->getName() ) );
        MediaWikiServices::getInstance()->getMainWANObjectCache()->delete( $key );
 
        $files = $this->getThumbnails();
        // Give media handler a chance to filter the purge list
        $handler = $this->getHandler();
        if ( $handler ) {
            $handler->filterThumbnailPurgeList( $files, $options );
        }
 
        $dir = $this->getThumbPath( $this->getName() );
        $purgeList = [];
        foreach ( $files as $file ) {
            $purgeList[] = "{$dir}{$file}";
        }
 
        # Delete the thumbnails
        $this->repo->quickPurgeBatch( $purgeList );
        # Clear out the thumbnail directory if empty
        $this->repo->quickCleanDir( $dir );
    }
 
    public function isTransformedLocally() {
        return false;
    }
}
 
class_alias( ForeignAPIFile::class, 'ForeignAPIFile' );