includes/UserRightsProxy.php

   1 <?php
   2
   3
   4 /**
   5  * Cut-down copy of User interface for local-interwiki-database
   6  * user rights manipulation.
   7  */
   8 class UserRightsProxy {
   9         private function __construct( $db, $database, $name, $id ) {
  10                 $this->db = $db;
  11                 $this->database = $database;
  12                 $this->name = $name;
  13                 $this->id = intval( $id );
  14         }
  15
  16         /**
  17          * Confirm the selected database name is a valid local interwiki database name.
  18          * @return bool
  19          */
  20         public static function validDatabase( $database ) {
  21                 global $wgLocalDatabases;
  22                 return in_array( $database, $wgLocalDatabases );
  23         }
  24
  25         public static function whoIs( $database, $id ) {
  26                 $user = self::newFromId( $database, $id );
  27                 if( $user ) {
  28                         return $user->name;
  29                 } else {
  30                         return false;
  31                 }
  32         }
  33
  34         /**
  35          * Factory function; get a remote user entry by ID number.
  36          * @return UserRightsProxy or null if doesn't exist
  37          */
  38         public static function newFromId( $database, $id ) {
  39                 return self::newFromLookup( $database, 'user_id', intval( $id ) );
  40         }
  41
  42         public static function newFromName( $database, $name ) {
  43                 return self::newFromLookup( $database, 'user_name', $name );
  44         }
  45
  46         private static function newFromLookup( $database, $field, $value ) {
  47                 $db = self::getDB( $database );
  48                 if( $db ) {
  49                         $row = $db->selectRow( 'user',
  50                                 array( 'user_id', 'user_name' ),
  51                                 array( $field => $value ),
  52                                 __METHOD__ );
  53                         if( $row !== false ) {
  54                                 return new UserRightsProxy( $db, $database,
  55                                         $row->user_name,
  56                                         intval( $row->user_id ) );
  57                         }
  58                 }
  59                 return null;
  60         }
  61
  62         /**
  63          * Open a database connection to work on for the requested user.
  64          * This may be a new connection to another database for remote users.
  65          * @param $database string
  66          * @return Database or null if invalid selection
  67          */
  68         public static function getDB( $database ) {
  69                 global $wgLocalDatabases, $wgDBname;
  70                 if( self::validDatabase( $database ) ) {
  71                         if( $database == $wgDBname ) {
  72                                 // Hmm... this shouldn't happen though. :)
  73                                 return wfGetDB( DB_MASTER );
  74                         } else {
  75                                 return wfGetDB( DB_MASTER, array(), $database );
  76                         }
  77                 }
  78                 return null;
  79         }
  80
  81         public function getId() {
  82                 return $this->id;
  83         }
  84
  85         public function isAnon() {
  86                 return $this->getId() == 0;
  87         }
  88
  89         public function getName() {
  90                 return $this->name . '@' . $this->database;
  91         }
  92
  93         public function getUserPage() {
  94                 return Title::makeTitle( NS_USER, $this->getName() );
  95         }
  96
  97         // Replaces getUserGroups()
  98         function getGroups() {
  99                 $res = $this->db->select( 'user_groups',
 100                         array( 'ug_group' ),
 101                         array( 'ug_user' => $this->id ),
 102                         __METHOD__ );
 103                 $groups = array();
 104                 while( $row = $this->db->fetchObject( $res ) ) {
 105                         $groups[] = $row->ug_group;
 106                 }
 107                 return $groups;
 108         }
 109
 110         // replaces addUserGroup
 111         function addGroup( $group ) {
 112                 $this->db->insert( 'user_groups',
 113                         array(
 114                                 'ug_user' => $this->id,
 115                                 'ug_group' => $group,
 116                         ),
 117                         __METHOD__,
 118                         array( 'IGNORE' ) );
 119         }
 120
 121         // replaces removeUserGroup
 122         function removeGroup( $group ) {
 123                 $this->db->delete( 'user_groups',
 124                         array(
 125                                 'ug_user' => $this->id,
 126                                 'ug_group' => $group,
 127                         ),
 128                         __METHOD__ );
 129         }
 130
 131         // replaces touchUser
 132         function invalidateCache() {
 133                 $this->db->update( 'user',
 134                         array( 'user_touched' => $this->db->timestamp() ),
 135                         array( 'user_id' => $this->id ),
 136                         __METHOD__ );
 137
 138                 global $wgMemc;
 139                 if ( function_exists( 'wfForeignMemcKey' ) ) {
 140                         $key = wfForeignMemcKey( $this->database, false, 'user', 'id', $this->id );
 141                 } else {
 142                         $key = "$this->database:user:id:" . $this->id;
 143                 }
 144                 $wgMemc->delete( $key );
 145         }
 146 }