WikiFilePage.php

Go to the documentation of this file.

<?php
use MediaWiki\Actions\FileDeleteAction;
use MediaWiki\MediaWikiServices;
use MediaWiki\Title\Title;
use MediaWiki\Title\TitleArray;
use Wikimedia\Rdbms\FakeResultWrapper;
 
class WikiFilePage extends WikiPage {
    protected $mFile = false;
    protected $mRepo = null;
    protected $mFileLoaded = false;
    protected $mDupes = null;
 
    public function __construct( $title ) {
        parent::__construct( $title );
        $this->mDupes = null;
        $this->mRepo = null;
    }
 
    public function setFile( File $file ) {
        $this->mFile = $file;
        $this->mFileLoaded = true;
    }
 
    protected function loadFile() {
        $services = MediaWikiServices::getInstance();
        if ( $this->mFileLoaded ) {
            return true;
        }
 
        $this->mFile = $services->getRepoGroup()->findFile( $this->mTitle );
        if ( !$this->mFile ) {
            $this->mFile = $services->getRepoGroup()->getLocalRepo()
                ->newFile( $this->mTitle );
        }
 
        if ( !$this->mFile instanceof File ) {
            throw new RuntimeException( 'Expected to find file. See T250767' );
        }
 
        $this->mRepo = $this->mFile->getRepo();
        $this->mFileLoaded = true;
        return true;
    }
 
    public function getRedirectTarget() {
        $this->loadFile();
        if ( $this->mFile->isLocal() ) {
            return parent::getRedirectTarget();
        }
        // Foreign image page
        $from = $this->mFile->getRedirected();
        $to = $this->mFile->getName();
        if ( $from == $to ) {
            return null;
        }
        $this->mRedirectTarget = Title::makeTitle( NS_FILE, $to );
        return $this->mRedirectTarget;
    }
 
    public function followRedirect() {
        $this->loadFile();
        if ( $this->mFile->isLocal() ) {
            return parent::followRedirect();
        }
        $from = $this->mFile->getRedirected();
        $to = $this->mFile->getName();
        if ( $from == $to ) {
            return false;
        }
        return Title::makeTitle( NS_FILE, $to );
    }
 
    public function isRedirect() {
        $this->loadFile();
        if ( $this->mFile->isLocal() ) {
            return parent::isRedirect();
        }
 
        return (bool)$this->mFile->getRedirected();
    }
 
    public function isLocal() {
        $this->loadFile();
        return $this->mFile->isLocal();
    }
 
    public function getFile(): File {
        $this->loadFile();
        return $this->mFile;
    }
 
    public function getDuplicates() {
        $this->loadFile();
        if ( $this->mDupes !== null ) {
            return $this->mDupes;
        }
        $hash = $this->mFile->getSha1();
        if ( !( $hash ) ) {
            $this->mDupes = [];
            return $this->mDupes;
        }
        $dupes = MediaWikiServices::getInstance()->getRepoGroup()->findBySha1( $hash );
        // Remove duplicates with self and non matching file sizes
        $self = $this->mFile->getRepoName() . ':' . $this->mFile->getName();
        $size = $this->mFile->getSize();
 
        foreach ( $dupes as $index => $file ) {
            $key = $file->getRepoName() . ':' . $file->getName();
            if ( $key == $self ) {
                unset( $dupes[$index] );
            }
            if ( $file->getSize() != $size ) {
                unset( $dupes[$index] );
            }
        }
        $this->mDupes = $dupes;
        return $this->mDupes;
    }
 
    public function doPurge() {
        $this->loadFile();
 
        if ( $this->mFile->exists() ) {
            wfDebug( 'ImagePage::doPurge purging ' . $this->mFile->getName() );
            $job = HTMLCacheUpdateJob::newForBacklinks(
                $this->mTitle,
                'imagelinks',
                [ 'causeAction' => 'file-purge' ]
            );
            MediaWikiServices::getInstance()->getJobQueueGroup()->lazyPush( $job );
        } else {
            wfDebug( 'ImagePage::doPurge no image for '
                . $this->mFile->getName() . "; limiting purge to cache only" );
        }
 
        // even if the file supposedly doesn't exist, force any cached information
        // to be updated (in case the cached information is wrong)
 
        // Purge current version and its thumbnails
        $this->mFile->purgeCache( [ 'forThumbRefresh' => true ] );
 
        // Purge the old versions and their thumbnails
        foreach ( $this->mFile->getHistory() as $oldFile ) {
            $oldFile->purgeCache( [ 'forThumbRefresh' => true ] );
        }
 
        if ( $this->mRepo ) {
            // Purge redirect cache
            $this->mRepo->invalidateImageRedirect( $this->mTitle );
        }
 
        return parent::doPurge();
    }
 
    public function getForeignCategories() {
        $this->loadFile();
        $title = $this->mTitle;
        $file = $this->mFile;
 
        if ( !$file instanceof LocalFile ) {
            wfDebug( __METHOD__ . " is not supported for this file" );
            return TitleArray::newFromResult( new FakeResultWrapper( [] ) );
        }
 
        $repo = $file->getRepo();
        $dbr = $repo->getReplicaDB();
 
        $res = $dbr->select(
            [ 'page', 'categorylinks' ],
            [
                'page_title' => 'cl_to',
                'page_namespace' => NS_CATEGORY,
            ],
            [
                'page_namespace' => $title->getNamespace(),
                'page_title' => $title->getDBkey(),
            ],
            __METHOD__,
            [],
            [ 'categorylinks' => [ 'JOIN', 'page_id = cl_from' ] ]
        );
 
        return TitleArray::newFromResult( $res );
    }
 
    public function getWikiDisplayName() {
        return $this->getFile()->getRepo()->getDisplayName();
    }
 
    public function getSourceURL() {
        return $this->getFile()->getDescriptionUrl();
    }
 
    public function getActionOverrides() {
        $file = $this->getFile();
        if ( $file->exists() && $file->isLocal() && !$file->getRedirected() ) {
            // Would be an actual file deletion
            return [ 'delete' => FileDeleteAction::class ] + parent::getActionOverrides();
        }
        // It should use the normal article deletion interface
        return parent::getActionOverrides();
    }
}