SpecialDeletedContributions.php

Go to the documentation of this file.

<?php
use MediaWiki\Block\DatabaseBlock;
use MediaWiki\Permissions\PermissionManager;
use MediaWiki\Revision\RevisionFactory;
use MediaWiki\User\UserNamePrefixSearch;
use MediaWiki\User\UserNameUtils;
use Wikimedia\IPUtils;
use Wikimedia\Rdbms\ILoadBalancer;
 
class SpecialDeletedContributions extends SpecialPage {
    protected $mOpts;
 
    private $permissionManager;
 
    private $loadBalancer;
 
    private $commentStore;
 
    private $actorMigration;
 
    private $revisionFactory;
 
    private $namespaceInfo;
 
    private $userNameUtils;
 
    private $userNamePrefixSearch;
 
    public function __construct(
        PermissionManager $permissionManager,
        ILoadBalancer $loadBalancer,
        CommentStore $commentStore,
        ActorMigration $actorMigration,
        RevisionFactory $revisionFactory,
        NamespaceInfo $namespaceInfo,
        UserNameUtils $userNameUtils,
        UserNamePrefixSearch $userNamePrefixSearch
    ) {
        parent::__construct( 'DeletedContributions', 'deletedhistory' );
        $this->permissionManager = $permissionManager;
        $this->loadBalancer = $loadBalancer;
        $this->commentStore = $commentStore;
        $this->actorMigration = $actorMigration;
        $this->revisionFactory = $revisionFactory;
        $this->namespaceInfo = $namespaceInfo;
        $this->userNameUtils = $userNameUtils;
        $this->userNamePrefixSearch = $userNamePrefixSearch;
    }
 
    public function execute( $par ) {
        $this->setHeaders();
        $this->outputHeader();
        $this->checkPermissions();
        $this->addHelpLink( 'Help:User contributions' );
 
        $opts = new FormOptions();
 
        $opts->add( 'target', '' );
        $opts->add( 'namespace', '' );
        $opts->add( 'limit', 20 );
 
        $opts->fetchValuesFromRequest( $this->getRequest() );
        $opts->validateIntBounds( 'limit', 0, $this->getConfig()->get( 'QueryPageDefaultLimit' ) );
 
        if ( $par !== null ) {
            // Beautify the username
            $par = $this->userNameUtils->getCanonical( $par, UserNameUtils::RIGOR_NONE );
            $opts->setValue( 'target', (string)$par );
        }
 
        $ns = $opts->getValue( 'namespace' );
        if ( $ns !== null && $ns !== '' ) {
            $opts->setValue( 'namespace', intval( $ns ) );
        }
 
        $this->mOpts = $opts;
 
        $target = trim( $opts->getValue( 'target' ) );
        if ( !strlen( $target ) ) {
            $this->getForm();
 
            return;
        }
 
        $userObj = User::newFromName( $target, false );
        if ( !$userObj ) {
            $this->getForm();
 
            return;
        }
        $this->getSkin()->setRelevantUser( $userObj );
 
        $target = $userObj->getName();
 
        $out = $this->getOutput();
        $out->addSubtitle( $this->getSubTitle( $userObj ) );
        $out->setHTMLTitle( $this->msg(
            'pagetitle',
            $this->msg( 'deletedcontributions-title', $target )->plain()
        )->inContentLanguage() );
 
        $this->getForm();
 
        $pager = new DeletedContribsPager(
            $this->getContext(),
            $target,
            $opts->getValue( 'namespace' ),
            $this->getLinkRenderer(),
            $this->getHookContainer(),
            $this->permissionManager,
            $this->loadBalancer,
            $this->commentStore,
            $this->actorMigration,
            $this->revisionFactory
        );
        if ( !$pager->getNumRows() ) {
            $out->addWikiMsg( 'nocontribs' );
 
            return;
        }
 
        # Show a message about replica DB lag, if applicable
        $lag = $pager->getDatabase()->getSessionLagStatus()['lag'];
        if ( $lag > 0 ) {
            $out->showLagWarning( $lag );
        }
 
        $out->addHTML(
            '<p>' . $pager->getNavigationBar() . '</p>' .
                $pager->getBody() .
                '<p>' . $pager->getNavigationBar() . '</p>' );
 
        # If there were contributions, and it was a valid user or IP, show
        # the appropriate "footer" message - WHOIS tools, etc.
        $message = IPUtils::isIPAddress( $target ) ?
            'sp-contributions-footer-anon' :
            'sp-contributions-footer';
 
        if ( !$this->msg( $message )->isDisabled() ) {
            $out->wrapWikiMsg(
                "<div class='mw-contributions-footer'>\n$1\n</div>",
                [ $message, $target ]
            );
        }
    }
 
    private function getSubTitle( $userObj ) {
        $linkRenderer = $this->getLinkRenderer();
        if ( $userObj->isAnon() ) {
            $user = htmlspecialchars( $userObj->getName() );
        } else {
            $user = $linkRenderer->makeLink( $userObj->getUserPage(), $userObj->getName() );
        }
        $links = '';
        $nt = $userObj->getUserPage();
        $talk = $nt->getTalkPage();
        if ( $talk ) {
            $tools = SpecialContributions::getUserLinks(
                $this,
                $userObj,
                $this->permissionManager,
                $this->getHookRunner()
            );
 
            $contributionsLink = $linkRenderer->makeKnownLink(
                SpecialPage::getTitleFor( 'Contributions', $nt->getDBkey() ),
                $this->msg( 'sp-deletedcontributions-contribs' )->text()
            );
            if ( isset( $tools['deletedcontribs'] ) ) {
                // Swap out the deletedcontribs link for our contribs one
                $tools = wfArrayInsertAfter(
                    $tools, [ 'contribs' => $contributionsLink ], 'deletedcontribs' );
                unset( $tools['deletedcontribs'] );
            } else {
                $tools['contribs'] = $contributionsLink;
            }
 
            $links = $this->getLanguage()->pipeList( $tools );
 
            // Show a note if the user is blocked and display the last block log entry.
            $block = DatabaseBlock::newFromTarget( $userObj, $userObj );
            if ( $block !== null && $block->getType() != DatabaseBlock::TYPE_AUTO ) {
                if ( $block->getType() == DatabaseBlock::TYPE_RANGE ) {
                    $nt = $this->namespaceInfo->getCanonicalName( NS_USER ) . ':' . $block->getTarget();
                }
 
                // LogEventsList::showLogExtract() wants the first parameter by ref
                $out = $this->getOutput();
                LogEventsList::showLogExtract(
                    $out,
                    'block',
                    $nt,
                    '',
                    [
                        'lim' => 1,
                        'showIfEmpty' => false,
                        'msgKey' => [
                            'sp-contributions-blocked-notice',
                            $userObj->getName() # Support GENDER in 'sp-contributions-blocked-notice'
                        ],
                        'offset' => '' # don't use $this->getRequest() parameter offset
                    ]
                );
            }
        }
 
        return $this->msg( 'contribsub2' )->rawParams( $user, $links )->params( $userObj->getName() );
    }
 
    private function getForm() {
        $opts = $this->mOpts;
 
        $formDescriptor = [
            'target' => [
                'type' => 'user',
                'name' => 'target',
                'label-message' => 'sp-contributions-username',
                'default' => $opts->getValue( 'target' ),
                'ipallowed' => true,
            ],
 
            'namespace' => [
                'type' => 'namespaceselect',
                'name' => 'namespace',
                'label-message' => 'namespace',
                'all' => '',
            ],
        ];
 
        HTMLForm::factory( 'ooui', $formDescriptor, $this->getContext() )
            ->setWrapperLegendMsg( 'sp-contributions-search' )
            ->setSubmitTextMsg( 'sp-contributions-submit' )
            // prevent setting subpage and 'target' parameter at the same time
            ->setAction( $this->getPageTitle()->getLocalURL() )
            ->setMethod( 'get' )
            ->prepareForm()
            ->displayForm( false );
    }
 
    public function prefixSearchSubpages( $search, $limit, $offset ) {
        $search = $this->userNameUtils->getCanonical( $search );
        if ( !$search ) {
            // No prefix suggestion for invalid user
            return [];
        }
        // Autocomplete subpage as user list - public to allow caching
        return $this->userNamePrefixSearch
            ->search( UserNamePrefixSearch::AUDIENCE_PUBLIC, $search, $limit, $offset );
    }
 
    protected function getGroupName() {
        return 'users';
    }
}