RevDelFileItem.php

Go to the documentation of this file.

<?php
use MediaWiki\Api\ApiResult;
use MediaWiki\FileRepo\File\File;
use MediaWiki\FileRepo\File\OldLocalFile;
use MediaWiki\Html\Html;
use MediaWiki\Linker\Linker;
use MediaWiki\MediaWikiServices;
use MediaWiki\RevisionList\RevisionListBase;
use MediaWiki\SpecialPage\SpecialPage;
use Wikimedia\Rdbms\IConnectionProvider;
 
class RevDelFileItem extends RevDelItem {
    protected $list;
    protected $file;
    protected IConnectionProvider $dbProvider;
 
    public function __construct( RevisionListBase $list, $row ) {
        parent::__construct( $list, $row );
        $this->file = static::initFile( $list, $row );
        $this->dbProvider = MediaWikiServices::getInstance()->getConnectionProvider();
    }
 
    protected static function initFile( $list, $row ) {
        return MediaWikiServices::getInstance()->getRepoGroup()->getLocalRepo()
            ->newFileFromRow( $row );
    }
 
    public function getIdField() {
        return 'oi_archive_name';
    }
 
    public function getTimestampField() {
        return 'oi_timestamp';
    }
 
    public function getAuthorIdField() {
        return 'oi_user';
    }
 
    public function getAuthorNameField() {
        return 'oi_user_text';
    }
 
    public function getAuthorActorField() {
        return 'oi_actor';
    }
 
    public function getId() {
        $parts = explode( '!', $this->row->oi_archive_name );
 
        return $parts[0];
    }
 
    public function canView() {
        return $this->file->userCan( File::DELETED_RESTRICTED, $this->list->getAuthority() );
    }
 
    public function canViewContent() {
        return $this->file->userCan( File::DELETED_FILE, $this->list->getAuthority() );
    }
 
    public function getBits() {
        return $this->file->getVisibility();
    }
 
    public function setBits( $bits ) {
        # Queue the file op
        # @todo FIXME: Move to LocalFile.php
        if ( $this->isDeleted() ) {
            if ( $bits & File::DELETED_FILE ) {
                # Still deleted
            } else {
                # Newly undeleted
                $key = $this->file->getStorageKey();
                $srcRel = $this->file->repo->getDeletedHashPath( $key ) . $key;
                $this->list->storeBatch[] = [
                    $this->file->repo->getVirtualUrl( 'deleted' ) . '/' . $srcRel,
                    'public',
                    $this->file->getRel()
                ];
                $this->list->cleanupBatch[] = $key;
            }
        } elseif ( $bits & File::DELETED_FILE ) {
            # Newly deleted
            $key = $this->file->getStorageKey();
            $dstRel = $this->file->repo->getDeletedHashPath( $key ) . $key;
            $this->list->deleteBatch[] = [ $this->file->getRel(), $dstRel ];
        }
 
        # Do the database operations
        $dbw = $this->dbProvider->getPrimaryDatabase();
        $dbw->newUpdateQueryBuilder()
            ->update( 'oldimage' )
            ->set( [ 'oi_deleted' => $bits ] )
            ->where( [
                'oi_name' => $this->row->oi_name,
                'oi_timestamp' => $this->row->oi_timestamp,
                'oi_deleted' => $this->getBits()
            ] )
            ->caller( __METHOD__ )->execute();
 
        return (bool)$dbw->affectedRows();
    }
 
    public function isDeleted() {
        return $this->file->isDeleted( File::DELETED_FILE );
    }
 
    protected function getLink() {
        $date = $this->list->getLanguage()->userTimeAndDate(
            $this->file->getTimestamp(), $this->list->getUser() );
 
        if ( !$this->isDeleted() ) {
            # Regular files...
            return Html::element( 'a', [ 'href' => $this->file->getUrl() ], $date );
        }
 
        # Hidden files...
        if ( !$this->canViewContent() ) {
            $link = htmlspecialchars( $date );
        } else {
            $link = $this->getLinkRenderer()->makeLink(
                SpecialPage::getTitleFor( 'Revisiondelete' ),
                $date,
                [],
                [
                    'target' => $this->list->getPageName(),
                    'file' => $this->file->getArchiveName(),
                    'token' => $this->list->getUser()->getEditToken(
                        $this->file->getArchiveName() )
                ]
            );
        }
 
        return '<span class="history-deleted">' . $link . '</span>';
    }
 
    protected function getUserTools() {
        $uploader = $this->file->getUploader( File::FOR_THIS_USER, $this->list->getAuthority() );
        if ( $uploader ) {
            $link = Linker::userLink( $uploader->getId(), $uploader->getName() ) .
                Linker::userToolLinks( $uploader->getId(), $uploader->getName() );
            return $link;
        } else {
            $link = $this->list->msg( 'rev-deleted-user' )->escaped();
        }
        if ( $this->file->isDeleted( File::DELETED_USER ) ) {
            return '<span class="history-deleted">' . $link . '</span>';
        }
        return $link;
    }
 
    protected function getComment() {
        if ( $this->file->userCan( File::DELETED_COMMENT, $this->list->getAuthority() ) ) {
            $block = MediaWikiServices::getInstance()->getCommentFormatter()
                ->formatBlock( $this->file->getDescription() );
        } else {
            $block = ' ' . $this->list->msg( 'rev-deleted-comment' )->escaped();
        }
        if ( $this->file->isDeleted( File::DELETED_COMMENT ) ) {
            return "<span class=\"history-deleted\">$block</span>";
        }
 
        return $block;
    }
 
    public function getHTML() {
        $data =
            $this->list->msg( 'widthheight' )->numParams(
                $this->file->getWidth(),
                $this->file->getHeight() )->escaped() .
            ' (' . $this->list->msg( 'nbytes' )->numParams(
                $this->file->getSize() )->escaped() . ')';
 
        return '<li>' . $this->getLink() . ' ' . $this->getUserTools() . ' ' .
            $data . ' ' . $this->getComment() . '</li>';
    }
 
    public function getApiData( ApiResult $result ) {
        $file = $this->file;
        $user = $this->list->getUser();
        $ret = [
            'title' => $this->list->getPageName(),
            'archivename' => $file->getArchiveName(),
            'timestamp' => wfTimestamp( TS_ISO_8601, $file->getTimestamp() ),
            'width' => $file->getWidth(),
            'height' => $file->getHeight(),
            'size' => $file->getSize(),
            'userhidden' => (bool)$file->isDeleted( File::DELETED_USER ),
            'commenthidden' => (bool)$file->isDeleted( File::DELETED_COMMENT ),
            'contenthidden' => (bool)$this->isDeleted(),
        ];
        if ( !$this->isDeleted() ) {
            $ret += [
                'url' => $file->getUrl(),
            ];
        } elseif ( $this->canViewContent() ) {
            $ret += [
                'url' => SpecialPage::getTitleFor( 'Revisiondelete' )->getLinkURL(
                    [
                        'target' => $this->list->getPageName(),
                        'file' => $file->getArchiveName(),
                        'token' => $user->getEditToken( $file->getArchiveName() )
                    ]
                ),
            ];
        }
        $uploader = $file->getUploader( File::FOR_THIS_USER, $user );
        if ( $uploader ) {
            $ret += [
                'userid' => $uploader->getId(),
                'user' => $uploader->getName(),
            ];
        }
        $comment = $file->getDescription( File::FOR_THIS_USER, $user );
        if ( ( $comment ?? '' ) !== '' ) {
            $ret += [
                'comment' => $comment,
            ];
        }
 
        return $ret;
    }
 
    public function lock() {
        return $this->file->acquireFileLock();
    }
 
    public function unlock() {
        return $this->file->releaseFileLock();
    }
}