CentralIdLookup.php

Go to the documentation of this file.

<?php
use Wikimedia\ObjectFactory;
 
abstract class CentralIdLookup implements IDBAccessObject {
    // Audience options for accessors
    public const AUDIENCE_PUBLIC = 1;
    public const AUDIENCE_RAW = 2;
 
    private static $instances = [];
 
    private $providerId;
 
    public static function factory( $providerId = null ) {
        global $wgCentralIdLookupProviders, $wgCentralIdLookupProvider;
 
        if ( $providerId === null ) {
            $providerId = $wgCentralIdLookupProvider;
        }
 
        if ( !array_key_exists( $providerId, self::$instances ) ) {
            self::$instances[$providerId] = null;
 
            if ( isset( $wgCentralIdLookupProviders[$providerId] ) ) {
                $provider = ObjectFactory::getObjectFromSpec( $wgCentralIdLookupProviders[$providerId] );
                if ( $provider instanceof CentralIdLookup ) {
                    $provider->providerId = $providerId;
                    self::$instances[$providerId] = $provider;
                }
            }
        }
 
        return self::$instances[$providerId];
    }
 
    public static function factoryNonLocal(): ?self {
        $centralIdLookup = self::factory();
 
        if ( $centralIdLookup instanceof LocalIdLookup ) {
            /*
             * A LocalIdLookup (which is the default) may actually be non-local,
             * if shared user tables are used.
             * However, we cannot know that here, so play it safe and refuse to return it.
             * See also T163277 and T170996.
             */
            return null;
        }
 
        return $centralIdLookup;
    }
 
    public static function resetCache() {
        if ( !defined( 'MW_PHPUNIT_TEST' ) ) {
            throw new MWException( __METHOD__ . ' may only be called from unit tests!' );
        }
        self::$instances = [];
    }
 
    final public function getProviderId() {
        return $this->providerId;
    }
 
    protected function checkAudience( $audience ) {
        if ( $audience instanceof User ) {
            return $audience;
        }
        if ( $audience === self::AUDIENCE_PUBLIC ) {
            return new User;
        }
        if ( $audience === self::AUDIENCE_RAW ) {
            return null;
        }
        throw new InvalidArgumentException( 'Invalid audience' );
    }
 
    abstract public function isAttached( User $user, $wikiId = null );
 
    abstract public function lookupCentralIds(
        array $idToName, $audience = self::AUDIENCE_PUBLIC, $flags = self::READ_NORMAL
    );
 
    abstract public function lookupUserNames(
        array $nameToId, $audience = self::AUDIENCE_PUBLIC, $flags = self::READ_NORMAL
    );
 
    public function nameFromCentralId(
        $id, $audience = self::AUDIENCE_PUBLIC, $flags = self::READ_NORMAL
    ) {
        $idToName = $this->lookupCentralIds( [ $id => null ], $audience, $flags );
        return $idToName[$id];
    }
 
    public function namesFromCentralIds(
        array $ids, $audience = self::AUDIENCE_PUBLIC, $flags = self::READ_NORMAL
    ) {
        $idToName = array_fill_keys( $ids, false );
        $names = $this->lookupCentralIds( $idToName, $audience, $flags );
        $names = array_unique( $names );
        $names = array_filter( $names, function ( $name ) {
            return $name !== false && $name !== '';
        } );
 
        return array_values( $names );
    }
 
    public function centralIdFromName(
        $name, $audience = self::AUDIENCE_PUBLIC, $flags = self::READ_NORMAL
    ) {
        $nameToId = $this->lookupUserNames( [ $name => 0 ], $audience, $flags );
        return $nameToId[$name];
    }
 
    public function centralIdsFromNames(
        array $names, $audience = self::AUDIENCE_PUBLIC, $flags = self::READ_NORMAL
    ) {
        $nameToId = array_fill_keys( $names, false );
        $ids = $this->lookupUserNames( $nameToId, $audience, $flags );
        $ids = array_unique( $ids );
        $ids = array_filter( $ids, function ( $id ) {
            return $id !== false;
        } );
 
        return array_values( $ids );
    }
 
    public function localUserFromCentralId(
        $id, $audience = self::AUDIENCE_PUBLIC, $flags = self::READ_NORMAL
    ) {
        $name = $this->nameFromCentralId( $id, $audience, $flags );
        if ( $name !== null && $name !== '' ) {
            $user = User::newFromName( $name );
            if ( $user && $user->getId() && $this->isAttached( $user ) ) {
                return $user;
            }
        }
        return null;
    }
 
    public function centralIdFromLocalUser(
        User $user, $audience = self::AUDIENCE_PUBLIC, $flags = self::READ_NORMAL
    ) {
        return $this->isAttached( $user )
            ? $this->centralIdFromName( $user->getName(), $audience, $flags )
            : 0;
    }
 
}