BlockErrorFormatter.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Block;
 
use MediaWiki\Api\ApiBlockInfoHelper;
use MediaWiki\Api\ApiMessage;
use MediaWiki\CommentStore\CommentStoreComment;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\HookContainer\HookRunner;
use MediaWiki\Language\Language;
use MediaWiki\Language\LocalizationContext;
use MediaWiki\Languages\LanguageFactory;
use MediaWiki\Message\Message;
use MediaWiki\Page\PageReferenceValue;
use MediaWiki\Title\TitleFormatter;
use MediaWiki\User\UserIdentity;
use MediaWiki\User\UserIdentityUtils;
 
class BlockErrorFormatter {
 
    private TitleFormatter $titleFormatter;
    private HookRunner $hookRunner;
    private UserIdentityUtils $userIdentityUtils;
    private LocalizationContext $uiContext;
    private LanguageFactory $languageFactory;
 
    public function __construct(
        TitleFormatter $titleFormatter,
        HookContainer $hookContainer,
        UserIdentityUtils $userIdentityUtils,
        LanguageFactory $languageFactory,
        LocalizationContext $uiContext
    ) {
        $this->titleFormatter = $titleFormatter;
        $this->hookRunner = new HookRunner( $hookContainer );
        $this->userIdentityUtils = $userIdentityUtils;
 
        $this->languageFactory = $languageFactory;
        $this->uiContext = $uiContext;
    }
 
    private function getLanguage(): Language {
        return $this->languageFactory->getLanguage( $this->uiContext->getLanguageCode() );
    }
 
    public function getMessage(
        Block $block,
        UserIdentity $user,
        $language,
        string $ip
    ): Message {
        $key = $this->getBlockErrorMessageKey( $block, $user );
        $params = $this->getBlockErrorMessageParams( $block, $user, $ip );
        $apiHelper = new ApiBlockInfoHelper;
 
        // @phan-suppress-next-line PhanTypeMismatchReturnSuperType
        return ApiMessage::create(
            $this->uiContext->msg( $key, $params ),
            $apiHelper->getBlockCode( $block ),
            [ 'blockinfo' => $apiHelper->getBlockDetails( $block, $this->getLanguage(), $user ) ]
        );
    }
 
    public function getMessages(
        Block $block,
        UserIdentity $user,
        string $ip
    ): array {
        $messages = [];
        foreach ( $block->toArray() as $singleBlock ) {
            $messages[] = $this->getMessage( $singleBlock, $user, null, $ip );
        }
 
        return $messages;
    }
 
    private function getBlockErrorInfo( Block $block ) {
        $blocker = $block->getBlocker();
        return [
            'identifier' => $block->getIdentifier(),
            'targetName' => $block->getTargetName(),
            'blockerName' => $blocker ? $blocker->getName() : '',
            'reason' => $block->getReasonComment(),
            'expiry' => $block->getExpiry(),
            'timestamp' => $block->getTimestamp(),
        ];
    }
 
    private function getFormattedBlockErrorInfo(
        Block $block,
        UserIdentity $user
    ) {
        $info = $this->getBlockErrorInfo( $block );
 
        $language = $this->getLanguage();
 
        $info['expiry'] = $language->formatExpiry( $info['expiry'], true, 'infinity', $user );
        $info['timestamp'] = $language->userTimeAndDate( $info['timestamp'], $user );
        $info['blockerName'] = $language->embedBidi( $info['blockerName'] );
        $info['targetName'] = $language->embedBidi( $info['targetName'] );
 
        $info['reason'] = $this->formatBlockReason( $info['reason'], $language );
 
        return $info;
    }
 
    private function formatBlockReason( CommentStoreComment $reason, Language $language ) {
        if ( $reason->text === '' ) {
            $message = new Message( 'blockednoreason', [], $language );
            return $message->plain();
        }
        return $reason->message->inLanguage( $language )->plain();
    }
 
    private function formatBlockerLink( ?UserIdentity $blocker ) {
        if ( !$blocker ) {
            // TODO should we say something? This is just matching the code before
            // the refactoring in late July 2021
            return '';
        }
 
        $language = $this->getLanguage();
 
        if ( $blocker->getId() === 0 ) {
            // Foreign user
            // TODO what about blocks placed by IPs? Shouldn't we check based on
            // $blocker's wiki instead? This is just matching the code before the
            // refactoring in late July 2021.
            return $language->embedBidi( $blocker->getName() );
        }
 
        $blockerUserpage = PageReferenceValue::localReference( NS_USER, $blocker->getName() );
        $blockerText = $language->embedBidi(
            $this->titleFormatter->getText( $blockerUserpage )
        );
        $prefixedText = $this->titleFormatter->getPrefixedText( $blockerUserpage );
        return "[[{$prefixedText}|{$blockerText}]]";
    }
 
    private function getBlockErrorMessageKey( Block $block, UserIdentity $user ) {
        $isTempUser = $this->userIdentityUtils->isTemp( $user );
        $key = $isTempUser ? 'blockedtext-tempuser' : 'blockedtext';
        if ( $block instanceof DatabaseBlock ) {
            if ( $block->getType() === Block::TYPE_AUTO ) {
                $key = $isTempUser ? 'autoblockedtext-tempuser' : 'autoblockedtext';
            } elseif ( !$block->isSitewide() ) {
                $key = 'blockedtext-partial';
            }
        } elseif ( $block instanceof SystemBlock ) {
            $key = 'systemblockedtext';
        } elseif ( $block instanceof CompositeBlock ) {
            $key = 'blockedtext-composite';
        }
 
        // Allow extensions to modify the block error message
        $this->hookRunner->onGetBlockErrorMessageKey( $block, $key );
 
        return $key;
    }
 
    private function getBlockErrorMessageParams(
        Block $block,
        UserIdentity $user,
        string $ip
    ) {
        $info = $this->getFormattedBlockErrorInfo( $block, $user );
 
        // Add params that are specific to the standard block errors
        $info['ip'] = $ip;
        $info['blockerLink'] = $this->formatBlockerLink( $block->getBlocker() );
 
        // Display the CompositeBlock identifier as a message containing relevant block IDs
        if ( $block instanceof CompositeBlock ) {
            $ids = $this->getLanguage()->commaList( array_map(
                static function ( $id ) {
                    return '#' . $id;
                },
                array_filter( $info['identifier'], 'is_int' )
            ) );
            if ( $ids === '' ) {
                $idsMsg = $this->uiContext->msg( 'blockedtext-composite-no-ids', [] );
            } else {
                $idsMsg = $this->uiContext->msg( 'blockedtext-composite-ids', [ $ids ] );
            }
            $info['identifier'] = $idsMsg->plain();
        }
 
        // Messages expect the params in this order
        $order = [
            'blockerLink',
            'reason',
            'ip',
            'blockerName',
            'identifier',
            'expiry',
            'targetName',
            'timestamp',
        ];
 
        $params = [];
        foreach ( $order as $item ) {
            $params[] = $info[$item];
        }
 
        return $params;
    }
 
}