UserFactory.php

Go to the documentation of this file.

<?php
namespace MediaWiki\User;
 
use DBAccessObjectUtils;
use IDBAccessObject;
use InvalidArgumentException;
use MediaWiki\Permissions\Authority;
use stdClass;
use User;
use Wikimedia\Rdbms\ILoadBalancer;
 
class UserFactory implements IDBAccessObject, UserRigorOptions {
 
    private $loadBalancer;
 
    private $userNameUtils;
 
    private $lastUserFromIdentity = null;
 
    public function __construct(
        ILoadBalancer $loadBalancer,
        UserNameUtils $userNameUtils
    ) {
        $this->loadBalancer = $loadBalancer;
        $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
    ) {
        list( $index, $options ) = DBAccessObjectUtils::getDBOptions( $flags );
 
        $db = $this->loadBalancer->getConnectionRef( $index );
 
        $id = $db->selectField(
            'user',
            'user_id',
            [
                'user_email_token' => md5( $confirmationCode ),
                'user_email_token_expires > ' . $db->addQuotes( $db->timestamp() ),
            ],
            __METHOD__,
            $options
        );
 
        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 );
        return $user;
    }
}