UserRightsProxy.php

Go to the documentation of this file.

<?php
use MediaWiki\MediaWikiServices;
use MediaWiki\User\UserGroupManager;
use MediaWiki\User\UserIdentityValue;
use Wikimedia\Rdbms\IDatabase;
 
class UserRightsProxy {
    private $db;
    private $dbDomain;
    private $name;
    private $id;
    private $newOptions;
    private $userGroupManager;
 
    private function __construct( $db, $dbDomain, $name, $id ) {
        $this->db = $db;
        $this->dbDomain = $dbDomain;
        $this->name = $name;
        $this->id = intval( $id );
        $this->newOptions = [];
        $this->userGroupManager = MediaWikiServices::getInstance()
            ->getUserGroupManagerFactory()
            ->getUserGroupManager( $dbDomain );
    }
 
    public static function validDatabase( $dbDomain ) {
        global $wgLocalDatabases;
        return in_array( $dbDomain, $wgLocalDatabases );
    }
 
    public static function whoIs( $dbDomain, $id, $ignoreInvalidDB = false ) {
        $user = self::newFromId( $dbDomain, $id, $ignoreInvalidDB );
        if ( $user ) {
            return $user->name;
        } else {
            return false;
        }
    }
 
    public static function newFromId( $dbDomain, $id, $ignoreInvalidDB = false ) {
        return self::newFromLookup( $dbDomain, 'user_id', intval( $id ), $ignoreInvalidDB );
    }
 
    public static function newFromName( $dbDomain, $name, $ignoreInvalidDB = false ) {
        return self::newFromLookup( $dbDomain, 'user_name', $name, $ignoreInvalidDB );
    }
 
    private static function newFromLookup( $dbDomain, $field, $value, $ignoreInvalidDB = false ) {
        global $wgSharedDB, $wgSharedTables;
        // If the user table is shared, perform the user query on it,
        // but don't pass it to the UserRightsProxy,
        // as user rights are normally not shared.
        if ( $wgSharedDB && in_array( 'user', $wgSharedTables ) ) {
            $userdb = self::getDB( $wgSharedDB, $ignoreInvalidDB );
        } else {
            $userdb = self::getDB( $dbDomain, $ignoreInvalidDB );
        }
 
        $db = self::getDB( $dbDomain, $ignoreInvalidDB );
 
        if ( $db && $userdb ) {
            $row = $userdb->selectRow( 'user',
                [ 'user_id', 'user_name' ],
                [ $field => $value ],
                __METHOD__ );
 
            if ( $row !== false ) {
                return new UserRightsProxy(
                    $db, $dbDomain, $row->user_name, intval( $row->user_id ) );
            }
        }
        return null;
    }
 
    public static function getDB( $dbDomain, $ignoreInvalidDB = false ) {
        if ( $ignoreInvalidDB || self::validDatabase( $dbDomain ) ) {
            if ( WikiMap::isCurrentWikiId( $dbDomain ) ) {
                // Hmm... this shouldn't happen though. :)
                return wfGetDB( DB_MASTER );
            } else {
                return wfGetDB( DB_MASTER, [], $dbDomain );
            }
        }
        return null;
    }
 
    public function getId() {
        return $this->id;
    }
 
    public function isAnon() {
        return $this->getId() == 0;
    }
 
    public function getName() {
        return $this->name . '@' . $this->dbDomain;
    }
 
    public function getUserPage() {
        return Title::makeTitle( NS_USER, $this->getName() );
    }
 
    public function getGroups() {
        return array_keys( self::getGroupMemberships() );
    }
 
    public function getGroupMemberships() {
        // TODO: We are creating an artificial UserIdentity to pass on to the user group manager.
        // After all the relevant UserGroupMemberships methods are ported into UserGroupManager,
        // the usages of this class will be changed into usages of the UserGroupManager,
        // thus the need of this class and the need of this artificial UserIdentityValue will parish.
        $user = new UserIdentityValue( $this->getId(), $this->getName(), 0 );
        return $this->userGroupManager->getUserGroupMemberships( $user, IDBAccessObject::READ_LATEST );
    }
 
    public function addGroup( $group, $expiry = null ) {
        return $this->userGroupManager->addUserToGroup(
            // TODO: Artificial UserIdentity just for passing the id and name.
            // see comment in getGroupMemberships.
            new UserIdentityValue( $this->getId(), $this->getName(), 0 ),
            $group,
            $expiry,
            true
        );
    }
 
    public function removeGroup( $group ) {
        return $this->userGroupManager->removeUserFromGroup(
            // TODO: Artificial UserIdentity just for passing the id and name.
            // see comment in getGroupMemberships.
            new UserIdentityValue( $this->getId(), $this->getName(), 0 ),
            $group
        );
    }
 
    public function setOption( $option, $value ) {
        $this->newOptions[$option] = $value;
    }
 
    public function saveSettings() {
        $rows = [];
        foreach ( $this->newOptions as $option => $value ) {
            $rows[] = [
                'up_user' => $this->id,
                'up_property' => $option,
                'up_value' => $value,
            ];
        }
        $this->db->replace(
            'user_properties',
            [ [ 'up_user', 'up_property' ] ],
            $rows,
            __METHOD__
        );
        $this->invalidateCache();
    }
 
    public function invalidateCache() {
        $this->db->update(
            'user',
            [ 'user_touched' => $this->db->timestamp() ],
            [ 'user_id' => $this->id ],
            __METHOD__
        );
 
        $domainId = $this->db->getDomainID();
        $userId = $this->id;
        $this->db->onTransactionPreCommitOrIdle(
            function () use ( $domainId, $userId ) {
                User::purge( $domainId, $userId );
            },
            __METHOD__
        );
    }
}