AbstractBlock.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Block;
 
use IContextSource;
use InvalidArgumentException;
use IP;
use MediaWiki\MediaWikiServices;
use RequestContext;
use Title;
use User;
 
abstract class AbstractBlock {
    public $mReason;
 
    public $mTimestamp;
 
    public $mExpiry = '';
 
    protected $mBlockEmail = false;
 
    protected $allowUsertalk = false;
 
    protected $blockCreateAccount = false;
 
    public $mHideName = false;
 
    protected $target;
 
    protected $type;
 
    protected $blocker;
 
    protected $isSitewide = true;
 
    # TYPE constants
    const TYPE_USER = 1;
    const TYPE_IP = 2;
    const TYPE_RANGE = 3;
    const TYPE_AUTO = 4;
    const TYPE_ID = 5;
 
    public function __construct( array $options = [] ) {
        $defaults = [
            'address'         => '',
            'by'              => null,
            'reason'          => '',
            'timestamp'       => '',
            'byText'          => '',
            'hideName'        => false,
        ];
 
        $options += $defaults;
 
        $this->setTarget( $options['address'] );
 
        if ( $options['by'] ) {
            # Local user
            $this->setBlocker( User::newFromId( $options['by'] ) );
        } else {
            # Foreign user
            $this->setBlocker( $options['byText'] );
        }
 
        $this->setReason( $options['reason'] );
        $this->setTimestamp( wfTimestamp( TS_MW, $options['timestamp'] ) );
        $this->setHideName( (bool)$options['hideName'] );
    }
 
    public function getBy() {
        return $this->getBlocker()->getId();
    }
 
    public function getByName() {
        return $this->getBlocker()->getName();
    }
 
    public function getId() {
        return null;
    }
 
    public function getReason() {
        return $this->mReason;
    }
 
    public function setReason( $reason ) {
        $this->mReason = $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 ) {
        $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 User ) {
            if ( IP::isValid( $target->getName() ) ) {
                return [ $target, self::TYPE_IP ];
            } else {
                return [ $target, self::TYPE_USER ];
            }
        } elseif ( $target === null ) {
            return [ null, null ];
        }
 
        $target = trim( $target );
 
        if ( IP::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( IP::sanitizeIP( $target ), false ),
                self::TYPE_IP
            ];
 
        } elseif ( IP::isValidRange( $target ) ) {
            # Can't create a User from an IP range
            return [ IP::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() {
        return $this->blocker;
    }
 
    public function setBlocker( $user ) {
        if ( is_string( $user ) ) {
            $user = User::newFromName( $user, false );
        }
 
        if ( $user->isAnon() && User::isUsableName( $user->getName() ) ) {
            throw new InvalidArgumentException(
                'Blocker must be a local user or a name that cannot be a local user'
            );
        }
 
        $this->blocker = $user;
    }
 
    abstract public function getPermissionsError( IContextSource $context );
 
    public function getBlockErrorParams( IContextSource $context ) {
        $lang = $context->getLanguage();
 
        $blocker = $this->getBlocker();
        if ( $blocker instanceof User ) { // local user
            $blockerUserpage = $blocker->getUserPage();
            $blockerText = $lang->embedBidi( $blockerUserpage->getText() );
            $link = "[[{$blockerUserpage->getPrefixedText()}|{$blockerText}]]";
        } else { // foreign user
            $link = $blocker;
        }
 
        $reason = $this->getReason();
        if ( $reason == '' ) {
            $reason = $context->msg( 'blockednoreason' )->text();
        }
 
        /* $ip returns who *is* being blocked, $intended contains who was meant to be blocked.
         * This could be a username, an IP range, or a single IP. */
        $intended = (string)$this->getTarget();
 
        return [
            $link,
            $reason,
            $context->getRequest()->getIP(),
            $lang->embedBidi( $this->getByName() ),
            // TODO: SystemBlock replaces this with the system block type. Clean up
            // error params so that this is not necessary.
            $this->getId(),
            $lang->formatExpiry( $this->getExpiry() ),
            $lang->embedBidi( $intended ),
            $lang->userTimeAndDate( $this->getTimestamp(), $context->getUser() ),
        ];
    }
 
    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();
    }
 
}