DeletedContribsPager.php

Go to the documentation of this file.

<?php
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\Linker\LinkRenderer;
use MediaWiki\Revision\RevisionFactory;
use MediaWiki\Revision\RevisionRecord;
use Wikimedia\Rdbms\FakeResultWrapper;
use Wikimedia\Rdbms\ILoadBalancer;
use Wikimedia\Rdbms\IResultWrapper;
 
class DeletedContribsPager extends ReverseChronologicalPager {
 
    public $mGroupByDate = true;
 
    public $messages;
 
    public $target;
 
    public $namespace = '';
 
    private $commentStore;
 
    private $hookRunner;
 
    private $revisionFactory;
 
    public function __construct(
        IContextSource $context,
        CommentStore $commentStore,
        HookContainer $hookContainer,
        LinkRenderer $linkRenderer,
        ILoadBalancer $loadBalancer,
        RevisionFactory $revisionFactory,
        $target,
        $namespace
    ) {
        // Set database before parent constructor to avoid setting it there with wfGetDB
        $this->mDb = $loadBalancer->getConnectionRef( ILoadBalancer::DB_REPLICA, 'contributions' );
        parent::__construct( $context, $linkRenderer );
        $msgs = [ 'deletionlog', 'undeleteviewlink', 'diff' ];
        foreach ( $msgs as $msg ) {
            $this->messages[$msg] = $this->msg( $msg )->text();
        }
        $this->target = $target;
        $this->namespace = $namespace;
        $this->hookRunner = new HookRunner( $hookContainer );
        $this->commentStore = $commentStore;
        $this->revisionFactory = $revisionFactory;
    }
 
    public function getDefaultQuery() {
        $query = parent::getDefaultQuery();
        $query['target'] = $this->target;
 
        return $query;
    }
 
    public function getQueryInfo() {
        $dbr = $this->getDatabase();
        $userCond = [ 'actor_name' => $this->target ];
        $conds = array_merge( $userCond, $this->getNamespaceCond() );
        // Paranoia: avoid brute force searches (T19792)
        if ( !$this->getAuthority()->isAllowed( 'deletedhistory' ) ) {
            $conds[] = $dbr->bitAnd( 'ar_deleted', RevisionRecord::DELETED_USER ) . ' = 0';
        } elseif ( !$this->getAuthority()->isAllowedAny( 'suppressrevision', 'viewsuppressed' ) ) {
            $conds[] = $dbr->bitAnd( 'ar_deleted', RevisionRecord::SUPPRESSED_USER ) .
                ' != ' . RevisionRecord::SUPPRESSED_USER;
        }
 
        $queryInfo = $this->revisionFactory->getArchiveQueryInfo();
        $queryInfo['conds'] = $conds;
        $queryInfo['options'] = [];
 
        // rename the "joins" field to "join_conds" as expected by the base class.
        $queryInfo['join_conds'] = $queryInfo['joins'];
        unset( $queryInfo['joins'] );
 
        ChangeTags::modifyDisplayQuery(
            $queryInfo['tables'],
            $queryInfo['fields'],
            $queryInfo['conds'],
            $queryInfo['join_conds'],
            $queryInfo['options'],
            ''
        );
 
        return $queryInfo;
    }
 
    public function reallyDoQuery( $offset, $limit, $order ) {
        $data = [ parent::reallyDoQuery( $offset, $limit, $order ) ];
 
        // This hook will allow extensions to add in additional queries, nearly
        // identical to ContribsPager::reallyDoQuery.
        $this->hookRunner->onDeletedContribsPager__reallyDoQuery(
            $data, $this, $offset, $limit, $order );
 
        $result = [];
 
        // loop all results and collect them in an array
        foreach ( $data as $query ) {
            foreach ( $query as $i => $row ) {
                // use index column as key, allowing us to easily sort in PHP
                $result[$row->{$this->getIndexField()} . "-$i"] = $row;
            }
        }
 
        // sort results
        if ( $order === self::QUERY_ASCENDING ) {
            ksort( $result );
        } else {
            krsort( $result );
        }
 
        // enforce limit
        $result = array_slice( $result, 0, $limit );
 
        // get rid of array keys
        $result = array_values( $result );
 
        return new FakeResultWrapper( $result );
    }
 
    protected function getExtraSortFields() {
        return [ 'ar_id' ];
    }
 
    public function getIndexField() {
        return 'ar_timestamp';
    }
 
    public function getTarget() {
        return $this->target;
    }
 
    public function getNamespace() {
        return $this->namespace;
    }
 
    protected function getStartBody() {
        return "<section class='mw-pager-body'>\n";
    }
 
    protected function getEndBody() {
        return "</section>\n";
    }
 
    private function getNamespaceCond() {
        if ( $this->namespace !== '' ) {
            return [ 'ar_namespace' => (int)$this->namespace ];
        } else {
            return [];
        }
    }
 
    public function formatRow( $row ) {
        $ret = '';
        $classes = [];
        $attribs = [];
 
        if ( $this->revisionFactory->isRevisionRow( $row, 'archive' ) ) {
            $revRecord = $this->revisionFactory->newRevisionFromArchiveRow( $row );
            $revId = $revRecord->getId();
            if ( $revId ) {
                $attribs['data-mw-revid'] = $revId;
                [ $ret, $classes ] = $this->formatRevisionRow( $row );
            }
        }
 
        // Let extensions add data
        $this->hookRunner->onDeletedContributionsLineEnding(
            $this, $ret, $row, $classes, $attribs );
        $attribs = array_filter( $attribs,
            [ Sanitizer::class, 'isReservedDataAttribute' ],
            ARRAY_FILTER_USE_KEY
        );
 
        if ( $classes === [] && $attribs === [] && $ret === '' ) {
            wfDebug( "Dropping Special:DeletedContribution row that could not be formatted" );
            $ret = "<!-- Could not format Special:DeletedContribution row. -->\n";
        } else {
            $attribs['class'] = $classes;
            $ret = Html::rawElement( 'li', $attribs, $ret ) . "\n";
        }
 
        return $ret;
    }
 
    private function formatRevisionRow( $row ) {
        $page = Title::makeTitle( $row->ar_namespace, $row->ar_title );
 
        $linkRenderer = $this->getLinkRenderer();
 
        $revRecord = $this->revisionFactory->newRevisionFromArchiveRow(
                $row,
                RevisionFactory::READ_NORMAL,
                $page
            );
 
        $undelete = SpecialPage::getTitleFor( 'Undelete' );
 
        $logs = SpecialPage::getTitleFor( 'Log' );
        $dellog = $linkRenderer->makeKnownLink(
            $logs,
            $this->messages['deletionlog'],
            [],
            [
                'type' => 'delete',
                'page' => $page->getPrefixedText()
            ]
        );
 
        $reviewlink = $linkRenderer->makeKnownLink(
            SpecialPage::getTitleFor( 'Undelete', $page->getPrefixedDBkey() ),
            $this->messages['undeleteviewlink']
        );
 
        $user = $this->getUser();
 
        if ( $this->getAuthority()->isAllowed( 'deletedtext' ) ) {
            $last = $linkRenderer->makeKnownLink(
                $undelete,
                $this->messages['diff'],
                [],
                [
                    'target' => $page->getPrefixedText(),
                    'timestamp' => $revRecord->getTimestamp(),
                    'diff' => 'prev'
                ]
            );
        } else {
            $last = htmlspecialchars( $this->messages['diff'] );
        }
 
        $comment = Linker::revComment( $revRecord );
        $date = $this->getLanguage()->userTimeAndDate( $revRecord->getTimestamp(), $user );
 
        if ( !$this->getAuthority()->isAllowed( 'undelete' ) ||
            !$revRecord->userCan( RevisionRecord::DELETED_TEXT, $this->getAuthority() )
        ) {
            $link = htmlspecialchars( $date ); // unusable link
        } else {
            $link = $linkRenderer->makeKnownLink(
                $undelete,
                $date,
                [ 'class' => 'mw-changeslist-date' ],
                [
                    'target' => $page->getPrefixedText(),
                    'timestamp' => $revRecord->getTimestamp()
                ]
            );
        }
        // Style deleted items
        if ( $revRecord->isDeleted( RevisionRecord::DELETED_TEXT ) ) {
            $class = Linker::getRevisionDeletedClass( $revRecord );
            $link = '<span class="' . $class . '">' . $link . '</span>';
        }
 
        $pagelink = $linkRenderer->makeLink(
            $page,
            null,
            [ 'class' => 'mw-changeslist-title' ]
        );
 
        if ( $revRecord->isMinor() ) {
            $mflag = ChangesList::flag( 'minor' );
        } else {
            $mflag = '';
        }
 
        // Revision delete link
        $del = Linker::getRevDeleteLink( $user, $revRecord, $page );
        if ( $del ) {
            $del .= ' ';
        }
 
        $tools = Html::rawElement(
            'span',
            [ 'class' => 'mw-deletedcontribs-tools' ],
            $this->msg( 'parentheses' )->rawParams( $this->getLanguage()->pipeList(
                [ $last, $dellog, $reviewlink ] ) )->escaped()
        );
 
        // Tags, if any.
        [ $tagSummary, $classes ] = ChangeTags::formatSummaryRow(
            $row->ts_tags,
            'deletedcontributions',
            $this->getContext()
        );
 
        $separator = '<span class="mw-changeslist-separator">. .</span>';
        $ret = "{$del}{$link} {$tools} {$separator} {$mflag} {$pagelink} {$comment} {$tagSummary}";
 
        # Denote if username is redacted for this edit
        if ( $revRecord->isDeleted( RevisionRecord::DELETED_USER ) ) {
            $ret .= " <strong>" . $this->msg( 'rev-deleted-user-contribs' )->escaped() . "</strong>";
        }
 
        return [ $ret, $classes ];
    }
}