DeletedContribsPager.php

Go to the documentation of this file.

<?php
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\Linker\LinkRenderer;
use MediaWiki\Permissions\PermissionManager;
use MediaWiki\Revision\RevisionFactory;
use MediaWiki\Revision\RevisionRecord;
use Wikimedia\Rdbms\FakeResultWrapper;
use Wikimedia\Rdbms\ILoadBalancer;
use Wikimedia\Rdbms\IResultWrapper;
 
class DeletedContribsPager extends IndexPager {
 
    public $mDefaultDirection = IndexPager::DIR_DESCENDING;
 
    public $messages;
 
    public $target;
 
    public $namespace = '';
 
    protected $mNavigationBar;
 
    private $hookRunner;
 
    private $permissionManager;
 
    private $commentStore;
 
    private $actorMigration;
 
    private $revisionFactory;
 
    public function __construct(
        IContextSource $context,
        $target,
        $namespace,
        LinkRenderer $linkRenderer,
        HookContainer $hookContainer,
        PermissionManager $permissionManager,
        ILoadBalancer $loadBalancer,
        CommentStore $commentStore,
        ActorMigration $actorMigration,
        RevisionFactory $revisionFactory
    ) {
        // 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->permissionManager = $permissionManager;
        $this->commentStore = $commentStore;
        $this->actorMigration = $actorMigration;
        $this->revisionFactory = $revisionFactory;
    }
 
    public function getDefaultQuery() {
        $query = parent::getDefaultQuery();
        $query['target'] = $this->target;
 
        return $query;
    }
 
    public function getQueryInfo() {
        $dbr = $this->getDatabase();
        $userCond = [
            // ->getJoin() below takes care of any joins needed
            $this->actorMigration->getWhere(
                $dbr, 'ar_user', User::newFromName( $this->target, false ), false
            )['conds']
        ];
        $conds = array_merge( $userCond, $this->getNamespaceCond() );
        $user = $this->getUser();
        // Paranoia: avoid brute force searches (T19792)
        if ( !$this->permissionManager->userHasRight( $user, 'deletedhistory' ) ) {
            $conds[] = $dbr->bitAnd( 'ar_deleted', RevisionRecord::DELETED_USER ) . ' = 0';
        } elseif ( !$this->permissionManager->userHasAnyRight( $user, 'suppressrevision', 'viewsuppressed' ) ) {
            $conds[] = $dbr->bitAnd( 'ar_deleted', RevisionRecord::SUPPRESSED_USER ) .
                ' != ' . RevisionRecord::SUPPRESSED_USER;
        }
 
        $commentQuery = $this->commentStore->getJoin( 'ar_comment' );
        $actorQuery = $this->actorMigration->getJoin( 'ar_user' );
 
        return [
            'tables' => [ 'archive' ] + $commentQuery['tables'] + $actorQuery['tables'],
            'fields' => [
                'ar_rev_id', 'ar_id', 'ar_namespace', 'ar_title', 'ar_timestamp',
                'ar_minor_edit', 'ar_deleted'
            ] + $commentQuery['fields'] + $actorQuery['fields'],
            'conds' => $conds,
            'options' => [],
            'join_conds' => $commentQuery['joins'] + $actorQuery['joins'],
        ];
    }
 
    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 );
    }
 
    public function getIndexField() {
        return 'ar_timestamp';
    }
 
    public function getTarget() {
        return $this->target;
    }
 
    public function getNamespace() {
        return $this->namespace;
    }
 
    protected function getStartBody() {
        return "<ul>\n";
    }
 
    protected function getEndBody() {
        return "</ul>\n";
    }
 
    public function getNavigationBar() {
        if ( isset( $this->mNavigationBar ) ) {
            return $this->mNavigationBar;
        }
 
        $linkTexts = [
            'prev' => $this->msg( 'pager-newer-n' )->numParams( $this->mLimit )->escaped(),
            'next' => $this->msg( 'pager-older-n' )->numParams( $this->mLimit )->escaped(),
            'first' => $this->msg( 'histlast' )->escaped(),
            'last' => $this->msg( 'histfirst' )->escaped()
        ];
 
        $pagingLinks = $this->getPagingLinks( $linkTexts );
        $limitLinks = $this->getLimitLinks();
        $lang = $this->getLanguage();
        $limits = $lang->pipeList( $limitLinks );
 
        $firstLast = $lang->pipeList( [ $pagingLinks['first'], $pagingLinks['last'] ] );
        $firstLast = $this->msg( 'parentheses' )->rawParams( $firstLast )->escaped();
        $prevNext = $this->msg( 'viewprevnext' )
            ->rawParams(
                $pagingLinks['prev'],
                $pagingLinks['next'],
                $limits
            )->escaped();
        $separator = $this->msg( 'word-separator' )->escaped();
        $this->mNavigationBar = $firstLast . $separator . $prevNext;
 
        return $this->mNavigationBar;
    }
 
    private function getNamespaceCond() {
        if ( $this->namespace !== '' ) {
            return [ 'ar_namespace' => (int)$this->namespace ];
        } else {
            return [];
        }
    }
 
    public function formatRow( $row ) {
        $ret = '';
        $classes = [];
        $attribs = [];
 
        /*
         * There may be more than just revision rows. To make sure that we'll only be processing
         * revisions here, let's _try_ to build a revision out of our row (without displaying
         * notices though) and then trying to grab data from the built object. If we succeed,
         * we're definitely dealing with revision data and we may proceed, if not, we'll leave it
         * to extensions to subscribe to the hook to parse the row.
         */
        Wikimedia\suppressWarnings();
        try {
            $revRecord = $this->revisionFactory->newRevisionFromArchiveRow( $row );
            $validRevision = (bool)$revRecord->getId();
        } catch ( Exception $e ) {
            $validRevision = false;
        }
        Wikimedia\restoreWarnings();
 
        if ( $validRevision ) {
            $attribs['data-mw-revid'] = $revRecord->getId();
            $ret = $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->permissionManager->userHasRight( $user, '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->permissionManager->userHasRight( $user, 'undelete' ) ||
             !RevisionRecord::userCanBitfield(
                $revRecord->getVisibility(),
                RevisionRecord::DELETED_TEXT,
                $user
            )
        ) {
            $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 ) ) {
            $link = '<span class="history-deleted">' . $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()
        );
 
        $separator = '<span class="mw-changeslist-separator">. .</span>';
        $ret = "{$del}{$link} {$tools} {$separator} {$mflag} {$pagelink} {$comment}";
 
        # 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;
    }
}