[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3   * Representation of an user on a other locally-hosted wiki.
   4   *
   5   * This program is free software; you can redistribute it and/or modify
   6   * it under the terms of the GNU General Public License as published by
   7   * the Free Software Foundation; either version 2 of the License, or
   8   * (at your option) any later version.
   9   *
  10   * This program is distributed in the hope that it will be useful,
  11   * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13   * GNU General Public License for more details.
  14   *
  15   * You should have received a copy of the GNU General Public License along
  16   * with this program; if not, write to the Free Software Foundation, Inc.,
  17   * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18   * http://www.gnu.org/copyleft/gpl.html
  19   *
  20   * @file
  21   */
  22  
  23  /**
  24   * Cut-down copy of User interface for local-interwiki-database
  25   * user rights manipulation.
  26   */
  27  class UserRightsProxy {
  28  
  29      /**
  30       * Constructor.
  31       *
  32       * @see newFromId()
  33       * @see newFromName()
  34       * @param DatabaseBase $db Db connection
  35       * @param string $database Database name
  36       * @param string $name User name
  37       * @param int $id User ID
  38       */
  39  	private function __construct( $db, $database, $name, $id ) {
  40          $this->db = $db;
  41          $this->database = $database;
  42          $this->name = $name;
  43          $this->id = intval( $id );
  44          $this->newOptions = array();
  45      }
  46  
  47      /**
  48       * Accessor for $this->database
  49       *
  50       * @return string Database name
  51       */
  52  	public function getDBName() {
  53          return $this->database;
  54      }
  55  
  56      /**
  57       * Confirm the selected database name is a valid local interwiki database name.
  58       *
  59       * @param string $database Database name
  60       * @return bool
  61       */
  62  	public static function validDatabase( $database ) {
  63          global $wgLocalDatabases;
  64          return in_array( $database, $wgLocalDatabases );
  65      }
  66  
  67      /**
  68       * Same as User::whoIs()
  69       *
  70       * @param string $database Database name
  71       * @param int $id User ID
  72       * @param bool $ignoreInvalidDB If true, don't check if $database is in $wgLocalDatabases
  73       * @return string User name or false if the user doesn't exist
  74       */
  75  	public static function whoIs( $database, $id, $ignoreInvalidDB = false ) {
  76          $user = self::newFromId( $database, $id, $ignoreInvalidDB );
  77          if ( $user ) {
  78              return $user->name;
  79          } else {
  80              return false;
  81          }
  82      }
  83  
  84      /**
  85       * Factory function; get a remote user entry by ID number.
  86       *
  87       * @param string $database Database name
  88       * @param int $id User ID
  89       * @param bool $ignoreInvalidDB If true, don't check if $database is in $wgLocalDatabases
  90       * @return UserRightsProxy|null If doesn't exist
  91       */
  92  	public static function newFromId( $database, $id, $ignoreInvalidDB = false ) {
  93          return self::newFromLookup( $database, 'user_id', intval( $id ), $ignoreInvalidDB );
  94      }
  95  
  96      /**
  97       * Factory function; get a remote user entry by name.
  98       *
  99       * @param string $database Database name
 100       * @param string $name User name
 101       * @param bool $ignoreInvalidDB If true, don't check if $database is in $wgLocalDatabases
 102       * @return UserRightsProxy|null If doesn't exist
 103       */
 104  	public static function newFromName( $database, $name, $ignoreInvalidDB = false ) {
 105          return self::newFromLookup( $database, 'user_name', $name, $ignoreInvalidDB );
 106      }
 107  
 108      /**
 109       * @param string $database
 110       * @param string $field
 111       * @param string $value
 112       * @param bool $ignoreInvalidDB
 113       * @return null|UserRightsProxy
 114       */
 115  	private static function newFromLookup( $database, $field, $value, $ignoreInvalidDB = false ) {
 116          global $wgSharedDB, $wgSharedTables;
 117          // If the user table is shared, perform the user query on it, but don't pass it to the UserRightsProxy,
 118          // as user rights are normally not shared.
 119          if ( $wgSharedDB && in_array( 'user', $wgSharedTables ) ) {
 120              $userdb = self::getDB( $wgSharedDB, $ignoreInvalidDB );
 121          } else {
 122              $userdb = self::getDB( $database, $ignoreInvalidDB );
 123          }
 124  
 125          $db = self::getDB( $database, $ignoreInvalidDB );
 126  
 127          if ( $db && $userdb ) {
 128              $row = $userdb->selectRow( 'user',
 129                  array( 'user_id', 'user_name' ),
 130                  array( $field => $value ),
 131                  __METHOD__ );
 132  
 133              if ( $row !== false ) {
 134                  return new UserRightsProxy( $db, $database,
 135                      $row->user_name,
 136                      intval( $row->user_id ) );
 137              }
 138          }
 139          return null;
 140      }
 141  
 142      /**
 143       * Open a database connection to work on for the requested user.
 144       * This may be a new connection to another database for remote users.
 145       *
 146       * @param string $database
 147       * @param bool $ignoreInvalidDB If true, don't check if $database is in $wgLocalDatabases
 148       * @return DatabaseBase|null If invalid selection
 149       */
 150  	public static function getDB( $database, $ignoreInvalidDB = false ) {
 151          global $wgDBname;
 152          if ( $ignoreInvalidDB || self::validDatabase( $database ) ) {
 153              if ( $database == $wgDBname ) {
 154                  // Hmm... this shouldn't happen though. :)
 155                  return wfGetDB( DB_MASTER );
 156              } else {
 157                  return wfGetDB( DB_MASTER, array(), $database );
 158              }
 159          }
 160          return null;
 161      }
 162  
 163      /**
 164       * @return int
 165       */
 166  	public function getId() {
 167          return $this->id;
 168      }
 169  
 170      /**
 171       * @return bool
 172       */
 173  	public function isAnon() {
 174          return $this->getId() == 0;
 175      }
 176  
 177      /**
 178       * Same as User::getName()
 179       *
 180       * @return string
 181       */
 182  	public function getName() {
 183          return $this->name . '@' . $this->database;
 184      }
 185  
 186      /**
 187       * Same as User::getUserPage()
 188       *
 189       * @return Title
 190       */
 191  	public function getUserPage() {
 192          return Title::makeTitle( NS_USER, $this->getName() );
 193      }
 194  
 195      /**
 196       * Replaces User::getUserGroups()
 197       * @return array
 198       */
 199  	function getGroups() {
 200          $res = $this->db->select( 'user_groups',
 201              array( 'ug_group' ),
 202              array( 'ug_user' => $this->id ),
 203              __METHOD__ );
 204          $groups = array();
 205          foreach ( $res as $row ) {
 206              $groups[] = $row->ug_group;
 207          }
 208          return $groups;
 209      }
 210  
 211      /**
 212       * Replaces User::addUserGroup()
 213       * @param string $group
 214       */
 215  	function addGroup( $group ) {
 216          $this->db->insert( 'user_groups',
 217              array(
 218                  'ug_user' => $this->id,
 219                  'ug_group' => $group,
 220              ),
 221              __METHOD__,
 222              array( 'IGNORE' ) );
 223      }
 224  
 225      /**
 226       * Replaces User::removeUserGroup()
 227       * @param string $group
 228       */
 229  	function removeGroup( $group ) {
 230          $this->db->delete( 'user_groups',
 231              array(
 232                  'ug_user' => $this->id,
 233                  'ug_group' => $group,
 234              ),
 235              __METHOD__ );
 236      }
 237  
 238      /**
 239       * Replaces User::setOption()
 240       * @param string $option
 241       * @param mixed $value
 242       */
 243  	public function setOption( $option, $value ) {
 244          $this->newOptions[$option] = $value;
 245      }
 246  
 247  	public function saveSettings() {
 248          $rows = array();
 249          foreach ( $this->newOptions as $option => $value ) {
 250              $rows[] = array(
 251                  'up_user' => $this->id,
 252                  'up_property' => $option,
 253                  'up_value' => $value,
 254              );
 255          }
 256          $this->db->replace( 'user_properties',
 257              array( array( 'up_user', 'up_property' ) ),
 258              $rows, __METHOD__
 259          );
 260          $this->invalidateCache();
 261      }
 262  
 263      /**
 264       * Replaces User::touchUser()
 265       */
 266  	function invalidateCache() {
 267          $this->db->update( 'user',
 268              array( 'user_touched' => $this->db->timestamp() ),
 269              array( 'user_id' => $this->id ),
 270              __METHOD__ );
 271  
 272          global $wgMemc;
 273          $key = wfForeignMemcKey( $this->database, false, 'user', 'id', $this->id );
 274          $wgMemc->delete( $key );
 275      }
 276  }