AbstractBlock.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Block;

use CommentStoreComment;
use IContextSource;
use InvalidArgumentException;
use IP;
use MediaWiki\MediaWikiServices;
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 $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;
    }

    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 ) {
        $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;
    }

    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 ) {
        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();
    }

}