BlockListPager.php

Go to the documentation of this file.

<?php
use MediaWiki\Block\BlockActionInfo;
use MediaWiki\Block\BlockRestrictionStore;
use MediaWiki\Block\BlockUtils;
use MediaWiki\Block\Restriction\ActionRestriction;
use MediaWiki\Block\Restriction\NamespaceRestriction;
use MediaWiki\Block\Restriction\PageRestriction;
use MediaWiki\Block\Restriction\Restriction;
use MediaWiki\Cache\LinkBatchFactory;
use MediaWiki\SpecialPage\SpecialPageFactory;
use MediaWiki\User\UserIdentity;
use Wikimedia\IPUtils;
use Wikimedia\Rdbms\ILoadBalancer;
use Wikimedia\Rdbms\IResultWrapper;
 
class BlockListPager extends TablePager {
 
    protected $conds;
 
    protected $restrictions = [];
 
    private $linkBatchFactory;
 
    private $blockRestrictionStore;
 
    private $specialPageFactory;
 
    private $commentStore;
 
    private $blockUtils;
 
    private $blockActionInfo;
 
    public function __construct(
        $page,
        $conds,
        LinkBatchFactory $linkBatchFactory,
        BlockRestrictionStore $blockRestrictionStore,
        ILoadBalancer $loadBalancer,
        SpecialPageFactory $specialPageFactory,
        CommentStore $commentStore,
        BlockUtils $blockUtils,
        BlockActionInfo $blockActionInfo
    ) {
        $this->mDb = $loadBalancer->getConnectionRef( ILoadBalancer::DB_REPLICA );
        parent::__construct( $page->getContext(), $page->getLinkRenderer() );
        $this->conds = $conds;
        $this->mDefaultDirection = IndexPager::DIR_DESCENDING;
        $this->linkBatchFactory = $linkBatchFactory;
        $this->blockRestrictionStore = $blockRestrictionStore;
        $this->specialPageFactory = $specialPageFactory;
        $this->commentStore = $commentStore;
        $this->blockUtils = $blockUtils;
        $this->blockActionInfo = $blockActionInfo;
    }
 
    protected function getFieldNames() {
        static $headers = null;
 
        if ( $headers === null ) {
            $headers = [
                'ipb_timestamp' => 'blocklist-timestamp',
                'ipb_target' => 'blocklist-target',
                'ipb_expiry' => 'blocklist-expiry',
                'ipb_by' => 'blocklist-by',
                'ipb_params' => 'blocklist-params',
                'ipb_reason' => 'blocklist-reason',
            ];
            foreach ( $headers as $key => $val ) {
                $headers[$key] = $this->msg( $val )->text();
            }
        }
 
        return $headers;
    }
 
    public function formatValue( $name, $value ) {
        static $msg = null;
        if ( $msg === null ) {
            $keys = [
                'anononlyblock',
                'createaccountblock',
                'noautoblockblock',
                'emailblock',
                'blocklist-nousertalk',
                'unblocklink',
                'change-blocklink',
                'blocklist-editing',
                'blocklist-editing-sitewide',
            ];
 
            foreach ( $keys as $key ) {
                $msg[$key] = $this->msg( $key )->text();
            }
        }
        '@phan-var string[] $msg';
 
        $row = $this->mCurrentRow;
 
        $language = $this->getLanguage();
 
        $formatted = '';
 
        $linkRenderer = $this->getLinkRenderer();
 
        switch ( $name ) {
            case 'ipb_timestamp':
                $formatted = htmlspecialchars( $language->userTimeAndDate( $value, $this->getUser() ) );
                break;
 
            case 'ipb_target':
                if ( $row->ipb_auto ) {
                    $formatted = $this->msg( 'autoblockid', $row->ipb_id )->parse();
                } else {
                    list( $target, ) = $this->blockUtils->parseBlockTarget( $row->ipb_address );
 
                    if ( is_string( $target ) ) {
                        if ( IPUtils::isValidRange( $target ) ) {
                            $target = User::newFromName( $target, false );
                        } else {
                            $formatted = $target;
                        }
                    }
 
                    if ( $target instanceof UserIdentity ) {
                        $formatted = Linker::userLink( $target->getId(), $target->getName() );
                        $formatted .= Linker::userToolLinks(
                            $target->getId(),
                            $target->getName(),
                            false,
                            Linker::TOOL_LINKS_NOBLOCK
                        );
                    }
                }
                break;
 
            case 'ipb_expiry':
                $formatted = htmlspecialchars( $language->formatExpiry(
                    $value,
                    /* User preference timezone */true,
                    'infinity',
                    $this->getUser()
                ) );
                if ( $this->getAuthority()->isAllowed( 'block' ) ) {
                    $links = [];
                    if ( $row->ipb_auto ) {
                        $links[] = $linkRenderer->makeKnownLink(
                            $this->specialPageFactory->getTitleForAlias( 'Unblock' ),
                            $msg['unblocklink'],
                            [],
                            [ 'wpTarget' => "#{$row->ipb_id}" ]
                        );
                    } else {
                        $links[] = $linkRenderer->makeKnownLink(
                            $this->specialPageFactory->getTitleForAlias( 'Unblock/' . $row->ipb_address ),
                            $msg['unblocklink']
                        );
                        $links[] = $linkRenderer->makeKnownLink(
                            $this->specialPageFactory->getTitleForAlias( 'Block/' . $row->ipb_address ),
                            $msg['change-blocklink']
                        );
                    }
                    $formatted .= ' ' . Html::rawElement(
                        'span',
                        [ 'class' => 'mw-blocklist-actions' ],
                        $this->msg( 'parentheses' )->rawParams(
                            $language->pipeList( $links ) )->escaped()
                    );
                }
                if ( $value !== 'infinity' ) {
                    $timestamp = new MWTimestamp( $value );
                    $formatted .= '<br />' . $this->msg(
                        'ipb-blocklist-duration-left',
                        $language->formatDuration(
                            $timestamp->getTimestamp() - MWTimestamp::time(),
                            // reasonable output
                            [
                                'minutes',
                                'hours',
                                'days',
                                'years',
                            ]
                        )
                    )->escaped();
                }
                break;
 
            case 'ipb_by':
                $formatted = Linker::userLink( $value, $row->ipb_by_text );
                $formatted .= Linker::userToolLinks( $value, $row->ipb_by_text );
                break;
 
            case 'ipb_reason':
                $value = $this->commentStore->getComment( 'ipb_reason', $row )->text;
                $formatted = Linker::formatComment( $value );
                break;
 
            case 'ipb_params':
                $properties = [];
 
                if ( $row->ipb_sitewide ) {
                    $properties[] = htmlspecialchars( $msg['blocklist-editing-sitewide'] );
                }
 
                if ( !$row->ipb_sitewide && $this->restrictions ) {
                    $list = $this->getRestrictionListHTML( $row );
                    if ( $list ) {
                        $properties[] = htmlspecialchars( $msg['blocklist-editing'] ) . $list;
                    }
                }
 
                if ( $row->ipb_anon_only ) {
                    $properties[] = htmlspecialchars( $msg['anononlyblock'] );
                }
                if ( $row->ipb_create_account ) {
                    $properties[] = htmlspecialchars( $msg['createaccountblock'] );
                }
                if ( $row->ipb_user && !$row->ipb_enable_autoblock ) {
                    $properties[] = htmlspecialchars( $msg['noautoblockblock'] );
                }
 
                if ( $row->ipb_block_email ) {
                    $properties[] = htmlspecialchars( $msg['emailblock'] );
                }
 
                if ( !$row->ipb_allow_usertalk ) {
                    $properties[] = htmlspecialchars( $msg['blocklist-nousertalk'] );
                }
 
                $formatted = Html::rawElement(
                    'ul',
                    [],
                    implode( '', array_map( static function ( $prop ) {
                        return Html::rawElement(
                            'li',
                            [],
                            $prop
                        );
                    }, $properties ) )
                );
                break;
 
            default:
                $formatted = "Unable to format $name";
                break;
        }
 
        return $formatted;
    }
 
    private function getRestrictionListHTML( stdClass $row ) {
        $items = [];
        $linkRenderer = $this->getLinkRenderer();
 
        foreach ( $this->restrictions as $restriction ) {
            if ( $restriction->getBlockId() !== (int)$row->ipb_id ) {
                continue;
            }
 
            switch ( $restriction->getType() ) {
                case PageRestriction::TYPE:
                    '@phan-var PageRestriction $restriction';
                    if ( $restriction->getTitle() ) {
                        $items[$restriction->getType()][] = Html::rawElement(
                            'li',
                            [],
                            $linkRenderer->makeLink( $restriction->getTitle() )
                        );
                    }
                    break;
                case NamespaceRestriction::TYPE:
                    $text = $restriction->getValue() === NS_MAIN
                        ? $this->msg( 'blanknamespace' )->text()
                        : $this->getLanguage()->getFormattedNsText(
                            $restriction->getValue()
                        );
                    if ( $text ) {
                        $items[$restriction->getType()][] = Html::rawElement(
                            'li',
                            [],
                            $linkRenderer->makeLink(
                                $this->specialPageFactory->getTitleForAlias( 'Allpages' ),
                                $text,
                                [],
                                [
                                    'namespace' => $restriction->getValue()
                                ]
                            )
                        );
                    }
                    break;
                case ActionRestriction::TYPE:
                    $actionName = $this->blockActionInfo->getActionFromId( $restriction->getValue() );
                    $enablePartialActionBlocks = $this->getConfig()->get( 'EnablePartialActionBlocks' );
                    if ( $actionName && $enablePartialActionBlocks ) {
                        $items[$restriction->getType()][] = Html::rawElement(
                            'li',
                            [],
                            $this->msg( 'ipb-action-' .
                                $this->blockActionInfo->getActionFromId( $restriction->getValue() ) )->escaped()
                        );
                    }
                    break;
            }
        }
 
        if ( empty( $items ) ) {
            return '';
        }
 
        $sets = [];
        foreach ( $items as $key => $value ) {
            $sets[] = Html::rawElement(
                'li',
                [],
                $this->msg( 'blocklist-editing-' . $key ) . Html::rawElement(
                    'ul',
                    [],
                    implode( '', $value )
                )
            );
        }
 
        return Html::rawElement(
            'ul',
            [],
            implode( '', $sets )
        );
    }
 
    public function getQueryInfo() {
        $commentQuery = $this->commentStore->getJoin( 'ipb_reason' );
 
        $info = [
            'tables' => array_merge(
                [ 'ipblocks', 'ipblocks_by_actor' => 'actor' ],
                $commentQuery['tables']
            ),
            'fields' => [
                'ipb_id',
                'ipb_address',
                'ipb_user',
                'ipb_by' => 'ipblocks_by_actor.actor_user',
                'ipb_by_text' => 'ipblocks_by_actor.actor_name',
                'ipb_timestamp',
                'ipb_auto',
                'ipb_anon_only',
                'ipb_create_account',
                'ipb_enable_autoblock',
                'ipb_expiry',
                'ipb_range_start',
                'ipb_range_end',
                'ipb_deleted',
                'ipb_block_email',
                'ipb_allow_usertalk',
                'ipb_sitewide',
            ] + $commentQuery['fields'],
            'conds' => $this->conds,
            'join_conds' => [
                'ipblocks_by_actor' => [ 'JOIN', 'actor_id=ipb_by_actor' ]
            ] + $commentQuery['joins']
        ];
 
        # Filter out any expired blocks
        $db = $this->getDatabase();
        $info['conds'][] = 'ipb_expiry > ' . $db->addQuotes( $db->timestamp() );
 
        # Is the user allowed to see hidden blocks?
        if ( !$this->getAuthority()->isAllowed( 'hideuser' ) ) {
            $info['conds']['ipb_deleted'] = 0;
        }
 
        return $info;
    }
 
    public function getTotalAutoblocks() {
        $dbr = $this->getDatabase();
        return (int)$dbr->selectField( 'ipblocks', 'COUNT(*)',
            [
                'ipb_auto' => '1',
                'ipb_expiry >= ' . $dbr->addQuotes( $dbr->timestamp() ),
            ],
            __METHOD__
        );
    }
 
    protected function getTableClass() {
        return parent::getTableClass() . ' mw-blocklist';
    }
 
    public function getIndexField() {
        return [ [ 'ipb_timestamp', 'ipb_id' ] ];
    }
 
    public function getDefaultSort() {
        return '';
    }
 
    protected function isFieldSortable( $name ) {
        return false;
    }
 
    public function preprocessResults( $result ) {
        # Do a link batch query
        $lb = $this->linkBatchFactory->newLinkBatch();
        $lb->setCaller( __METHOD__ );
 
        $partialBlocks = [];
        foreach ( $result as $row ) {
            $lb->add( NS_USER, $row->ipb_address );
            $lb->add( NS_USER_TALK, $row->ipb_address );
 
            if ( $row->ipb_by ?? null ) {
                $lb->add( NS_USER, $row->ipb_by_text );
                $lb->add( NS_USER_TALK, $row->ipb_by_text );
            }
 
            if ( !$row->ipb_sitewide ) {
                $partialBlocks[] = $row->ipb_id;
            }
        }
 
        if ( $partialBlocks ) {
            // Mutations to the $row object are not persisted. The restrictions will
            // need be stored in a separate store.
            $this->restrictions = $this->blockRestrictionStore->loadByBlockId( $partialBlocks );
 
            foreach ( $this->restrictions as $restriction ) {
                if ( $restriction->getType() === PageRestriction::TYPE ) {
                    '@phan-var PageRestriction $restriction';
                    $title = $restriction->getTitle();
                    if ( $title ) {
                        $lb->addObj( $title );
                    }
                }
            }
        }
 
        $lb->execute();
    }
 
}