BlockListPager.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Specials\Pager;
 
use MediaWiki\Block\BlockActionInfo;
use MediaWiki\Block\BlockRestrictionStore;
use MediaWiki\Block\BlockTargetFactory;
use MediaWiki\Block\BlockTargetWithUserPage;
use MediaWiki\Block\HideUserUtils;
use MediaWiki\Block\RangeBlockTarget;
use MediaWiki\Block\Restriction\ActionRestriction;
use MediaWiki\Block\Restriction\NamespaceRestriction;
use MediaWiki\Block\Restriction\PageRestriction;
use MediaWiki\Block\Restriction\Restriction;
use MediaWiki\CommentFormatter\RowCommentFormatter;
use MediaWiki\CommentStore\CommentStore;
use MediaWiki\Context\IContextSource;
use MediaWiki\Html\Html;
use MediaWiki\Linker\Linker;
use MediaWiki\Linker\LinkRenderer;
use MediaWiki\MainConfigNames;
use MediaWiki\Page\LinkBatchFactory;
use MediaWiki\Pager\IndexPager;
use MediaWiki\Pager\TablePager;
use MediaWiki\SpecialPage\SpecialPageFactory;
use MediaWiki\User\UserIdentityValue;
use MediaWiki\Utils\MWTimestamp;
use stdClass;
use Wikimedia\Rdbms\IConnectionProvider;
use Wikimedia\Rdbms\IResultWrapper;
use Wikimedia\Timestamp\TimestampFormat as TS;
 
class BlockListPager extends TablePager {
 
    protected array $restrictions = [];
 
    private array $formattedComments = [];
 
    private array $messages = [];
 
    private array $fieldNames = [];
 
    public function __construct(
        IContextSource $context,
        private readonly BlockActionInfo $blockActionInfo,
        private readonly BlockRestrictionStore $blockRestrictionStore,
        private readonly BlockTargetFactory $blockTargetFactory,
        private readonly HideUserUtils $hideUserUtils,
        private readonly CommentStore $commentStore,
        private readonly LinkBatchFactory $linkBatchFactory,
        LinkRenderer $linkRenderer,
        IConnectionProvider $dbProvider,
        private readonly RowCommentFormatter $rowCommentFormatter,
        private readonly SpecialPageFactory $specialPageFactory,
        protected array $conds,
    ) {
        // Set database before parent constructor to avoid setting it there
        $this->mDb = $dbProvider->getReplicaDatabase();
 
        parent::__construct( $context, $linkRenderer );
 
        $this->mDefaultDirection = IndexPager::DIR_DESCENDING;
    }
 
    protected function getFieldNames() {
        if ( $this->fieldNames === [] ) {
            $this->fieldNames = [
                'bl_timestamp' => 'blocklist-timestamp',
                'target' => 'blocklist-target',
                'bl_expiry' => 'blocklist-expiry',
                'bl_by' => 'blocklist-by',
                'params' => 'blocklist-params',
                'bl_reason' => 'blocklist-reason',
            ];
            foreach ( $this->fieldNames as $key => $val ) {
                $this->fieldNames[$key] = $this->msg( $val )->text();
            }
        }
 
        return $this->fieldNames;
    }
 
    public function formatValue( $name, $value ) {
        if ( $this->messages === [] ) {
            $keys = [
                'anononlyblock',
                'blanknamespace',
                'createaccountblock',
                'noautoblockblock',
                'emailblock',
                'blocklist-nousertalk',
                'unblocklink',
                'remove-blocklink',
                'change-blocklink',
                'blocklist-editing',
                'blocklist-editing-sitewide',
                'blocklist-hidden-param',
                'blocklist-hidden-placeholder',
                'blocklist-block-hidden',
            ];
 
            foreach ( $keys as $key ) {
                $this->messages[$key] = $this->msg( $key )->text();
            }
        }
 
        $row = $this->mCurrentRow;
 
        $language = $this->getLanguage();
 
        $linkRenderer = $this->getLinkRenderer();
 
        switch ( $name ) {
            case 'bl_timestamp':
                // Link the timestamp to the block ID. This allows users without permissions to change blocks
                // to be able to generate a link to a specific block.
                $formatted = $linkRenderer->makeKnownLink(
                    $this->specialPageFactory->getTitleForAlias( 'BlockList' ),
                    $language->userTimeAndDate( $value, $this->getUser() ),
                    [],
                    [ 'wpTarget' => "#{$row->bl_id}" ],
                );
                break;
 
            case 'target':
                $formatted = $this->formatTarget( $row );
                break;
 
            case 'bl_expiry':
                $formatted = htmlspecialchars( $language->formatExpiry(
                    $value,
                    /* User preference timezone */true,
                    'infinity',
                    $this->getUser()
                ) );
                if ( $this->getAuthority()->isAllowed( 'block' ) ) {
                    $links = $this->getBlockChangeLinks( $row );
                    $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->formatDurationBetweenTimestamps(
                            (int)$timestamp->getTimestamp( TS::UNIX ),
                            MWTimestamp::time(),
                            4
                        )
                    )->escaped();
                }
                break;
 
            case 'bl_by':
                $formatted = Linker::userLink( (int)$value, $row->bl_by_text );
                $formatted .= Linker::userToolLinks( (int)$value, $row->bl_by_text );
                break;
 
            case 'bl_reason':
                $formatted = $this->formattedComments[$this->getResultOffset()];
                break;
 
            case 'params':
                $properties = [];
 
                if ( intval( $row->bl_deleted ) === 1 ) {
                    $properties[] = htmlspecialchars( $this->messages['blocklist-hidden-param'] );
                } elseif ( intval( $row->bl_deleted ) === 2 ) {
                    $properties[] = htmlspecialchars( $this->messages['blocklist-block-hidden'] );
                }
                if ( $row->bl_sitewide ) {
                    $properties[] = htmlspecialchars( $this->messages['blocklist-editing-sitewide'] );
                }
 
                if ( !$row->bl_sitewide && $this->restrictions ) {
                    $list = $this->getRestrictionListHTML( $row );
                    if ( $list ) {
                        $properties[] = htmlspecialchars( $this->messages['blocklist-editing'] ) . $list;
                    }
                }
 
                if ( $row->bl_anon_only ) {
                    $properties[] = htmlspecialchars( $this->messages['anononlyblock'] );
                }
                if ( $row->bl_create_account ) {
                    $properties[] = htmlspecialchars( $this->messages['createaccountblock'] );
                }
                if ( $row->bt_user && !$row->bl_enable_autoblock ) {
                    $properties[] = htmlspecialchars( $this->messages['noautoblockblock'] );
                }
 
                if ( $row->bl_block_email ) {
                    $properties[] = htmlspecialchars( $this->messages['emailblock'] );
                }
 
                if ( !$row->bl_allow_usertalk ) {
                    $properties[] = htmlspecialchars( $this->messages['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 formatTarget( $row ) {
        if ( $row->bt_auto ) {
            return $this->msg( 'autoblockid', $row->bl_id )->parse();
        }
 
        $target = $this->blockTargetFactory->newFromRowRedacted( $row );
 
        if ( $target instanceof RangeBlockTarget ) {
            $userId = 0;
            $userName = $target->toString();
        } elseif ( ( $row->hu_deleted ?? null )
            && !$this->getAuthority()->isAllowed( 'hideuser' )
        ) {
            return Html::element(
                'span',
                [ 'class' => 'mw-blocklist-hidden' ],
                $this->messages['blocklist-hidden-placeholder']
            );
        } elseif ( $target instanceof BlockTargetWithUserPage ) {
            $user = $target->getUserIdentity();
            $userId = $user->getId();
            $userName = $user->getName();
        } else {
            return $this->msg( 'empty-username' )->escaped();
        }
        return Linker::userLink( $userId, $userName ) .
            Linker::userToolLinks(
                $userId,
                $userName,
                false,
                Linker::TOOL_LINKS_NOBLOCK
            );
    }
 
    private function getBlockChangeLinks( $row ): array {
        $linkRenderer = $this->getLinkRenderer();
        $links = [];
        $target = $this->blockTargetFactory->newFromRowRedacted( $row )->toString();
        if ( $this->getConfig()->get( MainConfigNames::UseCodexSpecialBlock ) ) {
            $query = [ 'id' => $row->bl_id ];
            if ( $row->bt_auto ) {
                $links[] = $linkRenderer->makeKnownLink(
                    $this->specialPageFactory->getTitleForAlias( 'Unblock' ),
                    $this->messages['remove-blocklink'],
                    [],
                    [ 'wpTarget' => "#{$row->bl_id}" ]
                );
            } else {
                $specialBlock = $this->specialPageFactory->getTitleForAlias( "Block/$target" );
                $links[] = $linkRenderer->makeKnownLink(
                    $specialBlock,
                    $this->messages['remove-blocklink'],
                    [],
                    $query + [ 'remove' => '1' ]
                );
                $links[] = $linkRenderer->makeKnownLink(
                    $specialBlock,
                    $this->messages['change-blocklink'],
                    [],
                    $query
                );
            }
        } else {
            if ( $row->bt_auto ) {
                $links[] = $linkRenderer->makeKnownLink(
                    $this->specialPageFactory->getTitleForAlias( 'Unblock' ),
                    $this->messages['unblocklink'],
                    [],
                    [ 'wpTarget' => "#{$row->bl_id}" ]
                );
            } else {
                $links[] = $linkRenderer->makeKnownLink(
                    $this->specialPageFactory->getTitleForAlias( "Unblock/$target" ),
                    $this->messages['unblocklink']
                );
                $links[] = $linkRenderer->makeKnownLink(
                    $this->specialPageFactory->getTitleForAlias( "Block/$target" ),
                    $this->messages['change-blocklink']
                );
            }
        }
        return $links;
    }
 
    private function getRestrictionListHTML( stdClass $row ) {
        $items = [];
        $linkRenderer = $this->getLinkRenderer();
 
        foreach ( $this->restrictions as $restriction ) {
            if ( $restriction->getBlockId() !== (int)$row->bl_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->messages['blanknamespace']
                        : $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() );
                    if ( $actionName ) {
                        $items[$restriction->getType()][] = Html::element(
                            'li',
                            [],
                            // The following messages may be used here:
                            // * ipb-action-create
                            // * ipb-action-move
                            // * ipb-action-upload
                            $this->msg( 'ipb-action-' .
                                $this->blockActionInfo->getActionFromId( $restriction->getValue() ) )->text()
                        );
                    }
                    break;
            }
        }
 
        if ( !$items ) {
            return '';
        }
 
        $sets = [];
        foreach ( $items as $key => $value ) {
            $sets[] = Html::rawElement(
                'li',
                [],
                // The following messages may be used here:
                // * blocklist-editing-sitewide
                // * blocklist-editing-page
                // * blocklist-editing-ns
                // * blocklist-editing-action
                $this->msg( 'blocklist-editing-' . $key ) . Html::rawElement(
                    'ul',
                    [],
                    implode( '', $value )
                )
            );
        }
 
        return Html::rawElement(
            'ul',
            [],
            implode( '', $sets )
        );
    }
 
    public function getQueryInfo() {
        $db = $this->getDatabase();
        $commentQuery = $this->commentStore->getJoin( 'bl_reason' );
        $info = [
            'tables' => [
                'block',
                'block_by_actor' => 'actor',
                'block_target' => 'block_target',
                ...$commentQuery['tables'],
            ],
            'fields' => [
                // The target fields should be those accepted by BlockTargetFactory::newFromRowRedacted()
                'bt_address',
                'bt_user_text',
                'bt_user',
                'bt_auto',
                'bt_range_start',
                'bt_range_end',
                // Block fields and aliases
                'bl_id',
                'bl_by' => 'block_by_actor.actor_user',
                'bl_by_text' => 'block_by_actor.actor_name',
                'bl_timestamp',
                'bl_anon_only',
                'bl_create_account',
                'bl_enable_autoblock',
                'bl_expiry',
                'bl_deleted',
                'bl_block_email',
                'bl_allow_usertalk',
                'bl_sitewide',
            ] + $commentQuery['fields'],
            'conds' => $this->conds,
            'join_conds' => [
                'block_by_actor' => [ 'JOIN', 'actor_id=bl_by_actor' ],
                'block_target' => [ 'JOIN', 'bt_id=bl_target' ],
            ] + $commentQuery['joins']
        ];
 
        # Filter out any expired blocks
        $info['conds'][] = $db->expr( 'bl_expiry', '>', $db->timestamp() );
 
        # Filter out blocks with the deleted option if the user doesn't
        # have permission to see hidden users
        # TODO: consider removing this -- we could just redact them instead.
        # The mere fact that an admin has deleted a user does not need to
        # be private and could be included in block lists and logs for
        # transparency purposes. Previously, filtering out deleted blocks
        # was a convenient way to avoid showing the target name.
        if ( $this->getAuthority()->isAllowed( 'hideuser' ) ) {
            $info['fields']['hu_deleted'] = $this->hideUserUtils->getExpression(
                $db,
                'block_target.bt_user',
                HideUserUtils::HIDDEN_USERS
            );
        } else {
            $info['fields']['hu_deleted'] = 0;
            $info['conds'][] = $this->hideUserUtils->getExpression(
                $db,
                'block_target.bt_user',
                HideUserUtils::SHOWN_USERS
            );
            $info['conds']['bl_deleted'] = 0;
        }
        return $info;
    }
 
    protected function getTableClass() {
        return parent::getTableClass() . ' mw-blocklist';
    }
 
    public function getIndexField() {
        return [ [ 'bl_timestamp', 'bl_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 ) {
            $target = $row->bt_address ?? $row->bt_user_text;
            if ( $target !== null ) {
                $lb->addUser( new UserIdentityValue( (int)$row->bt_user, $target ) );
            }
 
            if ( isset( $row->bl_by_text ) ) {
                $lb->add( NS_USER, $row->bl_by_text );
                $lb->add( NS_USER_TALK, $row->bl_by_text );
            }
 
            if ( !$row->bl_sitewide ) {
                $partialBlocks[] = (int)$row->bl_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();
 
        // Format comments
        // The keys of formattedComments will be the corresponding offset into $result
        $this->formattedComments = $this->rowCommentFormatter->formatRows( $result, 'bl_reason' );
    }
 
}
 
// @codeCoverageIgnoreStart
class_alias( BlockListPager::class, 'BlockListPager' );
 
class_alias( BlockListPager::class, 'MediaWiki\\Pager\\BlockListPager' );
// @codeCoverageIgnoreEnd