AbstractBlock.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Block;
 
use IContextSource;
use InvalidArgumentException;
use MediaWiki\CommentStore\CommentStoreComment;
use MediaWiki\DAO\WikiAwareEntityTrait;
use MediaWiki\MainConfigNames;
use MediaWiki\MediaWikiServices;
use MediaWiki\Title\Title;
use MediaWiki\User\User;
use MediaWiki\User\UserIdentity;
use Message;
use RequestContext;
 
abstract class AbstractBlock implements Block {
    use WikiAwareEntityTrait;
 
    protected $reason;
 
    protected $timestamp = '';
 
    protected $expiry = '';
 
    protected $blockEmail = false;
 
    protected $allowUsertalk = false;
 
    protected $blockCreateAccount = false;
 
    protected $hideName = false;
 
    protected $isHardblock;
 
    protected $target;
 
    protected $type;
 
    protected $isSitewide = true;
 
    protected $wikiId;
 
    public function __construct( array $options = [] ) {
        $defaults = [
            'address'         => '',
            'wiki'            => self::LOCAL,
            'reason'          => '',
            'timestamp'       => '',
            'hideName'        => false,
            'anonOnly'        => false,
        ];
 
        $options += $defaults;
 
        $this->wikiId = $options['wiki'];
        $this->setTarget( $options['address'] );
        $this->setReason( $options['reason'] );
        $this->setTimestamp( wfTimestamp( TS_MW, $options['timestamp'] ) );
        $this->setHideName( (bool)$options['hideName'] );
        $this->isHardblock( !$options['anonOnly'] );
    }
 
    abstract public function getBy( $wikiId = self::LOCAL ): int;
 
    abstract public function getByName();
 
    public function getId( $wikiId = self::LOCAL ): ?int {
        $this->assertWiki( $wikiId );
        return null;
    }
 
    public function getReason() {
        wfDeprecated( __METHOD__, '1.35' );
        $language = RequestContext::getMain()->getLanguage();
        return $this->reason->message->inLanguage( $language )->plain();
    }
 
    public function getReasonComment(): CommentStoreComment {
        return $this->reason;
    }
 
    public function setReason( $reason ) {
        $this->reason = CommentStoreComment::newUnsavedComment( $reason );
    }
 
    public function getHideName() {
        return $this->hideName;
    }
 
    public function setHideName( $hideName ) {
        $this->hideName = $hideName;
    }
 
    public function isSitewide( $x = null ): bool {
        return wfSetVar( $this->isSitewide, $x );
    }
 
    public function isCreateAccountBlocked( $x = null ): bool {
        return wfSetVar( $this->blockCreateAccount, $x );
    }
 
    public function isEmailBlocked( $x = null ) {
        return wfSetVar( $this->blockEmail, $x );
    }
 
    public function isUsertalkEditAllowed( $x = null ) {
        return wfSetVar( $this->allowUsertalk, $x );
    }
 
    public function isHardblock( $x = null ): bool {
        wfSetVar( $this->isHardblock, $x );
 
        return $this->getType() == self::TYPE_USER
            ? true
            : $this->isHardblock;
    }
 
    public function appliesToRight( $right ) {
        $blockDisablesLogin = MediaWikiServices::getInstance()->getMainConfig()
            ->get( MainConfigNames::BlockDisablesLogin );
 
        $res = null;
        switch ( $right ) {
            case 'createaccount':
                $res = $this->isCreateAccountBlocked();
                break;
            case 'sendemail':
                $res = $this->isEmailBlocked();
                break;
            case 'upload':
                // Sitewide blocks always block upload. This may be overridden in a subclass.
                $res = $this->isSitewide();
                break;
            case 'read':
            case 'purge':
                $res = false;
                break;
        }
        if ( !$res && $blockDisablesLogin ) {
            // If a block would disable login, then it should
            // prevent any right that all users cannot do
            $permissionManager = MediaWikiServices::getInstance()->getPermissionManager();
            $anon = new User;
            $res = $permissionManager->userHasRight( $anon, $right ) ? $res : true;
        }
 
        return $res;
    }
 
    public function getType(): ?int {
        return $this->type;
    }
 
    public function getTargetUserIdentity(): ?UserIdentity {
        return $this->target instanceof UserIdentity ? $this->target : null;
    }
 
    public function getTargetName(): string {
        return $this->target instanceof UserIdentity
            ? $this->target->getName()
            : (string)$this->target;
    }
 
    public function isBlocking( $target ): bool {
        $targetName = $target instanceof UserIdentity
            ? $target->getName()
            : (string)$target;
 
        return $targetName === $this->getTargetName();
    }
 
    public function getExpiry(): string {
        return $this->expiry;
    }
 
    public function setExpiry( $expiry ) {
        // Force string so getExpiry() return typehint doesn't break things
        $this->expiry = (string)$expiry;
    }
 
    public function getTimestamp(): string {
        return $this->timestamp;
    }
 
    public function setTimestamp( $timestamp ) {
        // Force string so getTimestamp() return typehint doesn't break things
        $this->timestamp = (string)$timestamp;
    }
 
    public function setTarget( $target ) {
        // Small optimization to make this code testable, this is what would happen anyway
        if ( $target === '' ) {
            $this->target = null;
            $this->type = null;
        } else {
            [ $parsedTarget, $this->type ] = MediaWikiServices::getInstance()
                ->getBlockUtils()
                ->parseBlockTarget( $target );
            if ( $parsedTarget !== null ) {
                $this->assertWiki( is_string( $parsedTarget ) ? self::LOCAL : $parsedTarget->getWikiId() );
            }
            $this->target = $parsedTarget;
        }
    }
 
    public function getWikiId() {
        return $this->wikiId;
    }
 
    public function getPermissionsError( IContextSource $context ) {
        wfDeprecated( __METHOD__, '1.35' );
        $message = MediaWikiServices::getInstance()
            ->getBlockErrorFormatter()->getMessage(
                $this,
                $context->getUser(),
                $context->getLanguage(),
                $context->getRequest()->getIP()
            );
        return array_merge( [ $message->getKey() ], $message->getParams() );
    }
 
    public function appliesToUsertalk( Title $usertalk = null ) {
        if ( !$usertalk ) {
            if ( $this->target instanceof UserIdentity ) {
                $usertalk = Title::makeTitle(
                    NS_USER_TALK,
                    $this->target->getName()
                );
            } else {
                throw new InvalidArgumentException(
                    '$usertalk must be provided if block target is not a user/IP'
                );
            }
        }
 
        if ( $usertalk->getNamespace() !== NS_USER_TALK ) {
            throw new InvalidArgumentException(
                '$usertalk must be a user talk page'
            );
        }
 
        if ( !$this->isSitewide() ) {
            if ( $this->appliesToPage( $usertalk->getArticleID() ) ) {
                return true;
            }
            if ( !$this->appliesToNamespace( NS_USER_TALK ) ) {
                return false;
            }
        }
 
        // This is a type of block which uses the ipb_allow_usertalk
        // flag. The flag can still be overridden by global configs.
        if ( !MediaWikiServices::getInstance()->getMainConfig()
            ->get( MainConfigNames::BlockAllowsUTEdit )
        ) {
            return true;
        }
        return !$this->isUsertalkEditAllowed();
    }
 
    public function appliesToTitle( Title $title ) {
        return $this->isSitewide();
    }
 
    public function appliesToNamespace( $ns ) {
        return $this->isSitewide();
    }
 
    public function appliesToPage( $pageId ) {
        return $this->isSitewide();
    }
 
    public function appliesToPasswordReset() {
        return $this->isCreateAccountBlocked();
    }
 
    public function toArray(): array {
        return [ $this ];
    }
 
}