ForeignAPIFile.php

Go to the documentation of this file.

<?php
use MediaWiki\MediaWikiServices;

class ForeignAPIFile extends File {
    private $mExists;
    private $mInfo = [];

    protected $repoClass = ForeignAPIRepo::class;

    function __construct( $title, $repo, $info, $exists = false ) {
        parent::__construct( $title, $repo );

        $this->mInfo = $info;
        $this->mExists = $exists;

        $this->assertRepoDefined();
    }

    static function newFromTitle( Title $title, $repo ) {
        $data = $repo->fetchImageQuery( [
            'titles' => 'File:' . $title->getDBkey(),
            'iiprop' => self::getProps(),
            'prop' => 'imageinfo',
            'iimetadataversion' => MediaHandler::getMetadataVersion(),
            // extmetadata is language-dependant, accessing the current language here
            // would be problematic, so we just get them all
            'iiextmetadatamultilang' => 1,
        ] );

        $info = $repo->getImageInfo( $data );

        if ( $info ) {
            $lastRedirect = isset( $data['query']['redirects'] )
                ? count( $data['query']['redirects'] ) - 1
                : -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;
        }
    }

    static function getProps() {
        return 'timestamp|user|comment|url|size|sha1|metadata|mime|mediatype|extmetadata';
    }

    // Dummy functions...

    public function exists() {
        return $this->mExists;
    }

    public function getPath() {
        return false;
    }

    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 = $this->repo->getThumbUrlFromCache(
            $this->getName(),
            $width,
            $height,
            $otherParams
        );
        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 isset( $this->mInfo['width'] ) ? intval( $this->mInfo['width'] ) : 0;
    }

    public function getHeight( $page = 1 ) {
        return isset( $this->mInfo['height'] ) ? intval( $this->mInfo['height'] ) : 0;
    }

    public function getMetadata() {
        if ( isset( $this->mInfo['metadata'] ) ) {
            return serialize( self::parseMetadata( $this->mInfo['metadata'] ) );
        }

        return null;
    }

    public function getExtendedMetadata() {
        return $this->mInfo['extmetadata'] ?? null;
    }

    public static function parseMetadata( $metadata ) {
        if ( !is_array( $metadata ) ) {
            return $metadata;
        }
        '@phan-var array[] $metadata';
        $ret = [];
        foreach ( $metadata as $meta ) {
            $ret[$meta['name']] = self::parseMetadata( $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 getUser( $type = 'text' ) {
        if ( $type == 'text' ) {
            return isset( $this->mInfo['user'] ) ? strval( $this->mInfo['user'] ) : null;
        } else {
            return 0; // What makes sense here, for a remote user?
        }
    }

    public function getDescription( $audience = self::FOR_PUBLIC, User $user = null ) {
        return isset( $this->mInfo['comment'] ) ? strval( $this->mInfo['comment'] ) : null;
    }

    function getSha1() {
        return isset( $this->mInfo['sha1'] )
            ? Wikimedia\base_convert( strval( $this->mInfo['sha1'] ), 16, 36, 31 )
            : null;
    }

    function getTimestamp() {
        return wfTimestamp( TS_MW,
            isset( $this->mInfo['timestamp'] )
                ? strval( $this->mInfo['timestamp'] )
                : null
        );
    }

    function getMimeType() {
        if ( !isset( $this->mInfo['mime'] ) ) {
            $magic = MediaWiki\MediaWikiServices::getInstance()->getMimeAnalyzer();
            $this->mInfo['mime'] = $magic->guessTypesForExtension( $this->getExtension() );
        }

        return $this->mInfo['mime'];
    }

    function getMediaType() {
        if ( isset( $this->mInfo['mediatype'] ) ) {
            return $this->mInfo['mediatype'];
        }
        $magic = MediaWiki\MediaWikiServices::getInstance()->getMimeAnalyzer();

        return $magic->getMediaType( null, $this->getMimeType() );
    }

    function getDescriptionUrl() {
        return $this->mInfo['descriptionurl'] ?? false;
    }

    function getThumbPath( $suffix = '' ) {
        if ( !$this->repo->canCacheThumbs() ) {
            return null;
        }

        $path = $this->repo->getZonePath( 'thumb' ) . '/' . $this->getHashPath();
        if ( $suffix ) {
            $path .= $suffix . '/';
        }
        return $path;
    }

    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;
    }

    function purgeCache( $options = [] ) {
        $this->purgeThumbnails( $options );
        $this->purgeDescriptionPage();
    }

    function purgeDescriptionPage() {
        $services = MediaWikiServices::getInstance();
        $url = $this->repo->getDescriptionRenderUrl(
            $this->getName(), $services->getContentLanguage()->getCode() );
        $key = $this->repo->getLocalCacheKey( 'RemoteFileDescription', 'url', md5( $url ) );

        $services->getMainWANObjectCache()->delete( $key );
    }

    function purgeThumbnails( $options = [] ) {
        $key = $this->repo->getLocalCacheKey( 'ForeignAPIRepo', 'ThumbUrl', $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;
    }
}