AbstractBlock.php
No OneTemporary
Actions

Size

15 KB

Referenced Files

None

Subscribers

None

AbstractBlock.php
View Options

	<?php
	/**
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License along
	* with this program; if not, write to the Free Software Foundation, Inc.,
	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	* http://www.gnu.org/copyleft/gpl.html
	*
	* @file
	*/

	namespace MediaWiki\Block;

	use InvalidArgumentException;
	use LogicException;
	use MediaWiki\CommentStore\CommentStoreComment;
	use MediaWiki\DAO\WikiAwareEntityTrait;
	use MediaWiki\MainConfigNames;
	use MediaWiki\MediaWikiServices;
	use MediaWiki\Message\Message;
	use MediaWiki\Title\Title;
	use MediaWiki\User\UserIdentity;

	/**
	* @note Extensions should not subclass this, as MediaWiki currently does not
	* support custom block types.
	* @since 1.34 Factored out from DatabaseBlock (previously Block).
	*/
	abstract class AbstractBlock implements Block {
	use WikiAwareEntityTrait;

	/** @var CommentStoreComment */
	protected $reason;

	/** @var string */
	protected $timestamp = '';

	/** @var string */
	protected $expiry = '';

	/** @var bool */
	protected $blockEmail = false;

	/** @var bool */
	protected $allowUsertalk = false;

	/** @var bool */
	protected $blockCreateAccount = false;

	/** @var bool */
	protected $hideName = false;

	/** @var bool */
	protected $isHardblock;

	/** @var BlockTarget\|null */
	protected $target;

	/** @var bool */
	protected $isSitewide = true;

	/** @var string\|false */
	protected $wikiId;

	/**
	* Create a new block with specified parameters on a user, IP or IP range.
	*
	* @param array $options Parameters of the block, with supported options:
	* - target: (BlockTarget) The target object (since 1.44)
	* - address: (string\|UserIdentity) Target user name, user identity object,
	* IP address or IP range.
	* - wiki: (string\|false) The wiki the block has been issued in,
	* self::LOCAL for the local wiki (since 1.38)
	* - reason: (string\|Message\|CommentStoreComment) Reason for the block
	* - timestamp: (string) The time at which the block comes into effect,
	* in any format supported by wfTimestamp()
	* - decodedTimestamp: (string) The timestamp in MW 14-character format
	* - hideName: (bool) Hide the target user name
	* - anonOnly: (bool) Used if the target is an IP address. The block only
	* applies to anon and temporary users using this IP address, and not to
	* logged-in users.
	*/
	public function __construct( array $options = [] ) {
	$defaults = [
	'wiki' => self::LOCAL,
	'reason' => '',
	'timestamp' => '',
	'hideName' => false,
	'anonOnly' => false,
	];

	$options += $defaults;

	$this->wikiId = $options['wiki'];
	if ( isset( $options['target'] ) ) {
	if ( !( $options['target'] instanceof BlockTarget ) ) {
	throw new InvalidArgumentException( 'Invalid block target' );
	}
	$this->setTarget( $options['target'] );
	} elseif ( isset( $options['address'] ) ) {
	$this->setTarget( $options['address'] );
	} else {
	$this->setTarget( null );
	}
	$this->setReason( $options['reason'] );
	if ( isset( $options['decodedTimestamp'] ) ) {
	$this->setTimestamp( $options['decodedTimestamp'] );
	} else {
	$this->setTimestamp( wfTimestamp( TS_MW, $options['timestamp'] ) );
	}
	$this->setHideName( (bool)$options['hideName'] );
	$this->isHardblock( !$options['anonOnly'] );
	}

	/**
	* Get the user id of the blocking sysop
	*
	* @param string\|false $wikiId (since 1.38)
	* @return int (0 for foreign users)
	*/
	abstract public function getBy( $wikiId = self::LOCAL ): int;

	/**
	* Get the username of the blocking sysop
	*
	* @return string
	*/
	abstract public function getByName();

	/**
	* @inheritDoc
	*/
	public function getId( $wikiId = self::LOCAL ): ?int {
	$this->assertWiki( $wikiId );
	return null;
	}

	/**
	* Get the reason for creating the block.
	*
	* @since 1.35
	* @return CommentStoreComment
	*/
	public function getReasonComment(): CommentStoreComment {
	return $this->reason;
	}

	/**
	* Set the reason for creating the block.
	*
	* @since 1.33
	* @param string\|Message\|CommentStoreComment $reason
	*/
	public function setReason( $reason ) {
	$this->reason = CommentStoreComment::newUnsavedComment( $reason );
	}

	/**
	* Get whether the block hides the target's username
	*
	* @since 1.33
	* @return bool The block hides the username
	*/
	public function getHideName() {
	return $this->hideName;
	}

	/**
	* Set whether the block hides the target's username
	*
	* @since 1.33
	* @param bool $hideName The block hides the username
	*/
	public function setHideName( $hideName ) {
	$this->hideName = $hideName;
	}

	/**
	* Indicates that the block is a sitewide block. This means the user is
	* prohibited from editing any page on the site (other than their own talk
	* page).
	*
	* @since 1.33
	* @param null\|bool $x
	* @return bool
	*/
	public function isSitewide( $x = null ): bool {
	return wfSetVar( $this->isSitewide, $x );
	}

	/**
	* Get or set the flag indicating whether this block blocks the target from
	* creating an account. (Note that the flag may be overridden depending on
	* global configs.)
	*
	* @since 1.33
	* @param null\|bool $x Value to set (if null, just get the property value)
	* @return bool Value of the property
	*/
	public function isCreateAccountBlocked( $x = null ): bool {
	return wfSetVar( $this->blockCreateAccount, $x );
	}

	/**
	* Get or set the flag indicating whether this block blocks the target from
	* sending emails. (Note that the flag may be overridden depending on
	* global configs.)
	*
	* @since 1.33
	* @param null\|bool $x Value to set (if null, just get the property value)
	* @return bool Value of the property
	*/
	public function isEmailBlocked( $x = null ) {
	return wfSetVar( $this->blockEmail, $x );
	}

	/**
	* Get or set the flag indicating whether this block blocks the target from
	* editing their own user talk page. (Note that the flag may be overridden
	* depending on global configs.)
	*
	* @since 1.33
	* @param null\|bool $x Value to set (if null, just get the property value)
	* @return bool Value of the property
	*/
	public function isUsertalkEditAllowed( $x = null ) {
	return wfSetVar( $this->allowUsertalk, $x );
	}

	/**
	* Get/set whether the block is a hard block (affects logged-in users on a
	* given IP/range).
	*
	* Note that temporary users are not considered logged-in here - they are
	* always blocked by IP-address blocks.
	*
	* Note that user blocks are always hard blocks, since the target is logged
	* in by definition.
	*
	* @since 1.36 Moved up from DatabaseBlock
	* @param bool\|null $x
	* @return bool
	*/
	public function isHardblock( $x = null ): bool {
	wfSetVar( $this->isHardblock, $x );

	return $this->getType() == self::TYPE_USER
	? true
	: $this->isHardblock;
	}

	/**
	* Determine whether the block prevents a given right. A right may be
	* allowed or disallowed by default, or determined from a property on the
	* block object. For certain rights, the property may be overridden
	* according to global configs.
	*
	* @since 1.33
	* @param string $right
	* @return bool\|null The block applies to the right, or null if
	* unsure (e.g. unrecognized right or unset property)
	*/
	public function appliesToRight( $right ) {
	$blockDisablesLogin = MediaWikiServices::getInstance()->getMainConfig()
	->get( MainConfigNames::BlockDisablesLogin );

	$res = null;
	switch ( $right ) {
	case 'autocreateaccount':
	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':
	$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 = MediaWikiServices::getInstance()->getUserFactory()->newAnonymous();
	$res = $permissionManager->userHasRight( $anon, $right ) ? $res : true;
	}

	return $res;
	}

	public function getTarget(): ?BlockTarget {
	return $this->target;
	}

	public function getRedactedTarget(): ?BlockTarget {
	$target = $this->getTarget();
	if ( $this->getType() === Block::TYPE_AUTO
	&& !( $target instanceof AutoBlockTarget )
	) {
	$id = $this->getId( $this->wikiId );
	if ( $id === null ) {
	throw new LogicException( 'no ID available for autoblock redaction' );
	}
	$target = new AutoBlockTarget( $id, $this->wikiId );
	}
	return $target;
	}

	/**
	* Get the type of target for this particular block.
	* @return int\|null AbstractBlock::TYPE_ constant
	*/
	public function getType(): ?int {
	return $this->target ? $this->target->getType() : null;
	}

	/**
	* @since 1.37
	* @return ?UserIdentity
	*/
	public function getTargetUserIdentity(): ?UserIdentity {
	return $this->target instanceof BlockTargetWithUserIdentity
	? $this->target->getUserIdentity() : null;
	}

	/**
	* @since 1.37
	* @return string
	*/
	public function getTargetName(): string {
	return (string)$this->target;
	}

	/**
	* @param BlockTarget\|UserIdentity\|string $target
	*
	* @return bool
	* @since 1.37
	*/
	public function isBlocking( $target ): bool {
	$targetName = $target instanceof UserIdentity
	? $target->getName()
	: (string)$target;

	return $targetName === $this->getTargetName();
	}

	/**
	* Get the block expiry time
	*
	* @since 1.19
	* @return string
	*/
	public function getExpiry(): string {
	return $this->expiry;
	}

	/** @inheritDoc */
	public function isIndefinite(): bool {
	return wfIsInfinity( $this->getExpiry() );
	}

	/**
	* Set the block expiry time
	*
	* @since 1.33
	* @param string $expiry
	*/
	public function setExpiry( $expiry ) {
	// Force string so getExpiry() return typehint doesn't break things
	$this->expiry = (string)$expiry;
	}

	/**
	* Get the timestamp indicating when the block was created
	*
	* @since 1.33
	* @return string
	*/
	public function getTimestamp(): string {
	return $this->timestamp;
	}

	/**
	* Set the timestamp indicating when the block was created
	*
	* @since 1.33
	* @param string $timestamp
	*/
	public function setTimestamp( $timestamp ) {
	// Force string so getTimestamp() return typehint doesn't break things
	$this->timestamp = (string)$timestamp;
	}

	/**
	* Set the target for this block
	* @param BlockTarget\|string\|UserIdentity\|null $target
	*/
	public function setTarget( $target ) {
	// Small optimization to make this code testable, this is what would happen anyway
	if ( $target === '' \|\| $target === null ) {
	$this->target = null;
	} elseif ( $target instanceof BlockTarget ) {
	$this->assertWiki( $target->getWikiId() );
	$this->target = $target;
	} else {
	$parsedTarget = MediaWikiServices::getInstance()
	->getCrossWikiBlockTargetFactory()
	->getFactory( $this->wikiId )
	->newFromLegacyUnion( $target );
	$this->assertWiki( $parsedTarget->getWikiId() );
	$this->target = $parsedTarget;
	}
	}

	/**
	* @since 1.38
	* @return string\|false
	*/
	public function getWikiId() {
	return $this->wikiId;
	}

	/**
	* Determine whether the block allows the user to edit their own
	* user talk page. This is done separately from
	* AbstractBlock::appliesToRight because there is no right for
	* editing one's own user talk page and because the user's talk
	* page needs to be passed into the block object, which is unaware
	* of the user.
	*
	* The bl_allow_usertalk flag (which corresponds to the property
	* allowUsertalk) is used on sitewide blocks and partial blocks
	* that contain a namespace restriction on the user talk namespace,
	* but do not contain a page restriction on the user's talk page.
	* For all other (i.e. most) partial blocks, the flag is ignored,
	* and the user can always edit their user talk page unless there
	* is a page restriction on their user talk page, in which case
	* they can never edit it. (Ideally the flag would be stored as
	* null in these cases, but the database field isn't nullable.)
	*
	* This method does not validate that the passed in talk page belongs to the
	* block target since the target (an IP) might not be the same as the user's
	* talk page (if they are logged in).
	*
	* @since 1.33
	* @param Title\|null $usertalk The user's user talk page. If null,
	* and if the target is a User, the target's userpage is used
	* @return bool The user can edit their talk page
	*/
	public function appliesToUsertalk( ?Title $usertalk = null ) {
	if ( !$usertalk ) {
	if ( $this->target instanceof BlockTargetWithUserPage ) {
	$usertalk = Title::makeTitle(
	NS_USER_TALK,
	$this->target->getUserPage()->getDBkey()
	);
	} 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 bl_allow_usertalk
	// flag. The flag can still be overridden by global configs.
	if ( !MediaWikiServices::getInstance()->getMainConfig()
	->get( MainConfigNames::BlockAllowsUTEdit )
	) {
	return true;
	}
	return !$this->isUsertalkEditAllowed();
	}

	/**
	* Checks if a block applies to a particular title
	*
	* This check does not consider whether `$this->isUsertalkEditAllowed`
	* returns false, as the identity of the user making the hypothetical edit
	* isn't known here (particularly in the case of IP hard blocks, range
	* blocks, and auto-blocks).
	*
	* @param Title $title
	* @return bool
	*/
	public function appliesToTitle( Title $title ) {
	return $this->isSitewide();
	}

	/**
	* Checks if a block applies to a particular namespace
	*
	* @since 1.33
	*
	* @param int $ns
	* @return bool
	*/
	public function appliesToNamespace( $ns ) {
	return $this->isSitewide();
	}

	/**
	* Checks if a block applies to a particular page
	*
	* This check does not consider whether `$this->isUsertalkEditAllowed`
	* returns false, as the identity of the user making the hypothetical edit
	* isn't known here (particularly in the case of IP hard blocks, range
	* blocks, and auto-blocks).
	*
	* @since 1.33
	*
	* @param int $pageId
	* @return bool
	*/
	public function appliesToPage( $pageId ) {
	return $this->isSitewide();
	}

	/**
	* Check if the block prevents a user from resetting their password
	*
	* @since 1.33
	* @return bool The block blocks password reset
	*/
	public function appliesToPasswordReset() {
	return $this->isCreateAccountBlocked();
	}

	/**
	* @return AbstractBlock[]
	*/
	public function toArray(): array {
	return [ $this ];
	}

	}

File Metadata

Mime Type: text/x-php
Expires: Fri, Jul 3, 17:46 (20 h, 49 m)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 32/96/6660d6b343de7ec16b0df6ab0c93
Default Alt Text: AbstractBlock.php (15 KB)

AbstractBlock.phpNo OneTemporaryActions

AbstractBlock.phpView Options

File Metadata

Event Timeline

AbstractBlock.php
No OneTemporary
Actions

AbstractBlock.php
View Options