PageArchive.php

Go to the documentation of this file.

<?php
use MediaWiki\FileRepo\File\FileSelectQueryBuilder;
use MediaWiki\MediaWikiServices;
use MediaWiki\Page\UndeletePage;
use MediaWiki\Revision\RevisionRecord;
use MediaWiki\Status\Status;
use MediaWiki\Title\Title;
use MediaWiki\User\UserIdentity;
use Wikimedia\Rdbms\IReadableDatabase;
use Wikimedia\Rdbms\IResultWrapper;
use Wikimedia\Rdbms\SelectQueryBuilder;
 
class PageArchive {
 
    protected $title;
 
    protected $fileStatus;
 
    protected $revisionStatus;
 
    public function __construct( Title $title ) {
        $this->title = $title;
    }
 
    public static function listPagesBySearch( $term ) {
        $title = Title::newFromText( $term );
        if ( $title ) {
            $ns = $title->getNamespace();
            $termMain = $title->getText();
            $termDb = $title->getDBkey();
        } else {
            // Prolly won't work too good
            // @todo handle bare namespace names cleanly?
            $ns = 0;
            $termMain = $termDb = $term;
        }
 
        // Try search engine first
        $engine = MediaWikiServices::getInstance()->newSearchEngine();
        $engine->setLimitOffset( 100 );
        $engine->setNamespaces( [ $ns ] );
        $results = $engine->searchArchiveTitle( $termMain );
        if ( !$results->isOK() ) {
            $results = [];
        } else {
            $results = $results->getValue();
        }
 
        if ( !$results ) {
            // Fall back to regular prefix search
            return self::listPagesByPrefix( $term );
        }
 
        $dbr = MediaWikiServices::getInstance()->getDBLoadBalancerFactory()->getReplicaDatabase();
        $condTitles = array_unique( array_map( static function ( Title $t ) {
            return $t->getDBkey();
        }, $results ) );
        $conds = [
            'ar_namespace' => $ns,
            $dbr->makeList( [
                'ar_title' => $condTitles,
                'ar_title' . $dbr->buildLike( $termDb, $dbr->anyString() ),
            ], LIST_OR ),
        ];
 
        return self::listPages( $dbr, $conds );
    }
 
    public static function listPagesByPrefix( $prefix ) {
        $dbr = MediaWikiServices::getInstance()->getDBLoadBalancerFactory()->getReplicaDatabase();
 
        $title = Title::newFromText( $prefix );
        if ( $title ) {
            $ns = $title->getNamespace();
            $prefix = $title->getDBkey();
        } else {
            // Prolly won't work too good
            // @todo handle bare namespace names cleanly?
            $ns = 0;
        }
 
        $conds = [
            'ar_namespace' => $ns,
            'ar_title' . $dbr->buildLike( $prefix, $dbr->anyString() ),
        ];
 
        return self::listPages( $dbr, $conds );
    }
 
    protected static function listPages( IReadableDatabase $dbr, $condition ) {
        return $dbr->newSelectQueryBuilder()
            ->select( [ 'ar_namespace', 'ar_title', 'count' => 'COUNT(*)' ] )
            ->from( 'archive' )
            ->where( $condition )
            ->groupBy( [ 'ar_namespace', 'ar_title' ] )
            ->orderBy( [ 'ar_namespace', 'ar_title' ] )
            ->limit( 100 )
            ->caller( __METHOD__ )->fetchResultSet();
    }
 
    public function listRevisions() {
        wfDeprecated( __METHOD__, '1.38' );
        $lookup = MediaWikiServices::getInstance()->getArchivedRevisionLookup();
        return $lookup->listRevisions( $this->title );
    }
 
    public function listFiles() {
        if ( $this->title->getNamespace() !== NS_FILE ) {
            return null;
        }
 
        $dbr = MediaWikiServices::getInstance()->getDBLoadBalancerFactory()->getReplicaDatabase();
        $queryBuilder = FileSelectQueryBuilder::newForArchivedFile( $dbr );
        $queryBuilder->where( [ 'fa_name' => $this->title->getDBkey() ] )
            ->orderBy( 'fa_timestamp', SelectQueryBuilder::SORT_DESC );
        return $queryBuilder->caller( __METHOD__ )->fetchResultSet();
    }
 
    public function getRevisionRecordByTimestamp( $timestamp ) {
        wfDeprecated( __METHOD__, '1.38' );
        $lookup = MediaWikiServices::getInstance()->getArchivedRevisionLookup();
        return $lookup->getRevisionRecordByTimestamp( $this->title, $timestamp );
    }
 
    public function getArchivedRevisionRecord( int $revId ) {
        wfDeprecated( __METHOD__, '1.38' );
        $lookup = MediaWikiServices::getInstance()->getArchivedRevisionLookup();
        return $lookup->getArchivedRevisionRecord( $this->title, $revId );
    }
 
    public function getPreviousRevisionRecord( string $timestamp ) {
        wfDeprecated( __METHOD__, '1.38' );
        $lookup = MediaWikiServices::getInstance()->getArchivedRevisionLookup();
        return $lookup->getPreviousRevisionRecord( $this->title, $timestamp );
    }
 
    public function getLastRevisionId() {
        wfDeprecated( __METHOD__, '1.38' );
        $lookup = MediaWikiServices::getInstance()->getArchivedRevisionLookup();
        return $lookup->getLastRevisionId( $this->title );
    }
 
    public function isDeleted() {
        wfDeprecated( __METHOD__, '1.38' );
        $lookup = MediaWikiServices::getInstance()->getArchivedRevisionLookup();
        return $lookup->hasArchivedRevisions( $this->title );
    }
 
    public function undeleteAsUser(
        $timestamps,
        UserIdentity $user,
        $comment = '',
        $fileVersions = [],
        $unsuppress = false,
        $tags = null
    ) {
        $services = MediaWikiServices::getInstance();
        $page = $services->getWikiPageFactory()->newFromTitle( $this->title );
        $user = $services->getUserFactory()->newFromUserIdentity( $user );
        $up = $services->getUndeletePageFactory()->newUndeletePage( $page, $user );
        if ( is_string( $tags ) ) {
            $tags = [ $tags ];
        } elseif ( $tags === null ) {
            $tags = [];
        }
        $status = $up
            ->setUndeleteOnlyTimestamps( $timestamps )
            ->setUndeleteOnlyFileVersions( $fileVersions ?: [] )
            ->setUnsuppress( $unsuppress )
            ->setTags( $tags ?: [] )
            ->undeleteUnsafe( $comment );
        // BC with old return format
        if ( $status->isGood() ) {
            $restoredRevs = $status->getValue()[UndeletePage::REVISIONS_RESTORED];
            $restoredFiles = $status->getValue()[UndeletePage::FILES_RESTORED];
            if ( $restoredRevs === 0 && $restoredFiles === 0 ) {
                $ret = false;
            } else {
                $ret = [ $restoredRevs, $restoredFiles, $comment ];
            }
        } else {
            $ret = false;
        }
        $this->fileStatus = $up->getFileStatus();
        $this->revisionStatus = $up->getRevisionStatus();
        return $ret;
    }
 
    public function getFileStatus() {
        wfDeprecated( __METHOD__, '1.38' );
        return $this->fileStatus;
    }
 
    public function getRevisionStatus() {
        wfDeprecated( __METHOD__, '1.38' );
        return $this->revisionStatus;
    }
}