RevDelRevisionList.php

Go to the documentation of this file.

<?php
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\MediaWikiServices;
use MediaWiki\Page\PageIdentity;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Revision\RevisionStore;
use MediaWiki\Status\Status;
use MediaWiki\Title\Title;
use Wikimedia\Rdbms\FakeResultWrapper;
use Wikimedia\Rdbms\IDatabase;
use Wikimedia\Rdbms\IResultWrapper;
use Wikimedia\Rdbms\LBFactory;
 
class RevDelRevisionList extends RevDelList {
 
    private $lbFactory;
 
    private $hookRunner;
 
    private $htmlCacheUpdater;
 
    private $revisionStore;
 
    public $currentRevId;
 
    public function __construct(
        IContextSource $context,
        PageIdentity $page,
        array $ids,
        LBFactory $lbFactory,
        HookContainer $hookContainer,
        HtmlCacheUpdater $htmlCacheUpdater,
        RevisionStore $revisionStore
    ) {
        parent::__construct( $context, $page, $ids, $lbFactory );
        $this->lbFactory = $lbFactory;
        $this->hookRunner = new HookRunner( $hookContainer );
        $this->htmlCacheUpdater = $htmlCacheUpdater;
        $this->revisionStore = $revisionStore;
    }
 
    public function getType() {
        return 'revision';
    }
 
    public static function getRelationType() {
        return 'rev_id';
    }
 
    public static function getRestriction() {
        return 'deleterevision';
    }
 
    public static function getRevdelConstant() {
        return RevisionRecord::DELETED_TEXT;
    }
 
    public static function suggestTarget( $target, array $ids ) {
        $revisionRecord = MediaWikiServices::getInstance()
            ->getRevisionLookup()
            ->getRevisionById( $ids[0] );
 
        if ( $revisionRecord ) {
            return Title::newFromLinkTarget( $revisionRecord->getPageAsLinkTarget() );
        }
        return $target;
    }
 
    public function doQuery( $db ) {
        $ids = array_map( 'intval', $this->ids );
        $revQuery = $this->revisionStore->getQueryInfo( [ 'page', 'user' ] );
        $queryInfo = [
            'tables' => $revQuery['tables'],
            'fields' => $revQuery['fields'],
            'conds' => [
                'rev_page' => $this->page->getId(),
                'rev_id' => $ids,
            ],
            'options' => [
                'ORDER BY' => 'rev_id DESC',
                'USE INDEX' => [ 'revision' => 'PRIMARY' ] // workaround for MySQL bug (T104313)
            ],
            'join_conds' => $revQuery['joins'],
        ];
        ChangeTags::modifyDisplayQuery(
            $queryInfo['tables'],
            $queryInfo['fields'],
            $queryInfo['conds'],
            $queryInfo['join_conds'],
            $queryInfo['options'],
            ''
        );
 
        $live = $db->select(
            $queryInfo['tables'],
            $queryInfo['fields'],
            $queryInfo['conds'],
            __METHOD__,
            $queryInfo['options'],
            $queryInfo['join_conds']
        );
        if ( $live->numRows() >= count( $ids ) ) {
            // All requested revisions are live, keeps things simple!
            return $live;
        }
 
        $arQuery = $this->revisionStore->getArchiveQueryInfo();
        $archiveQueryInfo = [
            'tables' => $arQuery['tables'],
            'fields' => $arQuery['fields'],
            'conds' => [
                'ar_rev_id' => $ids,
            ],
            'options' => [ 'ORDER BY' => 'ar_rev_id DESC' ],
            'join_conds' => $arQuery['joins'],
        ];
 
        ChangeTags::modifyDisplayQuery(
            $archiveQueryInfo['tables'],
            $archiveQueryInfo['fields'],
            $archiveQueryInfo['conds'],
            $archiveQueryInfo['join_conds'],
            $archiveQueryInfo['options'],
            ''
        );
 
        // Check if any requested revisions are available fully deleted.
        $archived = $db->select(
            $archiveQueryInfo['tables'],
            $archiveQueryInfo['fields'],
            $archiveQueryInfo['conds'],
            __METHOD__,
            $archiveQueryInfo['options'],
            $archiveQueryInfo['join_conds']
        );
 
        if ( $archived->numRows() == 0 ) {
            return $live;
        } elseif ( $live->numRows() == 0 ) {
            return $archived;
        } else {
            // Combine the two! Whee
            $rows = [];
            foreach ( $live as $row ) {
                $rows[$row->rev_id] = $row;
            }
            foreach ( $archived as $row ) {
                $rows[$row->ar_rev_id] = $row;
            }
            krsort( $rows );
            return new FakeResultWrapper( array_values( $rows ) );
        }
    }
 
    public function newItem( $row ) {
        if ( isset( $row->rev_id ) ) {
            return new RevDelRevisionItem( $this, $row );
        } elseif ( isset( $row->ar_rev_id ) ) {
            return new RevDelArchivedRevisionItem( $this, $row );
        } else {
            // This shouldn't happen. :)
            throw new InvalidArgumentException( 'Invalid row type in RevDelRevisionList' );
        }
    }
 
    public function getCurrent() {
        if ( $this->currentRevId === null ) {
            $dbw = $this->lbFactory->getPrimaryDatabase();
            $this->currentRevId = $dbw->newSelectQueryBuilder()
                ->select( 'page_latest' )
                ->from( 'page' )
                ->where( [ 'page_namespace' => $this->page->getNamespace(), 'page_title' => $this->page->getDBkey() ] )
                ->caller( __METHOD__ )->fetchField();
        }
        return $this->currentRevId;
    }
 
    public function doPreCommitUpdates() {
        Title::newFromPageIdentity( $this->page )->invalidateCache();
        return Status::newGood();
    }
 
    public function doPostCommitUpdates( array $visibilityChangeMap ) {
        $this->htmlCacheUpdater->purgeTitleUrls(
            $this->page,
            HtmlCacheUpdater::PURGE_INTENT_TXROUND_REFLECTED
        );
        // Extensions that require referencing previous revisions may need this
        $this->hookRunner->onArticleRevisionVisibilitySet(
            Title::newFromPageIdentity( $this->page ),
            $this->ids,
            $visibilityChangeMap
        );
 
        return Status::newGood();
    }
}