UserRightsProxy.php

Go to the documentation of this file.

<?php
class UserRightsProxy {

        private function __construct( $db, $database, $name, $id ) {
                $this->db = $db;
                $this->database = $database;
                $this->name = $name;
                $this->id = intval( $id );
                $this->newOptions = array();
        }

        public function getDBName() {
                return $this->database;
        }

        public static function validDatabase( $database ) {
                global $wgLocalDatabases;
                return in_array( $database, $wgLocalDatabases );
        }

        public static function whoIs( $database, $id, $ignoreInvalidDB = false ) {
                $user = self::newFromId( $database, $id, $ignoreInvalidDB );
                if( $user ) {
                        return $user->name;
                } else {
                        return false;
                }
        }

        public static function newFromId( $database, $id, $ignoreInvalidDB = false ) {
                return self::newFromLookup( $database, 'user_id', intval( $id ), $ignoreInvalidDB );
        }

        public static function newFromName( $database, $name, $ignoreInvalidDB = false ) {
                return self::newFromLookup( $database, 'user_name', $name, $ignoreInvalidDB );
        }

        private static function newFromLookup( $database, $field, $value, $ignoreInvalidDB = false ) {
                $db = self::getDB( $database, $ignoreInvalidDB );
                if( $db ) {
                        $row = $db->selectRow( 'user',
                                array( 'user_id', 'user_name' ),
                                array( $field => $value ),
                                __METHOD__ );
                        if( $row !== false ) {
                                return new UserRightsProxy( $db, $database,
                                        $row->user_name,
                                        intval( $row->user_id ) );
                        }
                }
                return null;
        }

        public static function getDB( $database, $ignoreInvalidDB = false ) {
                global $wgDBname;
                if( self::validDatabase( $database ) ) {
                        if( $database == $wgDBname ) {
                                // Hmm... this shouldn't happen though. :)
                                return wfGetDB( DB_MASTER );
                        } else {
                                return wfGetDB( DB_MASTER, array(), $database );
                        }
                }
                return null;
        }

        public function getId() {
                return $this->id;
        }

        public function isAnon() {
                return $this->getId() == 0;
        }

        public function getName() {
                return $this->name . '@' . $this->database;
        }

        public function getUserPage() {
                return Title::makeTitle( NS_USER, $this->getName() );
        }

        function getGroups() {
                $res = $this->db->select( 'user_groups',
                        array( 'ug_group' ),
                        array( 'ug_user' => $this->id ),
                        __METHOD__ );
                $groups = array();
                foreach ( $res as $row ) {
                        $groups[] = $row->ug_group;
                }
                return $groups;
        }

        function addGroup( $group ) {
                $this->db->insert( 'user_groups',
                        array(
                                'ug_user' => $this->id,
                                'ug_group' => $group,
                        ),
                        __METHOD__,
                        array( 'IGNORE' ) );
        }

        function removeGroup( $group ) {
                $this->db->delete( 'user_groups',
                        array(
                                'ug_user' => $this->id,
                                'ug_group' => $group,
                        ),
                        __METHOD__ );
        }

        public function setOption( $option, $value ) {
                $this->newOptions[$option] = $value;
        }

        public function saveSettings() {
                $rows = array();
                foreach ( $this->newOptions as $option => $value ) {
                        $rows[] = array(
                                'up_user' => $this->id,
                                'up_property' => $option,
                                'up_value' => $value,
                        );
                }
                $this->db->replace( 'user_properties',
                        array( array( 'up_user', 'up_property' ) ),
                        $rows, __METHOD__
                );
                $this->invalidateCache();
        }

        function invalidateCache() {
                $this->db->update( 'user',
                        array( 'user_touched' => $this->db->timestamp() ),
                        array( 'user_id' => $this->id ),
                        __METHOD__ );

                global $wgMemc;
                $key = wfForeignMemcKey( $this->database, false, 'user', 'id', $this->id );
                $wgMemc->delete( $key );
        }
}