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;
use Wikimedia\IPUtils;
 
abstract class AbstractBlock {
    protected $mReason;
 
    protected $reason;
 
    public $mTimestamp;
 
    public $mExpiry = '';
 
    protected $mBlockEmail = false;
 
    protected $allowUsertalk = false;
 
    protected $blockCreateAccount = false;
 
    public $mHideName = false;
 
    protected $target;
 
    protected $type;
 
    protected $isSitewide = true;
 
    # TYPE constants
    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,
        ];
 
        $options += $defaults;
 
        $this->setTarget( $options['address'] );
 
        $this->setReason( $options['reason'] );
        $this->setTimestamp( wfTimestamp( TS_MW, $options['timestamp'] ) );
        $this->setHideName( (bool)$options['hideName'] );
    }
 
    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 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 function prevents( $action, $x = null ) {
        wfDeprecated( __METHOD__, '1.33' );
        $config = RequestContext::getMain()->getConfig();
        $blockDisablesLogin = $config->get( 'BlockDisablesLogin' );
        $blockAllowsUTEdit = $config->get( 'BlockAllowsUTEdit' );
 
        $res = null;
        switch ( $action ) {
            case 'edit':
                # For now... <evil laugh>
                $res = true;
                break;
            case 'createaccount':
                $res = wfSetVar( $this->blockCreateAccount, $x );
                break;
            case 'sendemail':
                $res = wfSetVar( $this->mBlockEmail, $x );
                break;
            case 'upload':
                // Until T6995 is completed
                $res = $this->isSitewide();
                break;
            case 'editownusertalk':
                // NOTE: this check is not reliable on partial blocks
                // since partially blocked users are always allowed to edit
                // their own talk page unless a restriction exists on the
                // page or User_talk: namespace
                wfSetVar( $this->allowUsertalk, $x === null ? null : !$x );
                $res = !$this->isUsertalkEditAllowed();
 
                // edit own user talk can be disabled by config
                if ( !$blockAllowsUTEdit ) {
                    $res = true;
                }
                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 action that all users cannot do
            $permissionManager = MediaWikiServices::getInstance()->getPermissionManager();
            $anon = new User;
            $res = $permissionManager->userHasRight( $anon, $action ) ? $res : true;
        }
 
        return $res;
    }
 
    public static function parseTarget( $target ) {
        # We may have been through this before
        if ( $target instanceof UserIdentity ) {
            $userObj = User::newFromIdentity( $target );
            if ( IPUtils::isValid( $target->getName() ) ) {
                return [ $userObj, self::TYPE_IP ];
            } else {
                return [ $userObj, self::TYPE_USER ];
            }
        } elseif ( $target === null ) {
            return [ null, null ];
        }
 
        $target = trim( $target );
 
        if ( IPUtils::isValid( $target ) ) {
            # We can still create a User if it's an IP address, but we need to turn
            # off validation checking (which would exclude IP addresses)
            return [
                User::newFromName( IPUtils::sanitizeIP( $target ), false ),
                self::TYPE_IP
            ];
 
        } elseif ( IPUtils::isValidRange( $target ) ) {
            # Can't create a User from an IP range
            return [ IPUtils::sanitizeRange( $target ), self::TYPE_RANGE ];
        }
 
        # Consider the possibility that this is not a username at all
        # but actually an old subpage (T31797)
        if ( strpos( $target, '/' ) !== false ) {
            # An old subpage, drill down to the user behind it
            $target = explode( '/', $target )[0];
        }
 
        $userObj = User::newFromName( $target );
        if ( $userObj instanceof User ) {
            # Note that since numbers are valid usernames, a $target of "12345" will be
            # considered a User.  If you want to pass a block ID, prepend a hash "#12345",
            # since hash characters are not valid in usernames or titles generally.
            return [ $userObj, self::TYPE_USER ];
 
        } elseif ( preg_match( '/^#\d+$/', $target ) ) {
            # Autoblock reference in the form "#12345"
            return [ substr( $target, 1 ), self::TYPE_AUTO ];
 
        } else {
            return [ null, null ];
        }
    }
 
    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 getBlocker() {
        wfDeprecated( __METHOD__, '1.35' );
        return null;
    }
 
    public function setBlocker( $user ) {
        wfDeprecated( __METHOD__, '1.35' );
    }
 
    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 getBlockErrorParams( IContextSource $context ) {
        wfDeprecated( __METHOD__, '1.35' );
        return MediaWikiServices::getInstance()
            ->getBlockErrorFormatter()->getMessage(
                $this,
                $context->getUser(),
                $context->getLanguage(),
                $context->getRequest()->getIP()
            )->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 shouldTrackWithCookie( $isAnon ) {
        wfDeprecated( __METHOD__, '1.34' );
        return false;
    }
 
    public function appliesToPasswordReset() {
        return $this->isCreateAccountBlocked();
    }
 
}