AbstractBlock.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Block;
 
use CommentStoreComment;
use IContextSource;
use InvalidArgumentException;
use MediaWiki\MediaWikiServices;
use MediaWiki\User\UserIdentity;
use Message;
use RequestContext;
use Title;
use User;
 
abstract class AbstractBlock {
    protected $mReason;
 
    protected $reason;
 
    public $mTimestamp;
 
    public $mExpiry = '';
 
    protected $mBlockEmail = false;
 
    protected $allowUsertalk = false;
 
    protected $blockCreateAccount = false;
 
    public $mHideName = false;
 
    protected $isHardblock;
 
    protected $target;
 
    protected $type;
 
    protected $isSitewide = true;
 
    # TYPE constants
    # Do not introduce negative constants without changing BlockUser command object.
    public const TYPE_USER = 1;
    public const TYPE_IP = 2;
    public const TYPE_RANGE = 3;
    public const TYPE_AUTO = 4;
    public const TYPE_ID = 5;
 
    public function __construct( array $options = [] ) {
        $defaults = [
            'address'         => '',
            'reason'          => '',
            'timestamp'       => '',
            'hideName'        => false,
            'anonOnly'        => false,
        ];
 
        $options += $defaults;
 
        $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();
 
    abstract public function getByName();
 
    public function getId() {
        return null;
    }
 
    abstract public function getIdentifier();
 
    public function getReason() {
        $language = RequestContext::getMain()->getLanguage();
        return $this->reason->message->inLanguage( $language )->plain();
    }
 
    public function getReasonComment() {
        return $this->reason;
    }
 
    public function setReason( $reason ) {
        $this->reason = CommentStoreComment::newUnsavedComment( $reason );
    }
 
    public function getHideName() {
        return $this->mHideName;
    }
 
    public function setHideName( $hideName ) {
        $this->mHideName = $hideName;
    }
 
    public function isSitewide( $x = null ) {
        return wfSetVar( $this->isSitewide, $x );
    }
 
    public function isCreateAccountBlocked( $x = null ) {
        return wfSetVar( $this->blockCreateAccount, $x );
    }
 
    public function isEmailBlocked( $x = null ) {
        return wfSetVar( $this->mBlockEmail, $x );
    }
 
    public function isUsertalkEditAllowed( $x = null ) {
        return wfSetVar( $this->allowUsertalk, $x );
    }
 
    public function isHardblock( $x = null ) {
        wfSetVar( $this->isHardblock, $x );
 
        return $this->getType() == self::TYPE_USER
            ? true
            : $this->isHardblock;
    }
 
    public function appliesToRight( $right ) {
        $config = RequestContext::getMain()->getConfig();
        $blockDisablesLogin = $config->get( 'BlockDisablesLogin' );
 
        $res = null;
        switch ( $right ) {
            case 'edit':
                // TODO: fix this case to return proper value
                $res = true;
                break;
            case 'createaccount':
                $res = $this->isCreateAccountBlocked();
                break;
            case 'sendemail':
                $res = $this->isEmailBlocked();
                break;
            case 'upload':
                // Until T6995 is completed
                $res = $this->isSitewide();
                break;
            case 'read':
                $res = false;
                break;
            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 static function parseTarget( $target ) {
        return MediaWikiServices::getInstance()
            ->getBlockUtils()
            ->parseBlockTarget( $target );
    }
 
    public function getType() {
        return $this->type;
    }
 
    public function getTargetAndType() {
        return [ $this->getTarget(), $this->getType() ];
    }
 
    public function getTarget() {
        return $this->target;
    }
 
    public function getExpiry() {
        return $this->mExpiry;
    }
 
    public function setExpiry( $expiry ) {
        $this->mExpiry = $expiry;
    }
 
    public function getTimestamp() {
        return $this->mTimestamp;
    }
 
    public function setTimestamp( $timestamp ) {
        $this->mTimestamp = $timestamp;
    }
 
    public function setTarget( $target ) {
        list( $this->target, $this->type ) = static::parseTarget( $target );
    }
 
    public function getPermissionsError( IContextSource $context ) {
        $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 User ) {
                $usertalk = $this->target->getTalkPage();
            } 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.
        $config = RequestContext::getMain()->getConfig();
        if ( !$config->get( '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();
    }
 
}