ImageHistoryList.php

Go to the documentation of this file.

<?php
use MediaWiki\Context\ContextSource;
use MediaWiki\HookContainer\ProtectedHookAccessorTrait;
use MediaWiki\Html\Html;
use MediaWiki\Linker\Linker;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\SpecialPage\SpecialPage;
use MediaWiki\Title\Title;
 
class ImageHistoryList extends ContextSource {
    use ProtectedHookAccessorTrait;
 
    protected $title;
 
    protected $img;
 
    protected $imagePage;
 
    protected $current;
 
    protected $repo;
    protected bool $showThumb;
    protected $preventClickjacking = false;
 
    public function __construct( $imagePage ) {
        $context = $imagePage->getContext();
        $this->current = $imagePage->getPage()->getFile();
        $this->img = $imagePage->getDisplayedFile();
        $this->title = $imagePage->getTitle();
        $this->imagePage = $imagePage;
        $this->showThumb = $context->getConfig()->get( MainConfigNames::ShowArchiveThumbnails ) &&
            $this->img->canRender();
        $this->setContext( $context );
    }
 
    public function getImagePage() {
        return $this->imagePage;
    }
 
    public function getFile() {
        return $this->img;
    }
 
    public function beginImageHistoryList() {
        // Styles for class=history-deleted
        $this->getOutput()->addModuleStyles( 'mediawiki.interface.helpers.styles' );
 
        $html = '';
        $canDelete = $this->current->isLocal() &&
            $this->getAuthority()->isAllowedAny( 'delete', 'deletedhistory' );
 
        foreach ( [
            '',
            $canDelete ? '' : null,
            'filehist-datetime',
            $this->showThumb ? 'filehist-thumb' : null,
            'filehist-dimensions',
            'filehist-user',
            'filehist-comment',
        ] as $key ) {
            if ( $key !== null ) {
                $html .= Html::element( 'th', [], $key ? $this->msg( $key )->text() : '' );
            }
        }
 
        return Html::openElement( 'table', [ 'class' => 'wikitable filehistory' ] ) . "\n"
            . Html::rawElement( 'tr', [], $html ) . "\n";
    }
 
    public function endImageHistoryList() {
        return Html::closeElement( 'table' ) . "\n";
    }
 
    public function imageHistoryLine( $iscur, $file, $formattedComment ) {
        $user = $this->getUser();
        $lang = $this->getLanguage();
        $linkRenderer = MediaWikiServices::getInstance()->getLinkRenderer();
        $timestamp = wfTimestamp( TS_MW, $file->getTimestamp() );
        // @phan-suppress-next-line PhanUndeclaredMethod
        $img = $iscur ? $file->getName() : $file->getArchiveName();
        $uploader = $file->getUploader( File::FOR_THIS_USER, $user );
 
        $local = $this->current->isLocal();
        $row = '';
 
        // Deletion link
        if ( $local && ( $this->getAuthority()->isAllowedAny( 'delete', 'deletedhistory' ) ) ) {
            $row .= Html::openElement( 'td' );
            # Link to hide content. Don't show useless link to people who cannot hide revisions.
            if ( !$iscur && $this->getAuthority()->isAllowed( 'deleterevision' ) ) {
                // If file is top revision, is missing or locked from this user, don't link
                if ( !$file->userCan( File::DELETED_RESTRICTED, $user ) || !$file->exists() ) {
                    $row .= Html::check( 'deleterevisions', false, [ 'disabled' => 'disabled' ] );
                } else {
                    $row .= Html::check( 'ids[' . explode( '!', $img, 2 )[0] . ']', false );
                }
                if ( $this->getAuthority()->isAllowed( 'delete' ) ) {
                    $row .= ' ';
                }
            }
            # Link to remove from history
            if ( $this->getAuthority()->isAllowed( 'delete' ) ) {
                if ( $file->exists() ) {
                    $row .= $linkRenderer->makeKnownLink(
                        $this->title,
                        $this->msg( $iscur ? 'filehist-deleteall' : 'filehist-deleteone' )->text(),
                        [],
                        [ 'action' => 'delete', 'oldimage' => $iscur ? null : $img ]
                    );
                } else {
                    // T244567: Non-existing file can not be deleted.
                    $row .= $this->msg( 'filehist-missing' )->escaped();
                }
 
            }
            $row .= Html::closeElement( 'td' );
        }
 
        // Reversion link/current indicator
        $row .= Html::openElement( 'td' );
        if ( $iscur ) {
            $row .= $this->msg( 'filehist-current' )->escaped();
        } elseif ( $local && $this->getAuthority()->probablyCan( 'edit', $this->title )
            && $this->getAuthority()->probablyCan( 'upload', $this->title )
        ) {
            if ( $file->isDeleted( File::DELETED_FILE ) ) {
                $row .= $this->msg( 'filehist-revert' )->escaped();
            } elseif ( !$file->exists() ) {
                // T328112: Lost file, in this case there's no version to revert back to.
                $row .= $this->msg( 'filehist-missing' )->escaped();
            } else {
                $row .= $linkRenderer->makeKnownLink(
                    $this->title,
                    $this->msg( 'filehist-revert' )->text(),
                    [],
                    [
                        'action' => 'revert',
                        'oldimage' => $img,
                    ]
                );
            }
        }
        $row .= Html::closeElement( 'td' );
 
        // Date/time and image link
        $selected = $file->getTimestamp() === $this->img->getTimestamp();
        $row .= Html::openElement( 'td', [
            'class' => $selected ? 'filehistory-selected' : null,
            'style' => 'white-space: nowrap;'
        ] );
        if ( !$file->userCan( File::DELETED_FILE, $user ) ) {
            # Don't link to unviewable files
            $row .= Html::element( 'span', [ 'class' => 'history-deleted' ],
                $lang->userTimeAndDate( $timestamp, $user )
            );
        } elseif ( $file->isDeleted( File::DELETED_FILE ) ) {
            $timeAndDate = $lang->userTimeAndDate( $timestamp, $user );
            if ( $local ) {
                $this->setPreventClickjacking( true );
                # Make a link to review the image
                $url = $linkRenderer->makeKnownLink(
                    SpecialPage::getTitleFor( 'Revisiondelete' ),
                    $timeAndDate,
                    [],
                    [
                        'target' => $this->title->getPrefixedText(),
                        'file' => $img,
                        'token' => $user->getEditToken( $img )
                    ]
                );
            } else {
                $url = htmlspecialchars( $timeAndDate );
            }
            $row .= Html::rawElement( 'span', [ 'class' => 'history-deleted' ], $url );
        } elseif ( !$file->exists() ) {
            $row .= Html::element( 'span', [ 'class' => 'mw-file-missing' ],
                $lang->userTimeAndDate( $timestamp, $user )
            );
        } else {
            $url = $iscur ? $this->current->getUrl() : $this->current->getArchiveUrl( $img );
            $row .= Html::element( 'a', [ 'href' => $url ],
                $lang->userTimeAndDate( $timestamp, $user )
            );
        }
        $row .= Html::closeElement( 'td' );
 
        // Thumbnail
        if ( $this->showThumb ) {
            $row .= Html::rawElement( 'td', [],
                $this->getThumbForLine( $file, $iscur ) ?? $this->msg( 'filehist-nothumb' )->escaped()
            );
        }
 
        // Image dimensions + size
        $row .= Html::openElement( 'td' );
        $row .= htmlspecialchars( $file->getDimensionsString() );
        $row .= $this->msg( 'word-separator' )->escaped();
        $row .= Html::element( 'span', [ 'style' => 'white-space: nowrap;' ],
            $this->msg( 'parentheses' )->sizeParams( $file->getSize() )->text()
        );
        $row .= Html::closeElement( 'td' );
 
        // Uploading user
        $row .= Html::openElement( 'td' );
        // Hide deleted usernames
        if ( $uploader && $local ) {
            $row .= Linker::userLink( $uploader->getId(), $uploader->getName() );
            $row .= Html::rawElement( 'span', [ 'style' => 'white-space: nowrap;' ],
                Linker::userToolLinks( $uploader->getId(), $uploader->getName() )
            );
        } elseif ( $uploader ) {
            $row .= htmlspecialchars( $uploader->getName() );
        } else {
            $row .= Html::element( 'span', [ 'class' => 'history-deleted' ],
                $this->msg( 'rev-deleted-user' )->text()
            );
        }
        $row .= Html::closeElement( 'td' );
 
        // Don't show deleted descriptions
        if ( $file->isDeleted( File::DELETED_COMMENT ) ) {
            $row .= Html::rawElement( 'td', [],
                Html::element( 'span', [ 'class' => 'history-deleted' ],
                    $this->msg( 'rev-deleted-comment' )->text()
                )
            );
        } else {
            $contLang = MediaWikiServices::getInstance()->getContentLanguage();
            $row .= Html::rawElement( 'td', [ 'dir' => $contLang->getDir() ], $formattedComment );
        }
 
        $rowClass = null;
        $this->getHookRunner()->onImagePageFileHistoryLine( $this, $file, $row, $rowClass );
 
        return Html::rawElement( 'tr', [ 'class' => $rowClass ], $row ) . "\n";
    }
 
    protected function getThumbForLine( $file, $iscur ) {
        $user = $this->getUser();
        if ( !$file->allowInlineDisplay() ||
            $file->isDeleted( File::DELETED_FILE ) ||
            !$file->userCan( File::DELETED_FILE, $user )
        ) {
            return null;
        }
 
        $thumbnail = $file->transform(
            [
                'width' => '120',
                'height' => '120',
                'isFilePageThumb' => $iscur  // old revisions are already versioned
            ]
        );
        if ( !$thumbnail ) {
            return null;
        }
 
        $lang = $this->getLanguage();
        $timestamp = wfTimestamp( TS_MW, $file->getTimestamp() );
        $alt = $this->msg(
            'filehist-thumbtext',
            $lang->userTimeAndDate( $timestamp, $user ),
            $lang->userDate( $timestamp, $user ),
            $lang->userTime( $timestamp, $user )
        )->text();
        return $thumbnail->toHtml( [ 'alt' => $alt, 'file-link' => true, 'loading' => 'lazy' ] );
    }
 
    protected function preventClickjacking( $enable = true ) {
        $this->preventClickjacking = $enable;
    }
 
    protected function setPreventClickjacking( bool $enable ) {
        $this->preventClickjacking = $enable;
    }
 
    public function getPreventClickjacking() {
        return $this->preventClickjacking;
    }
}