UserFactory.php

Go to the documentation of this file.

<?php
namespace MediaWiki\User;
 
use DBAccessObjectUtils;
use IDBAccessObject;
use InvalidArgumentException;
use MediaWiki\Config\ServiceOptions;
use MediaWiki\MainConfigNames;
use MediaWiki\Permissions\Authority;
use stdClass;
use Wikimedia\Rdbms\IDatabase;
use Wikimedia\Rdbms\ILBFactory;
use Wikimedia\Rdbms\ILoadBalancer;
 
class UserFactory implements IDBAccessObject, UserRigorOptions {
 
    public const CONSTRUCTOR_OPTIONS = [
        MainConfigNames::SharedDB,
        MainConfigNames::SharedTables,
    ];
 
    private $options;
 
    private $loadBalancerFactory;
 
    private $loadBalancer;
 
    private $userNameUtils;
 
    private $lastUserFromIdentity = null;
 
    public function __construct(
        ServiceOptions $options,
        ILBFactory $loadBalancerFactory,
        UserNameUtils $userNameUtils
    ) {
        $options->assertRequiredOptions( self::CONSTRUCTOR_OPTIONS );
        $this->options = $options;
        $this->loadBalancerFactory = $loadBalancerFactory;
        $this->loadBalancer = $loadBalancerFactory->getMainLB();
        $this->userNameUtils = $userNameUtils;
    }
 
    public function newFromName(
        string $name,
        string $validate = self::RIGOR_VALID
    ): ?User {
        // RIGOR_* constants are the same here and in the UserNameUtils class
        $canonicalName = $this->userNameUtils->getCanonical( $name, $validate );
        if ( $canonicalName === false ) {
            return null;
        }
 
        $user = new User();
        $user->mName = $canonicalName;
        $user->mFrom = 'name';
        $user->setItemLoaded( 'name' );
        return $user;
    }
 
    public function newAnonymous( ?string $ip = null ): User {
        if ( $ip ) {
            if ( !$this->userNameUtils->isIP( $ip ) ) {
                throw new InvalidArgumentException( 'Invalid IP address' );
            }
            $user = new User();
            $user->setName( $ip );
        } else {
            $user = new User();
        }
        return $user;
    }
 
    public function newFromId( int $id ): User {
        $user = new User();
        $user->mId = $id;
        $user->mFrom = 'id';
        $user->setItemLoaded( 'id' );
        return $user;
    }
 
    public function newFromActorId( int $actorId ): User {
        $user = new User();
        $user->mActorId = $actorId;
        $user->mFrom = 'actor';
        $user->setItemLoaded( 'actor' );
        return $user;
    }
 
    public function newFromUserIdentity( UserIdentity $userIdentity ): User {
        if ( $userIdentity instanceof User ) {
            return $userIdentity;
        }
 
        $id = $userIdentity->getId();
        $name = $userIdentity->getName();
        // Cache the $userIdentity we converted last. This avoids redundant conversion
        // in cases where we would be converting the same UserIdentity over and over,
        // for instance because we need to access data preferences when formatting
        // timestamps in a listing.
        if (
            $this->lastUserFromIdentity
            && $this->lastUserFromIdentity->getId() === $id
            && $this->lastUserFromIdentity->getName() === $name
        ) {
            return $this->lastUserFromIdentity;
        }
 
        $this->lastUserFromIdentity = $this->newFromAnyId(
            $id === 0 ? null : $id,
            $name === '' ? null : $name,
            null
        );
 
        return $this->lastUserFromIdentity;
    }
 
    public function newFromAnyId(
        ?int $userId,
        ?string $userName,
        ?int $actorId = null,
        $dbDomain = false
    ): User {
        // Stop-gap solution for the problem described in T222212.
        // Force the User ID and Actor ID to zero for users loaded from the database
        // of another wiki, to prevent subtle data corruption and confusing failure modes.
        if ( $dbDomain !== false ) {
            $userId = 0;
            $actorId = 0;
        }
 
        $user = new User;
        $user->mFrom = 'defaults';
 
        if ( $actorId !== null ) {
            $user->mActorId = $actorId;
            if ( $actorId !== 0 ) {
                $user->mFrom = 'actor';
            }
            $user->setItemLoaded( 'actor' );
        }
 
        if ( $userName !== null && $userName !== '' ) {
            $user->mName = $userName;
            $user->mFrom = 'name';
            $user->setItemLoaded( 'name' );
        }
 
        if ( $userId !== null ) {
            $user->mId = $userId;
            if ( $userId !== 0 ) {
                $user->mFrom = 'id';
            }
            $user->setItemLoaded( 'id' );
        }
 
        if ( $user->mFrom === 'defaults' ) {
            throw new InvalidArgumentException(
                'Cannot create a user with no name, no ID, and no actor ID'
            );
        }
 
        return $user;
    }
 
    public function newFromConfirmationCode(
        string $confirmationCode,
        int $flags = self::READ_NORMAL
    ) {
        [ $index, $options ] = DBAccessObjectUtils::getDBOptions( $flags );
 
        $db = $this->loadBalancer->getConnectionRef( $index );
 
        $id = $db->newSelectQueryBuilder()
            ->select( 'user_id' )
            ->from( 'user' )
            ->where( [ 'user_email_token' => md5( $confirmationCode ) ] )
            ->andWhere( $db->expr( 'user_email_token_expires', '>', $db->timestamp() ) )
            ->options( $options )
            ->caller( __METHOD__ )->fetchField();
 
        if ( !$id ) {
            return null;
        }
 
        return $this->newFromId( (int)$id );
    }
 
    public function newFromRow( $row, $data = null ) {
        return User::newFromRow( $row, $data );
    }
 
    public function newFromAuthority( Authority $authority ): User {
        if ( $authority instanceof User ) {
            return $authority;
        }
        return $this->newFromUserIdentity( $authority->getUser() );
    }
 
    public function newTempPlaceholder() {
        $user = new User();
        $user->setName( $this->userNameUtils->getTempPlaceholder() );
        return $user;
    }
 
    public function newUnsavedTempUser( ?string $name ) {
        $user = new User();
        $user->setName( $name ?? $this->userNameUtils->getTempPlaceholder() );
        return $user;
    }
 
    public function invalidateCache( UserIdentity $userIdentity ) {
        if ( !$userIdentity->isRegistered() ) {
            return;
        }
 
        $wikiId = $userIdentity->getWikiId();
        if ( $wikiId === UserIdentity::LOCAL ) {
            $legacyUser = $this->newFromUserIdentity( $userIdentity );
            // Update user_touched within User class to manage state of User::mTouched for CAS check
            $legacyUser->invalidateCache();
        } else {
            // cross-wiki invalidation
            $userId = $userIdentity->getId( $wikiId );
 
            $dbw = $this->getUserTableConnection( ILoadBalancer::DB_PRIMARY, $wikiId );
            $dbw->newUpdateQueryBuilder()
                ->update( 'user' )
                ->set( [ 'user_touched' => $dbw->timestamp() ] )
                ->where( [ 'user_id' => $userId ] )
                ->caller( __METHOD__ )->execute();
 
            $dbw->onTransactionPreCommitOrIdle(
                static function () use ( $wikiId, $userId ) {
                    User::purge( $wikiId, $userId );
                },
                __METHOD__
            );
        }
    }
 
    private function getUserTableConnection( $mode, $wikiId ) {
        if ( is_string( $wikiId ) && $this->loadBalancerFactory->getLocalDomainID() === $wikiId ) {
            $wikiId = UserIdentity::LOCAL;
        }
 
        if ( $this->options->get( MainConfigNames::SharedDB ) &&
            in_array( 'user', $this->options->get( MainConfigNames::SharedTables ) )
        ) {
            // The main LB is aliased for the shared database in Setup.php
            $lb = $this->loadBalancer;
        } else {
            $lb = $this->loadBalancerFactory->getMainLB( $wikiId );
        }
 
        return $lb->getConnection( $mode, [], $wikiId );
    }
}