<?php
/**
* Implements the User class for the %MediaWiki software.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ * http://www.gnu.org/copyleft/gpl.html
+ *
* @file
*/
'mEmailTokenExpires',
'mRegistration',
'mEditCount',
- // user_group table
+ // user_groups table
'mGroups',
// user_properties table
'mOptionOverrides',
'deletedhistory',
'deletedtext',
'deleterevision',
- 'disableaccount',
'edit',
'editinterface',
'editusercssjs', #deprecated
'reupload',
'reupload-shared',
'rollback',
- 'selenium',
'sendemail',
'siteadmin',
'suppressionlog',
'suppressredirect',
'suppressrevision',
- 'trackback',
+ 'unblockself',
'undelete',
'unwatchedpages',
'upload',
//@{
var $mId, $mName, $mRealName, $mPassword, $mNewpassword, $mNewpassTime,
$mEmail, $mTouched, $mToken, $mEmailAuthenticated,
- $mEmailToken, $mEmailTokenExpires, $mRegistration, $mGroups, $mOptionOverrides;
+ $mEmailToken, $mEmailTokenExpires, $mRegistration, $mGroups, $mOptionOverrides,
+ $mCookiePassword, $mEditCount, $mAllowUsertalk;
//@}
/**
*/
//@{
var $mOptionsLoaded;
+
+ /**
+ * Array with already loaded items or true if all items have been loaded.
+ */
private $mLoadedItems = array();
//@}
* Lazy-initialized variables, invalidated with clearInstanceCache
*/
var $mNewtalk, $mDatePreference, $mBlockedby, $mHash, $mRights,
- $mBlockreason, $mEffectiveGroups, $mBlockedGlobally,
- $mLocked, $mHideName, $mOptions;
+ $mBlockreason, $mEffectiveGroups, $mImplicitGroups, $mFormerGroups, $mBlockedGlobally,
+ $mLocked, $mHideName, $mOptions, $mDisplayName;
/**
- * @var Skin
+ * @var WebRequest
*/
- var $mSkin;
+ private $mRequest;
/**
* @var Block
*/
var $mBlock;
+ /**
+ * @var Block
+ */
+ private $mBlockedFromCreateAccount = false;
+
static $idCacheByName = array();
/**
$this->clearInstanceCache( 'defaults' );
}
+ /**
+ * @return String
+ */
function __toString(){
return $this->getName();
}
/**
* Load the user table data for this object from the source given by mFrom.
*/
- function load() {
+ public function load() {
if ( $this->mLoadedItems === true ) {
return;
}
/**
* Load user table data, given mId has already been set.
* @return Bool false if the ID does not exist, true otherwise
- * @private
*/
- function loadFromId() {
+ public function loadFromId() {
global $wgMemc;
if ( $this->mId == 0 ) {
$this->loadDefaults();
/**
* Save user data to the shared cache
*/
- function saveToCache() {
+ public function saveToCache() {
$this->load();
$this->loadGroups();
$this->loadOptions();
$wgMemc->set( $key, $data );
}
-
/** @name newFrom*() static factory methods */
//@{
* username is not present in the database, the result will be a user object
* with a name, zero user ID and default settings.
*/
- static function newFromName( $name, $validate = 'valid' ) {
+ public static function newFromName( $name, $validate = 'valid' ) {
if ( $validate === true ) {
$validate = 'valid';
}
* @param $id Int Valid user ID
* @return User The corresponding User object
*/
- static function newFromId( $id ) {
+ public static function newFromId( $id ) {
$u = new User;
$u->mId = $id;
$u->mFrom = 'id';
* If the code is invalid or has expired, returns NULL.
*
* @param $code String Confirmation code
- * @return User
+ * @return User object, or null
*/
- static function newFromConfirmationCode( $code ) {
+ public static function newFromConfirmationCode( $code ) {
$dbr = wfGetDB( DB_SLAVE );
$id = $dbr->selectField( 'user', 'user_id', array(
'user_email_token' => md5( $code ),
* Create a new user object using data from session or cookies. If the
* login credentials are invalid, the result is an anonymous user.
*
- * @return User
+ * @param $request WebRequest object to use; $wgRequest will be used if
+ * ommited.
+ * @return User object
*/
- static function newFromSession() {
+ public static function newFromSession( WebRequest $request = null ) {
$user = new User;
$user->mFrom = 'session';
+ $user->mRequest = $request;
return $user;
}
* @param $row Array A row from the user table
* @return User
*/
- static function newFromRow( $row ) {
+ public static function newFromRow( $row ) {
$user = new User;
$user->loadFromRow( $row );
return $user;
//@}
-
/**
* Get the username corresponding to a given user ID
* @param $id Int User ID
- * @return String The corresponding username
+ * @return String|false The corresponding username
*/
- static function whoIs( $id ) {
+ public static function whoIs( $id ) {
$dbr = wfGetDB( DB_SLAVE );
return $dbr->selectField( 'user', 'user_name', array( 'user_id' => $id ), __METHOD__ );
}
* Get the real name of a user given their user ID
*
* @param $id Int User ID
- * @return String The corresponding user's real name
+ * @return String|false The corresponding user's real name
*/
- static function whoIsReal( $id ) {
+ public static function whoIsReal( $id ) {
$dbr = wfGetDB( DB_SLAVE );
return $dbr->selectField( 'user', 'user_real_name', array( 'user_id' => $id ), __METHOD__ );
}
* @param $name String Username
* @return Int|Null The corresponding user's ID, or null if user is nonexistent
*/
- static function idFromName( $name ) {
+ public static function idFromName( $name ) {
$nt = Title::makeTitleSafe( NS_USER, $name );
if( is_null( $nt ) ) {
# Illegal name
* @param $name String to match
* @return Bool
*/
- static function isIP( $name ) {
+ public static function isIP( $name ) {
return preg_match('/^\d{1,3}\.\d{1,3}\.\d{1,3}\.(?:xxx|\d{1,3})$/',$name) || IP::isIPv6($name);
}
* @param $name String to match
* @return Bool
*/
- static function isValidUserName( $name ) {
+ public static function isValidUserName( $name ) {
global $wgContLang, $wgMaxNameChars;
if ( $name == ''
return false;
}
+
// Ensure that the name can't be misresolved as a different title,
// such as with extra namespace keys at the start.
$parsed = Title::newFromText( $name );
* @param $name String to match
* @return Bool
*/
- static function isUsableName( $name ) {
+ public static function isUsableName( $name ) {
global $wgReservedUsernames;
// Must be a valid username, obviously ;)
if ( !self::isValidUserName( $name ) ) {
* @param $name String to match
* @return Bool
*/
- static function isCreatableName( $name ) {
+ public static function isCreatableName( $name ) {
global $wgInvalidUsernameCharacters;
// Ensure that the username isn't longer than 235 bytes, so that
* @param $password String Desired password
* @return Bool
*/
- function isValidPassword( $password ) {
+ public function isValidPassword( $password ) {
//simple boolean wrapper for getPasswordValidity
return $this->getPasswordValidity( $password ) === true;
}
* @param $password String Desired password
* @return mixed: true on success, string or array of error message on failure
*/
- function getPasswordValidity( $password ) {
+ public function getPasswordValidity( $password ) {
global $wgMinimalPasswordLength, $wgContLang;
static $blockedLogins = array(
* @deprecated since 1.18 call Sanitizer::isValidEmail() directly
*/
public static function isValidEmailAddr( $addr ) {
+ wfDeprecated( __METHOD__, '1.18' );
return Sanitizer::validateEmail( $addr );
}
* - 'valid' Valid for batch processes
* - 'usable' Valid for batch processes and login
* - 'creatable' Valid for batch processes, login and account creation
+ *
+ * @return bool|string
*/
- static function getCanonicalName( $name, $validate = 'valid' ) {
+ public static function getCanonicalName( $name, $validate = 'valid' ) {
# Force usernames to capital
global $wgContLang;
$name = $wgContLang->ucfirst( $name );
* @param $uid Int User ID to check
* @return Int the user's edit count
*/
- static function edits( $uid ) {
+ public static function edits( $uid ) {
wfProfileIn( __METHOD__ );
$dbr = wfGetDB( DB_SLAVE );
// check if the user_editcount field has been initialized
*
* @return String new random password
*/
- static function randomPassword() {
+ public static function randomPassword() {
global $wgMinimalPasswordLength;
$pwchars = 'ABCDEFGHJKLMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz';
$l = strlen( $pwchars ) - 1;
*
* @note This no longer clears uncached lazy-initialised properties;
* the constructor does that instead.
- * @private
+ *
+ * @param $name string
*/
- function loadDefaults( $name = false ) {
+ public function loadDefaults( $name = false ) {
wfProfileIn( __METHOD__ );
- global $wgRequest;
-
$this->mId = 0;
$this->mName = $name;
$this->mRealName = '';
$this->mOptionOverrides = null;
$this->mOptionsLoaded = false;
- if( $wgRequest->getCookie( 'LoggedOut' ) !== null ) {
- $this->mTouched = wfTimestamp( TS_MW, $wgRequest->getCookie( 'LoggedOut' ) );
+ $loggedOut = $this->getRequest()->getCookie( 'LoggedOut' );
+ if( $loggedOut !== null ) {
+ $this->mTouched = wfTimestamp( TS_MW, $loggedOut );
} else {
$this->mTouched = '0'; # Allow any pages to be cached
}
* @return Bool True if the user is logged in, false otherwise.
*/
private function loadFromSession() {
- global $wgRequest, $wgExternalAuthType, $wgAutocreatePolicy;
+ global $wgExternalAuthType, $wgAutocreatePolicy;
$result = null;
wfRunHooks( 'UserLoadFromSession', array( $this, &$result ) );
}
}
- $cookieId = $wgRequest->getCookie( 'UserID' );
- $sessId = $wgRequest->getSessionData( 'wsUserID' );
+ $request = $this->getRequest();
+
+ $cookieId = $request->getCookie( 'UserID' );
+ $sessId = $request->getSessionData( 'wsUserID' );
if ( $cookieId !== null ) {
$sId = intval( $cookieId );
cookie user ID ($sId) don't match!" );
return false;
}
- $wgRequest->setSessionData( 'wsUserID', $sId );
- } else if ( $sessId !== null && $sessId != 0 ) {
+ $request->setSessionData( 'wsUserID', $sId );
+ } elseif ( $sessId !== null && $sessId != 0 ) {
$sId = $sessId;
} else {
$this->loadDefaults();
return false;
}
- if ( $wgRequest->getSessionData( 'wsUserName' ) !== null ) {
- $sName = $wgRequest->getSessionData( 'wsUserName' );
- } else if ( $wgRequest->getCookie( 'UserName' ) !== null ) {
- $sName = $wgRequest->getCookie( 'UserName' );
- $wgRequest->setSessionData( 'wsUserName', $sName );
+ if ( $request->getSessionData( 'wsUserName' ) !== null ) {
+ $sName = $request->getSessionData( 'wsUserName' );
+ } elseif ( $request->getCookie( 'UserName' ) !== null ) {
+ $sName = $request->getCookie( 'UserName' );
+ $request->setSessionData( 'wsUserName', $sName );
} else {
$this->loadDefaults();
return false;
}
- $this->mId = $sId;
- if ( !$this->loadFromId() ) {
- # Not a valid ID, loadFromId has switched the object to anon for us
+ $proposedUser = User::newFromId( $sId );
+ if ( !$proposedUser->isLoggedIn() ) {
+ # Not a valid ID
+ $this->loadDefaults();
return false;
}
global $wgBlockDisablesLogin;
- if( $wgBlockDisablesLogin && $this->isBlocked() ) {
+ if( $wgBlockDisablesLogin && $proposedUser->isBlocked() ) {
# User blocked and we've disabled blocked user logins
$this->loadDefaults();
return false;
}
- if ( $wgRequest->getSessionData( 'wsToken' ) !== null ) {
- $passwordCorrect = $this->mToken == $wgRequest->getSessionData( 'wsToken' );
+ if ( $request->getSessionData( 'wsToken' ) !== null ) {
+ $passwordCorrect = $proposedUser->getToken() === $request->getSessionData( 'wsToken' );
$from = 'session';
- } else if ( $wgRequest->getCookie( 'Token' ) !== null ) {
- $passwordCorrect = $this->mToken == $wgRequest->getCookie( 'Token' );
+ } elseif ( $request->getCookie( 'Token' ) !== null ) {
+ $passwordCorrect = $proposedUser->getToken() === $request->getCookie( 'Token' );
$from = 'cookie';
} else {
# No session or persistent login cookie
return false;
}
- if ( ( $sName == $this->mName ) && $passwordCorrect ) {
- $wgRequest->setSessionData( 'wsToken', $this->mToken );
+ if ( ( $sName === $proposedUser->getName() ) && $passwordCorrect ) {
+ $this->loadFromUserObject( $proposedUser );
+ $request->setSessionData( 'wsToken', $this->mToken );
wfDebug( "User: logged in from $from\n" );
return true;
} else {
* $this->mId must be set, this is how the user is identified.
*
* @return Bool True if the user exists, false if the user is anonymous
- * @private
*/
- function loadFromDatabase() {
+ public function loadFromDatabase() {
# Paranoia
$this->mId = intval( $this->mId );
*
* @param $row Array Row from the user table to load.
*/
- function loadFromRow( $row ) {
+ public function loadFromRow( $row ) {
$all = true;
+ $this->mGroups = null; // deferred
+
if ( isset( $row->user_name ) ) {
$this->mName = $row->user_name;
$this->mFrom = 'name';
$all = false;
}
- if ( isset( $row->user_name ) ) {
+ if ( isset( $row->user_real_name ) ) {
$this->mRealName = $row->user_real_name;
$this->setItemLoaded( 'realname' );
} else {
$all = false;
}
+ if ( isset( $row->user_editcount ) ) {
+ $this->mEditCount = $row->user_editcount;
+ } else {
+ $all = false;
+ }
+
if ( isset( $row->user_password ) ) {
$this->mPassword = $row->user_password;
$this->mNewpassword = $row->user_newpassword;
$this->mNewpassTime = wfTimestampOrNull( TS_MW, $row->user_newpass_time );
$this->mEmail = $row->user_email;
- $this->decodeOptions( $row->user_options );
- $this->mTouched = wfTimestamp(TS_MW,$row->user_touched);
+ if ( isset( $row->user_options ) ) {
+ $this->decodeOptions( $row->user_options );
+ }
+ $this->mTouched = wfTimestamp( TS_MW, $row->user_touched );
$this->mToken = $row->user_token;
$this->mEmailAuthenticated = wfTimestampOrNull( TS_MW, $row->user_email_authenticated );
$this->mEmailToken = $row->user_email_token;
$this->mEmailTokenExpires = wfTimestampOrNull( TS_MW, $row->user_email_token_expires );
$this->mRegistration = wfTimestampOrNull( TS_MW, $row->user_registration );
- $this->mEditCount = $row->user_editcount;
} else {
$all = false;
}
}
}
+ /**
+ * Load the data for this user object from another user object.
+ *
+ * @param $user User
+ */
+ protected function loadFromUserObject( $user ) {
+ $user->load();
+ $user->loadGroups();
+ $user->loadOptions();
+ foreach ( self::$mCacheVars as $var ) {
+ $this->$var = $user->$var;
+ }
+ }
+
/**
* Load the groups from the database if they aren't already loaded.
- * @private
*/
- function loadGroups() {
+ private function loadGroups() {
if ( is_null( $this->mGroups ) ) {
$dbr = wfGetDB( DB_MASTER );
$res = $dbr->select( 'user_groups',
}
}
+ /**
+ * Add the user to the group if he/she meets given criteria.
+ *
+ * Contrary to autopromotion by \ref $wgAutopromote, the group will be
+ * possible to remove manually via Special:UserRights. In such case it
+ * will not be re-added automatically. The user will also not lose the
+ * group if they no longer meet the criteria.
+ *
+ * @param $event String key in $wgAutopromoteOnce (each one has groups/criteria)
+ *
+ * @return array Array of groups the user has been promoted to.
+ *
+ * @see $wgAutopromoteOnce
+ */
+ public function addAutopromoteOnceGroups( $event ) {
+ global $wgAutopromoteOnceLogInRC;
+
+ $toPromote = array();
+ if ( $this->getId() ) {
+ $toPromote = Autopromote::getAutopromoteOnceGroups( $this, $event );
+ if ( count( $toPromote ) ) {
+ $oldGroups = $this->getGroups(); // previous groups
+ foreach ( $toPromote as $group ) {
+ $this->addGroup( $group );
+ }
+ $newGroups = array_merge( $oldGroups, $toPromote ); // all groups
+
+ $log = new LogPage( 'rights', $wgAutopromoteOnceLogInRC /* in RC? */ );
+ $log->addEntry( 'autopromote',
+ $this->getUserPage(),
+ '', // no comment
+ // These group names are "list to texted"-ed in class LogPage.
+ array( implode( ', ', $oldGroups ), implode( ', ', $newGroups ) )
+ );
+ }
+ }
+ return $toPromote;
+ }
+
/**
* Clear various cached data stored in this object.
- * @param $reloadFrom String Reload user and user_groups table data from a
+ * @param $reloadFrom bool|String Reload user and user_groups table data from a
* given source. May be "name", "id", "defaults", "session", or false for
* no reload.
*/
- function clearInstanceCache( $reloadFrom = false ) {
+ public function clearInstanceCache( $reloadFrom = false ) {
$this->mNewtalk = -1;
$this->mDatePreference = null;
$this->mBlockedby = -1; # Unset
$this->mHash = false;
- $this->mSkin = null;
$this->mRights = null;
$this->mEffectiveGroups = null;
+ $this->mImplicitGroups = null;
$this->mOptions = null;
+ $this->mDisplayName = null;
if ( $reloadFrom ) {
$this->mLoadedItems = array();
*
* @return Array of String options
*/
- static function getDefaultOptions() {
- global $wgNamespacesToBeSearchedDefault;
- /**
- * Site defaults will override the global/language defaults
- */
- global $wgDefaultUserOptions, $wgContLang, $wgDefaultSkin;
- $defOpt = $wgDefaultUserOptions + $wgContLang->getDefaultUserOptionOverrides();
-
- /**
- * default language setting
- */
+ public static function getDefaultOptions() {
+ global $wgNamespacesToBeSearchedDefault, $wgDefaultUserOptions, $wgContLang, $wgDefaultSkin;
+
+ $defOpt = $wgDefaultUserOptions;
+ # default language setting
$variant = $wgContLang->getDefaultVariant();
$defOpt['variant'] = $variant;
$defOpt['language'] = $variant;
}
$defOpt['skin'] = $wgDefaultSkin;
+ // FIXME: Ideally we'd cache the results of this function so the hook is only run once,
+ // but that breaks the parser tests because they rely on being able to change $wgContLang
+ // mid-request and see that change reflected in the return value of this function.
+ // Which is insane and would never happen during normal MW operation, but is also not
+ // likely to get fixed unless and until we context-ify everything.
+ // See also https://www.mediawiki.org/wiki/Special:Code/MediaWiki/101488#c25275
+ wfRunHooks( 'UserGetDefaultOptions', array( &$defOpt ) );
+
return $defOpt;
}
/**
* Get blocking information
- * @private
* @param $bFromSlave Bool Whether to check the slave database first. To
* improve performance, non-critical checks are done
* against slaves. Check when actually saving should be
* done against master.
*/
- function getBlockedStatus( $bFromSlave = true ) {
+ private function getBlockedStatus( $bFromSlave = true ) {
global $wgProxyWhitelist, $wgUser;
if ( -1 != $this->mBlockedby ) {
# user is not immune to autoblocks/hardblocks, and they are the current user so we
# know which IP address they're actually coming from
if ( !$this->isAllowed( 'ipblock-exempt' ) && $this->getID() == $wgUser->getID() ) {
- $ip = wfGetIP();
+ $ip = $this->getRequest()->getIP();
} else {
$ip = null;
}
$this->mBlock = Block::newFromTarget( $this->getName(), $ip, !$bFromSlave );
if ( $this->mBlock instanceof Block ) {
wfDebug( __METHOD__ . ": Found block.\n" );
- $this->mBlockedby = $this->mBlock->getBlocker()->getName();
+ $this->mBlockedby = $this->mBlock->getByName();
$this->mBlockreason = $this->mBlock->mReason;
$this->mHideName = $this->mBlock->mHideName;
$this->mAllowUsertalk = !$this->mBlock->prevents( 'editownusertalk' );
- if ( $this->isLoggedIn() && $wgUser->getID() == $this->getID() ) {
- $this->spreadBlock();
- }
}
# Proxy blocking
- if ( !$this->isAllowed( 'proxyunbannable' ) && !in_array( $ip, $wgProxyWhitelist ) ) {
+ if ( $ip !== null && !$this->isAllowed( 'proxyunbannable' ) && !in_array( $ip, $wgProxyWhitelist ) ) {
# Local list
- if ( wfIsLocallyBlockedProxy( $ip ) ) {
+ if ( self::isLocallyBlockedProxy( $ip ) ) {
$this->mBlockedby = wfMsg( 'proxyblocker' );
$this->mBlockreason = wfMsg( 'proxyblockreason' );
}
* @param $checkWhitelist Bool: whether to check the whitelist first
* @return Bool True if blacklisted.
*/
- function isDnsBlacklisted( $ip, $checkWhitelist = false ) {
+ public function isDnsBlacklisted( $ip, $checkWhitelist = false ) {
global $wgEnableSorbs, $wgEnableDnsBlacklist,
$wgSorbsUrl, $wgDnsBlacklistUrls, $wgProxyWhitelist;
* @param $bases String|Array of Strings: URL of the DNS blacklist
* @return Bool True if blacklisted.
*/
- function inDnsBlacklist( $ip, $bases ) {
+ public function inDnsBlacklist( $ip, $bases ) {
wfProfileIn( __METHOD__ );
$found = false;
- // FIXME: IPv6 ??? (http://bugs.php.net/bug.php?id=33170)
+ // @todo FIXME: IPv6 ??? (http://bugs.php.net/bug.php?id=33170)
if( IP::isIPv4( $ip ) ) {
# Reverse IP, bug 21255
$ipReversed = implode( '.', array_reverse( explode( '.', $ip ) ) );
foreach( (array)$bases as $base ) {
# Make hostname
- $host = "$ipReversed.$base";
+ # If we have an access key, use that too (ProjectHoneypot, etc.)
+ if( is_array( $base ) ) {
+ if( count( $base ) >= 2 ) {
+ # Access key is 1, base URL is 0
+ $host = "{$base[1]}.$ipReversed.{$base[0]}";
+ } else {
+ $host = "$ipReversed.{$base[0]}";
+ }
+ } else {
+ $host = "$ipReversed.$base";
+ }
# Send query
$ipList = gethostbynamel( $host );
return $found;
}
+ /**
+ * Check if an IP address is in the local proxy list
+ *
+ * @param $ip string
+ *
+ * @return bool
+ */
+ public static function isLocallyBlockedProxy( $ip ) {
+ global $wgProxyList;
+
+ if ( !$wgProxyList ) {
+ return false;
+ }
+ wfProfileIn( __METHOD__ );
+
+ if ( !is_array( $wgProxyList ) ) {
+ # Load from the specified file
+ $wgProxyList = array_map( 'trim', file( $wgProxyList ) );
+ }
+
+ if ( !is_array( $wgProxyList ) ) {
+ $ret = false;
+ } elseif ( array_search( $ip, $wgProxyList ) !== false ) {
+ $ret = true;
+ } elseif ( array_key_exists( $ip, $wgProxyList ) ) {
+ # Old-style flipped proxy list
+ $ret = true;
+ } else {
+ $ret = false;
+ }
+ wfProfileOut( __METHOD__ );
+ return $ret;
+ }
+
/**
* Is this user subject to rate limiting?
*
* @return Bool True if rate limited
*/
public function isPingLimitable() {
- global $wgRateLimitsExcludedGroups;
global $wgRateLimitsExcludedIPs;
- if( array_intersect( $this->getEffectiveGroups(), $wgRateLimitsExcludedGroups ) ) {
- // Deprecated, but kept for backwards-compatibility config
- return false;
- }
- if( in_array( wfGetIP(), $wgRateLimitsExcludedIPs ) ) {
+ if( in_array( $this->getRequest()->getIP(), $wgRateLimitsExcludedIPs ) ) {
// No other good way currently to disable rate limits
// for specific IPs. :P
// But this is a crappy hack and should die.
* @param $action String Action to enforce; 'edit' if unspecified
* @return Bool True if a rate limiter was tripped
*/
- function pingLimiter( $action = 'edit' ) {
+ public function pingLimiter( $action = 'edit' ) {
# Call the 'PingLimiter' hook
$result = false;
if( !wfRunHooks( 'PingLimiter', array( &$this, $action, $result ) ) ) {
$limits = $wgRateLimits[$action];
$keys = array();
$id = $this->getId();
- $ip = wfGetIP();
+ $ip = $this->getRequest()->getIP();
$userLimit = false;
if( isset( $limits['anon'] ) && $id == 0 ) {
if( $count > $max ) {
wfDebug( __METHOD__ . ": tripped! $key at $count $summary\n" );
if( $wgRateLimitLog ) {
- @file_put_contents( $wgRateLimitLog, wfTimestamp( TS_MW ) . ' ' . wfWikiID() . ': ' . $this->getName() . " tripped $key at $count $summary\n", FILE_APPEND );
+ wfSuppressWarnings();
+ file_put_contents( $wgRateLimitLog, wfTimestamp( TS_MW ) . ' ' . wfWikiID() . ': ' . $this->getName() . " tripped $key at $count $summary\n", FILE_APPEND );
+ wfRestoreWarnings();
}
$triggered = true;
} else {
* @param $bFromSlave Bool Whether to check the slave database instead of the master
* @return Bool True if blocked, false otherwise
*/
- function isBlocked( $bFromSlave = true ) { // hacked from false due to horrible probs on site
+ public function isBlocked( $bFromSlave = true ) { // hacked from false due to horrible probs on site
+ return $this->getBlock( $bFromSlave ) instanceof Block && $this->getBlock()->prevents( 'edit' );
+ }
+
+ /**
+ * Get the block affecting the user, or null if the user is not blocked
+ *
+ * @param $bFromSlave Bool Whether to check the slave database instead of the master
+ * @return Block|null
+ */
+ public function getBlock( $bFromSlave = true ){
$this->getBlockedStatus( $bFromSlave );
- return $this->mBlock instanceof Block && $this->mBlock->prevents( 'edit' );
+ return $this->mBlock instanceof Block ? $this->mBlock : null;
}
/**
* If user is blocked, return the name of the user who placed the block
* @return String name of blocker
*/
- function blockedBy() {
+ public function blockedBy() {
$this->getBlockedStatus();
return $this->mBlockedby;
}
* If user is blocked, return the specified reason for the block
* @return String Blocking reason
*/
- function blockedFor() {
+ public function blockedFor() {
$this->getBlockedStatus();
return $this->mBlockreason;
}
* If user is blocked, return the ID for the block
* @return Int Block ID
*/
- function getBlockId() {
+ public function getBlockId() {
$this->getBlockedStatus();
return ( $this->mBlock ? $this->mBlock->getId() : false );
}
* @param $ip String IP address, uses current client if none given
* @return Bool True if blocked, false otherwise
*/
- function isBlockedGlobally( $ip = '' ) {
+ public function isBlockedGlobally( $ip = '' ) {
if( $this->mBlockedGlobally !== null ) {
return $this->mBlockedGlobally;
}
// User is already an IP?
if( IP::isIPAddress( $this->getName() ) ) {
$ip = $this->getName();
- } else if( !$ip ) {
- $ip = wfGetIP();
+ } elseif( !$ip ) {
+ $ip = $this->getRequest()->getIP();
}
$blocked = false;
wfRunHooks( 'UserIsBlockedGlobally', array( &$this, $ip, &$blocked ) );
*
* @return Bool True if locked, false otherwise
*/
- function isLocked() {
+ public function isLocked() {
if( $this->mLocked !== null ) {
return $this->mLocked;
}
*
* @return Bool True if hidden, false otherwise
*/
- function isHidden() {
+ public function isHidden() {
if( $this->mHideName !== null ) {
return $this->mHideName;
}
* Get the user's ID.
* @return Int The user's ID; 0 if the user is anonymous or nonexistent
*/
- function getId() {
+ public function getId() {
if( $this->mId === null && $this->mName !== null
&& User::isIP( $this->mName ) ) {
// Special case, we know the user is anonymous
* Set the user and reload all fields according to a given ID
* @param $v Int User ID to reload
*/
- function setId( $v ) {
+ public function setId( $v ) {
$this->mId = $v;
$this->clearInstanceCache( 'id' );
}
* Get the user name, or the IP of an anonymous user
* @return String User's name or IP address
*/
- function getName() {
+ public function getName() {
if ( $this->isItemLoaded( 'name', 'only' ) ) {
# Special case optimisation
return $this->mName;
$this->load();
if ( $this->mName === false ) {
# Clean up IPs
- $this->mName = IP::sanitizeIP( wfGetIP() );
+ $this->mName = IP::sanitizeIP( $this->getRequest()->getIP() );
}
return $this->mName;
}
* does not exist.
* @param $str String New user name to set
*/
- function setName( $str ) {
+ public function setName( $str ) {
$this->load();
$this->mName = $str;
}
* Get the user's name escaped by underscores.
* @return String Username escaped by underscores.
*/
- function getTitleKey() {
+ public function getTitleKey() {
return str_replace( ' ', '_', $this->getName() );
}
* Check if the user has new messages.
* @return Bool True if the user has new messages
*/
- function getNewtalk() {
+ public function getNewtalk() {
$this->load();
# Load the newtalk status if it is unloaded (mNewtalk=-1)
* Return the talk page(s) this user has new messages on.
* @return Array of String page URLs
*/
- function getNewMessageLinks() {
+ public function getNewMessageLinks() {
$talks = array();
if( !wfRunHooks( 'UserRetrieveNewTalks', array( &$this, &$talks ) ) )
return $talks;
* @param $id String|Int User's IP address for anonymous users, User ID otherwise
* @param $fromMaster Bool true to fetch from the master, false for a slave
* @return Bool True if the user has new messages
- * @private
*/
- function checkNewtalk( $field, $id, $fromMaster = false ) {
+ protected function checkNewtalk( $field, $id, $fromMaster = false ) {
if ( $fromMaster ) {
$db = wfGetDB( DB_MASTER );
} else {
* @param $field String 'user_ip' for anonymous users, 'user_id' otherwise
* @param $id String|Int User's IP address for anonymous users, User ID otherwise
* @return Bool True if successful, false otherwise
- * @private
*/
- function updateNewtalk( $field, $id ) {
+ protected function updateNewtalk( $field, $id ) {
$dbw = wfGetDB( DB_MASTER );
$dbw->insert( 'user_newtalk',
array( $field => $id ),
* @param $field String 'user_ip' for anonymous users, 'user_id' otherwise
* @param $id String|Int User's IP address for anonymous users, User ID otherwise
* @return Bool True if successful, false otherwise
- * @private
*/
- function deleteNewtalk( $field, $id ) {
+ protected function deleteNewtalk( $field, $id ) {
$dbw = wfGetDB( DB_MASTER );
$dbw->delete( 'user_newtalk',
array( $field => $id ),
* Update the 'You have new messages!' status.
* @param $val Bool Whether the user has new messages
*/
- function setNewtalk( $val ) {
+ public function setNewtalk( $val ) {
if( wfReadOnly() ) {
return;
}
* Updates user_touched field, and removes account data from memcached
* for reload on the next hit.
*/
- function invalidateCache() {
+ public function invalidateCache() {
if( wfReadOnly() ) {
return;
}
/**
* Validate the cache for this account.
* @param $timestamp String A timestamp in TS_MW format
+ *
+ * @return bool
*/
- function validateCache( $timestamp ) {
+ public function validateCache( $timestamp ) {
$this->load();
return ( $timestamp >= $this->mTouched );
}
* Get the user touched timestamp
* @return String timestamp
*/
- function getTouched() {
+ public function getTouched() {
$this->load();
return $this->mTouched;
}
*
* @param $str String New password to set
* @throws PasswordError on failure
+ *
+ * @return bool
*/
- function setPassword( $str ) {
+ public function setPassword( $str ) {
global $wgAuth;
if( $str !== null ) {
*
* @param $str String New password to set
*/
- function setInternalPassword( $str ) {
+ public function setInternalPassword( $str ) {
$this->load();
$this->setToken();
* Get the user's current token.
* @return String Token
*/
- function getToken() {
+ public function getToken() {
$this->load();
return $this->mToken;
}
* Set the random token (used for persistent authentication)
* Called from loadDefaults() among other places.
*
- * @param $token String If specified, set the token to this value
- * @private
+ * @param $token String|bool If specified, set the token to this value
*/
- function setToken( $token = false ) {
+ public function setToken( $token = false ) {
global $wgSecretKey, $wgProxyKey;
$this->load();
if ( !$token ) {
* Set the cookie password
*
* @param $str String New cookie password
- * @private
*/
- function setCookiePassword( $str ) {
+ private function setCookiePassword( $str ) {
$this->load();
$this->mCookiePassword = md5( $str );
}
* @param $str String New password to set
* @param $throttle Bool If true, reset the throttle timestamp to the present
*/
- function setNewpassword( $str, $throttle = true ) {
+ public function setNewpassword( $str, $throttle = true ) {
$this->load();
$this->mNewpassword = self::crypt( $str );
if ( $throttle ) {
* $wgPasswordReminderResendTime hours?
* @return Bool
*/
- function isPasswordReminderThrottled() {
+ public function isPasswordReminderThrottled() {
global $wgPasswordReminderResendTime;
$this->load();
if ( !$this->mNewpassTime || !$wgPasswordReminderResendTime ) {
* Get the user's e-mail address
* @return String User's email address
*/
- function getEmail() {
+ public function getEmail() {
$this->load();
wfRunHooks( 'UserGetEmail', array( $this, &$this->mEmail ) );
return $this->mEmail;
* Get the timestamp of the user's e-mail authentication
* @return String TS_MW timestamp
*/
- function getEmailAuthenticationTimestamp() {
+ public function getEmailAuthenticationTimestamp() {
$this->load();
wfRunHooks( 'UserGetEmailAuthenticationTimestamp', array( $this, &$this->mEmailAuthenticated ) );
return $this->mEmailAuthenticated;
* Set the user's e-mail address
* @param $str String New e-mail address
*/
- function setEmail( $str ) {
+ public function setEmail( $str ) {
$this->load();
+ if( $str == $this->mEmail ) {
+ return;
+ }
$this->mEmail = $str;
+ $this->invalidateEmail();
wfRunHooks( 'UserSetEmail', array( $this, &$this->mEmail ) );
}
* Get the user's real name
* @return String User's real name
*/
- function getRealName() {
+ public function getRealName() {
if ( !$this->isItemLoaded( 'realname' ) ) {
$this->load();
}
* Set the user's real name
* @param $str String New real name
*/
- function setRealName( $str ) {
+ public function setRealName( $str ) {
$this->load();
$this->mRealName = $str;
}
+ /**
+ * Return the name of this user we should used to display in the user interface
+ * @return String The user's display name
+ */
+ public function getDisplayName() {
+ global $wgRealNameInInterface;
+ if ( is_null( $this->mDisplayName ) ) {
+ $displayName = null;
+
+ // Allow hooks to set a display name
+ wfRunHooks( 'UserDisplayName', array( $this, &$displayName ) );
+
+ if ( is_null( $displayName ) && $wgRealNameInInterface && $this->getRealName() ) {
+ // If $wgRealNameInInterface is true use the real name as the display name if it's set
+ $displayName = $this->getRealName();
+ }
+
+ if ( is_null( $displayName ) ) {
+ $displayName = $this->getName();
+ }
+
+ $this->mDisplayName = $displayName;
+ }
+ return $this->mDisplayName;
+ }
+
/**
* Get the user's current setting for a given option.
*
* @see getBoolOption()
* @see getIntOption()
*/
- function getOption( $oname, $defaultOverride = null, $ignoreHidden = false ) {
+ public function getOption( $oname, $defaultOverride = null, $ignoreHidden = false ) {
global $wgHiddenPrefs;
$this->loadOptions();
* @return Bool User's current value for the option
* @see getOption()
*/
- function getBoolOption( $oname ) {
+ public function getBoolOption( $oname ) {
return (bool)$this->getOption( $oname );
}
-
/**
* Get the user's current setting for a given option, as a boolean value.
*
* @return Int User's current value for the option
* @see getOption()
*/
- function getIntOption( $oname, $defaultOverride=0 ) {
+ public function getIntOption( $oname, $defaultOverride=0 ) {
$val = $this->getOption( $oname );
if( $val == '' ) {
$val = $defaultOverride;
* @param $oname String The option to set
* @param $val mixed New value to set
*/
- function setOption( $oname, $val ) {
+ public function setOption( $oname, $val ) {
$this->load();
$this->loadOptions();
- if ( $oname == 'skin' ) {
- # Clear cached skin, so the new one displays immediately in Special:Preferences
- $this->mSkin = null;
- }
-
// Explicitly NULL values should refer to defaults
global $wgDefaultUserOptions;
if( is_null( $val ) && isset( $wgDefaultUserOptions[$oname] ) ) {
/**
* Reset all options to the site defaults
*/
- function resetOptions() {
+ public function resetOptions() {
$this->mOptions = self::getDefaultOptions();
}
* Get the user's preferred date format.
* @return String User's preferred date format
*/
- function getDatePreference() {
+ public function getDatePreference() {
// Important migration for old data rows
if ( is_null( $this->mDatePreference ) ) {
global $wgLang;
/**
* Get the user preferred stub threshold
+ *
+ * @return int
*/
- function getStubThreshold() {
+ public function getStubThreshold() {
global $wgMaxArticleSize; # Maximum article size, in Kb
$threshold = intval( $this->getOption( 'stubthreshold' ) );
if ( $threshold > $wgMaxArticleSize * 1024 ) {
* Get the permissions this user has.
* @return Array of String permission names
*/
- function getRights() {
+ public function getRights() {
if ( is_null( $this->mRights ) ) {
$this->mRights = self::getGroupPermissions( $this->getEffectiveGroups() );
wfRunHooks( 'UserGetRights', array( $this, &$this->mRights ) );
* The implicit * and user groups are not included.
* @return Array of String internal group names
*/
- function getGroups() {
+ public function getGroups() {
$this->load();
+ $this->loadGroups();
return $this->mGroups;
}
* @param $recache Bool Whether to avoid the cache
* @return Array of String internal group names
*/
- function getEffectiveGroups( $recache = false ) {
+ public function getEffectiveGroups( $recache = false ) {
if ( $recache || is_null( $this->mEffectiveGroups ) ) {
wfProfileIn( __METHOD__ );
- $this->mEffectiveGroups = $this->getGroups();
- $this->mEffectiveGroups[] = '*';
- if( $this->getId() ) {
- $this->mEffectiveGroups[] = 'user';
+ $this->mEffectiveGroups = array_unique( array_merge(
+ $this->getGroups(), // explicit groups
+ $this->getAutomaticGroups( $recache ) // implicit groups
+ ) );
+ # Hook for additional groups
+ wfRunHooks( 'UserEffectiveGroups', array( &$this, &$this->mEffectiveGroups ) );
+ wfProfileOut( __METHOD__ );
+ }
+ return $this->mEffectiveGroups;
+ }
- $this->mEffectiveGroups = array_unique( array_merge(
- $this->mEffectiveGroups,
+ /**
+ * Get the list of implicit group memberships this user has.
+ * This includes 'user' if logged in, '*' for all accounts,
+ * and autopromoted groups
+ * @param $recache Bool Whether to avoid the cache
+ * @return Array of String internal group names
+ */
+ public function getAutomaticGroups( $recache = false ) {
+ if ( $recache || is_null( $this->mImplicitGroups ) ) {
+ wfProfileIn( __METHOD__ );
+ $this->mImplicitGroups = array( '*' );
+ if ( $this->getId() ) {
+ $this->mImplicitGroups[] = 'user';
+
+ $this->mImplicitGroups = array_unique( array_merge(
+ $this->mImplicitGroups,
Autopromote::getAutopromoteGroups( $this )
) );
-
- # Hook for additional groups
- wfRunHooks( 'UserEffectiveGroups', array( &$this, &$this->mEffectiveGroups ) );
+ }
+ if ( $recache ) {
+ # Assure data consistency with rights/groups,
+ # as getEffectiveGroups() depends on this function
+ $this->mEffectiveGroups = null;
}
wfProfileOut( __METHOD__ );
}
- return $this->mEffectiveGroups;
+ return $this->mImplicitGroups;
+ }
+
+ /**
+ * Returns the groups the user has belonged to.
+ *
+ * The user may still belong to the returned groups. Compare with getGroups().
+ *
+ * The function will not return groups the user had belonged to before MW 1.17
+ *
+ * @return array Names of the groups the user has belonged to.
+ */
+ public function getFormerGroups() {
+ if( is_null( $this->mFormerGroups ) ) {
+ $dbr = wfGetDB( DB_MASTER );
+ $res = $dbr->select( 'user_former_groups',
+ array( 'ufg_group' ),
+ array( 'ufg_user' => $this->mId ),
+ __METHOD__ );
+ $this->mFormerGroups = array();
+ foreach( $res as $row ) {
+ $this->mFormerGroups[] = $row->ufg_group;
+ }
+ }
+ return $this->mFormerGroups;
}
/**
* Get the user's edit count.
* @return Int
*/
- function getEditCount() {
+ public function getEditCount() {
if( $this->getId() ) {
if ( !isset( $this->mEditCount ) ) {
/* Populate the count, if it has not been populated yet */
* This takes immediate effect.
* @param $group String Name of the group to add
*/
- function addGroup( $group ) {
- if( wfRunHooks( 'UserAddGroup', array( &$this, &$group ) ) ) {
+ public function addGroup( $group ) {
+ if( wfRunHooks( 'UserAddGroup', array( $this, &$group ) ) ) {
$dbw = wfGetDB( DB_MASTER );
if( $this->getId() ) {
$dbw->insert( 'user_groups',
* This takes immediate effect.
* @param $group String Name of the group to remove
*/
- function removeGroup( $group ) {
+ public function removeGroup( $group ) {
$this->load();
- if( wfRunHooks( 'UserRemoveGroup', array( &$this, &$group ) ) ) {
+ if( wfRunHooks( 'UserRemoveGroup', array( $this, &$group ) ) ) {
$dbw = wfGetDB( DB_MASTER );
$dbw->delete( 'user_groups',
array(
'ug_user' => $this->getID(),
'ug_group' => $group,
), __METHOD__ );
+ // Remember that the user was in this group
+ $dbw->insert( 'user_former_groups',
+ array(
+ 'ufg_user' => $this->getID(),
+ 'ufg_group' => $group,
+ ),
+ __METHOD__,
+ array( 'IGNORE' ) );
}
$this->loadGroups();
$this->mGroups = array_diff( $this->mGroups, array( $group ) );
* Get whether the user is logged in
* @return Bool
*/
- function isLoggedIn() {
+ public function isLoggedIn() {
return $this->getID() != 0;
}
* Get whether the user is anonymous
* @return Bool
*/
- function isAnon() {
+ public function isAnon() {
return !$this->isLoggedIn();
}
/**
* Check if user is allowed to access a feature / make an action
- * @param varargs String permissions to test
+ *
+ * @internal param \String $varargs permissions to test
* @return Boolean: True if user is allowed to perform *any* of the given actions
+ *
+ * @return bool
*/
public function isAllowedAny( /*...*/ ){
$permissions = func_get_args();
}
/**
- * @param varargs String
+ *
+ * @internal param $varargs string
* @return bool True if the user is allowed to perform *all* of the given actions
*/
public function isAllowedAll( /*...*/ ){
return( ( $wgUseRCPatrol || $wgUseNPPatrol ) && ( $this->isAllowedAny( 'patrol', 'patrolmarks' ) ) );
}
+ /**
+ * Get the WebRequest object to use with this object
+ *
+ * @return WebRequest
+ */
+ public function getRequest() {
+ if ( $this->mRequest ) {
+ return $this->mRequest;
+ } else {
+ global $wgRequest;
+ return $wgRequest;
+ }
+ }
+
/**
* Get the current skin, loading it if required
* @return Skin The current skin
- * @todo: FIXME : need to check the old failback system [AV]
- * @deprecated Use ->getSkin() in the most relevant outputting context you have
+ * @todo FIXME: Need to check the old failback system [AV]
+ * @deprecated since 1.18 Use ->getSkin() in the most relevant outputting context you have
*/
- function getSkin() {
+ public function getSkin() {
+ wfDeprecated( __METHOD__, '1.18' );
return RequestContext::getMain()->getSkin();
}
* @param $title Title of the article to look at
* @return Bool
*/
- function isWatched( $title ) {
+ public function isWatched( $title ) {
$wl = WatchedItem::fromUserTitle( $this, $title );
return $wl->isWatched();
}
* Watch an article.
* @param $title Title of the article to look at
*/
- function addWatch( $title ) {
+ public function addWatch( $title ) {
$wl = WatchedItem::fromUserTitle( $this, $title );
$wl->addWatch();
$this->invalidateCache();
* Stop watching an article.
* @param $title Title of the article to look at
*/
- function removeWatch( $title ) {
+ public function removeWatch( $title ) {
$wl = WatchedItem::fromUserTitle( $this, $title );
$wl->removeWatch();
$this->invalidateCache();
}
+ /**
+ * Cleans up watchlist by removing invalid entries from it
+ */
+ public function cleanupWatchlist() {
+ $dbw = wfGetDB( DB_MASTER );
+ $dbw->delete( 'watchlist', array( 'wl_namespace < 0', 'wl_user' => $this->getId() ), __METHOD__ );
+ }
+
/**
* Clear the user's notification timestamp for the given title.
* If e-notif e-mails are on, they will receive notification mails on
* the next change of the page if it's watched etc.
* @param $title Title of the article to look at
*/
- function clearNotification( &$title ) {
- global $wgUser, $wgUseEnotif, $wgShowUpdatedMarker;
+ public function clearNotification( &$title ) {
+ global $wgUseEnotif, $wgShowUpdatedMarker;
# Do nothing if the database is locked to writes
if( wfReadOnly() ) {
// and when it does have to be executed, it can be on a slave
// If this is the user's newtalk page, we always update the timestamp
if( $title->getNamespace() == NS_USER_TALK &&
- $title->getText() == $wgUser->getName() )
+ $title->getText() == $this->getName() )
{
$watched = true;
- } elseif ( $this->getId() == $wgUser->getId() ) {
- $watched = $title->userIsWatching();
} else {
- $watched = true;
+ $watched = $this->isWatched( $title );
}
// If the page is watched by the user (or may be watched), update the timestamp on any
* Resets all of the given user's page-change notification timestamps.
* If e-notif e-mails are on, they will receive notification mails on
* the next change of any watched page.
- *
- * @param $currentUser Int User ID
*/
- function clearAllNotifications( $currentUser ) {
+ public function clearAllNotifications() {
global $wgUseEnotif, $wgShowUpdatedMarker;
if ( !$wgUseEnotif && !$wgShowUpdatedMarker ) {
$this->setNewtalk( false );
return;
}
- if( $currentUser != 0 ) {
+ $id = $this->getId();
+ if( $id != 0 ) {
$dbw = wfGetDB( DB_MASTER );
$dbw->update( 'watchlist',
array( /* SET */
'wl_notificationtimestamp' => null
), array( /* WHERE */
- 'wl_user' => $currentUser
+ 'wl_user' => $id
), __METHOD__
);
# We also need to clear here the "you have new message" notification for the own user_talk page
/**
* Set this user's options from an encoded string
* @param $str String Encoded options to import
- * @private
+ *
+ * @deprecated in 1.19 due to removal of user_options from the user table
*/
- function decodeOptions( $str ) {
+ private function decodeOptions( $str ) {
+ wfDeprecated( __METHOD__, '1.19' );
if( !$str )
return;
* if 0 or not specified, use the default $wgCookieExpiration
*/
protected function setCookie( $name, $value, $exp = 0 ) {
- global $wgRequest;
- $wgRequest->response()->setcookie( $name, $value, $exp );
+ $this->getRequest()->response()->setcookie( $name, $value, $exp );
}
/**
* @param $request WebRequest object to use; $wgRequest will be used if null
* is passed.
*/
- function setCookies( $request = null ) {
+ public function setCookies( $request = null ) {
if ( $request === null ) {
- global $wgRequest;
- $request = $wgRequest;
+ $request = $this->getRequest();
}
$this->load();
/**
* Log this user out.
*/
- function logout() {
+ public function logout() {
if( wfRunHooks( 'UserLogout', array( &$this ) ) ) {
$this->doLogout();
}
/**
* Clear the user's cookies and session, and reset the instance cache.
- * @private
* @see logout()
*/
- function doLogout() {
- global $wgRequest;
-
+ public function doLogout() {
$this->clearInstanceCache( 'defaults' );
- $wgRequest->setSessionData( 'wsUserID', 0 );
+ $this->getRequest()->setSessionData( 'wsUserID', 0 );
$this->clearCookie( 'UserID' );
$this->clearCookie( 'Token' );
* Save this user's settings into the database.
* @todo Only rarely do all these fields need to be set!
*/
- function saveSettings() {
+ public function saveSettings() {
$this->load();
if ( wfReadOnly() ) { return; }
if ( 0 == $this->mId ) { return; }
'user_real_name' => $this->mRealName,
'user_email' => $this->mEmail,
'user_email_authenticated' => $dbw->timestampOrNull( $this->mEmailAuthenticated ),
- 'user_options' => '',
'user_touched' => $dbw->timestamp( $this->mTouched ),
'user_token' => $this->mToken,
'user_email_token' => $this->mEmailToken,
* If only this user's username is known, and it exists, return the user ID.
* @return Int
*/
- function idForName() {
+ public function idForName() {
$s = trim( $this->getName() );
if ( $s === '' ) return 0;
*
* @return User object, or null if the username already exists
*/
- static function createNew( $name, $params = array() ) {
+ public static function createNew( $name, $params = array() ) {
$user = new User;
$user->load();
if ( isset( $params['options'] ) ) {
'user_email' => $user->mEmail,
'user_email_authenticated' => $dbw->timestampOrNull( $user->mEmailAuthenticated ),
'user_real_name' => $user->mRealName,
- 'user_options' => '',
'user_token' => $user->mToken,
'user_registration' => $dbw->timestamp( $user->mRegistration ),
'user_editcount' => 0,
/**
* Add this existing user object to the database
*/
- function addToDatabase() {
+ public function addToDatabase() {
$this->load();
$dbw = wfGetDB( DB_MASTER );
$seqVal = $dbw->nextSequenceValue( 'user_user_id_seq' );
'user_email' => $this->mEmail,
'user_email_authenticated' => $dbw->timestampOrNull( $this->mEmailAuthenticated ),
'user_real_name' => $this->mRealName,
- 'user_options' => '',
'user_token' => $this->mToken,
'user_registration' => $dbw->timestamp( $this->mRegistration ),
'user_editcount' => 0,
}
/**
- * If this (non-anonymous) user is blocked, block any IP address
- * they've successfully logged in from.
+ * If this user is logged-in and blocked,
+ * block any IP address they've successfully logged in from.
+ * @return bool A block was spread
*/
- function spreadBlock() {
+ public function spreadAnyEditBlock() {
+ if ( $this->isLoggedIn() && $this->isBlocked() ) {
+ return $this->spreadBlock();
+ }
+ return false;
+ }
+
+ /**
+ * If this (non-anonymous) user is blocked,
+ * block the IP address they've successfully logged in from.
+ * @return bool A block was spread
+ */
+ protected function spreadBlock() {
wfDebug( __METHOD__ . "()\n" );
$this->load();
if ( $this->mId == 0 ) {
- return;
+ return false;
}
$userblock = Block::newFromTarget( $this->getName() );
if ( !$userblock ) {
- return;
+ return false;
}
- $userblock->doAutoblock( wfGetIP() );
+ return (bool)$userblock->doAutoblock( $this->getRequest()->getIP() );
}
/**
* @deprecated since 1.17 use the ParserOptions object to get the relevant options
* @return String Page rendering hash
*/
- function getPageRenderingHash() {
+ public function getPageRenderingHash() {
+ wfDeprecated( __METHOD__, '1.17' );
+
global $wgUseDynamicDates, $wgRenderHashAppend, $wgLang, $wgContLang;
if( $this->mHash ){
return $this->mHash;
}
- wfDeprecated( __METHOD__ );
// stubthreshold is only included below for completeness,
// since it disables the parser cache, its value will always
* Get whether the user is explicitly blocked from account creation.
* @return Bool|Block
*/
- function isBlockedFromCreateAccount() {
+ public function isBlockedFromCreateAccount() {
$this->getBlockedStatus();
if( $this->mBlock && $this->mBlock->prevents( 'createaccount' ) ){
return $this->mBlock;
# bug 13611: if the IP address the user is trying to create an account from is
# blocked with createaccount disabled, prevent new account creation there even
# when the user is logged in
- static $accBlock = false;
- if( $accBlock === false ){
- $accBlock = Block::newFromTarget( null, wfGetIP() );
+ if( $this->mBlockedFromCreateAccount === false ){
+ $this->mBlockedFromCreateAccount = Block::newFromTarget( null, $this->getRequest()->getIP() );
}
- return $accBlock instanceof Block && $accBlock->prevents( 'createaccount' )
- ? $accBlock
+ return $this->mBlockedFromCreateAccount instanceof Block && $this->mBlockedFromCreateAccount->prevents( 'createaccount' )
+ ? $this->mBlockedFromCreateAccount
: false;
}
* Get whether the user is blocked from using Special:Emailuser.
* @return Bool
*/
- function isBlockedFromEmailuser() {
+ public function isBlockedFromEmailuser() {
$this->getBlockedStatus();
return $this->mBlock && $this->mBlock->prevents( 'sendemail' );
}
*
* @return Title: User's personal page title
*/
- function getUserPage() {
+ public function getUserPage() {
return Title::makeTitle( NS_USER, $this->getName() );
}
*
* @return Title: User's talk page title
*/
- function getTalkPage() {
+ public function getTalkPage() {
$title = $this->getUserPage();
return $title->getTalkPage();
}
- /**
- * Get the maximum valid user ID.
- * @return Integer: User ID
- * @static
- */
- function getMaxID() {
- static $res; // cache
-
- if ( isset( $res ) ) {
- return $res;
- } else {
- $dbr = wfGetDB( DB_SLAVE );
- return $res = $dbr->selectField( 'user', 'max(user_id)', false, __METHOD__ );
- }
- }
-
/**
* Determine whether the user is a newbie. Newbies are either
* anonymous IPs, or the most recently created accounts.
* @return Bool
*/
- function isNewbie() {
+ public function isNewbie() {
return !$this->isAllowed( 'autoconfirmed' );
}
* @param $password String: user password.
* @return Boolean: True if the given password is correct, otherwise False.
*/
- function checkPassword( $password ) {
+ public function checkPassword( $password ) {
global $wgAuth, $wgLegacyEncoding;
$this->load();
/**
* Check if the given clear-text password matches the temporary password
* sent by e-mail for password reset operations.
+ *
+ * @param $plaintext string
+ *
* @return Boolean: True if matches, false otherwise
*/
- function checkTemporaryPassword( $plaintext ) {
+ public function checkTemporaryPassword( $plaintext ) {
global $wgNewPasswordExpiry;
$this->load();
}
}
+ /**
+ * Alias for getEditToken.
+ * @deprecated since 1.19, use getEditToken instead.
+ *
+ * @param $salt String|Array of Strings Optional function-specific data for hashing
+ * @param $request WebRequest object to use or null to use $wgRequest
+ * @return String The new edit token
+ */
+ public function editToken( $salt = '', $request = null ) {
+ wfDeprecated( __METHOD__, '1.19' );
+ return $this->getEditToken( $salt, $request );
+ }
+
/**
* Initialize (if necessary) and return a session token value
* which can be used in edit forms to show that the user's
* login credentials aren't being hijacked with a foreign form
* submission.
*
+ * @since 1.19
+ *
* @param $salt String|Array of Strings Optional function-specific data for hashing
* @param $request WebRequest object to use or null to use $wgRequest
* @return String The new edit token
*/
- function editToken( $salt = '', $request = null ) {
+ public function getEditToken( $salt = '', $request = null ) {
if ( $request == null ) {
- global $wgRequest;
- $request = $wgRequest;
+ $request = $this->getRequest();
}
if ( $this->isAnon() ) {
* @param $request WebRequest object to use or null to use $wgRequest
* @return Boolean: Whether the token matches
*/
- function matchEditToken( $val, $salt = '', $request = null ) {
- $sessionToken = $this->editToken( $salt, $request );
+ public function matchEditToken( $val, $salt = '', $request = null ) {
+ $sessionToken = $this->getEditToken( $salt, $request );
if ( $val != $sessionToken ) {
wfDebug( "User::matchEditToken: broken session data\n" );
}
* @param $request WebRequest object to use or null to use $wgRequest
* @return Boolean: Whether the token matches
*/
- function matchEditTokenNoSuffix( $val, $salt = '', $request = null ) {
- $sessionToken = $this->editToken( $salt, $request );
+ public function matchEditTokenNoSuffix( $val, $salt = '', $request = null ) {
+ $sessionToken = $this->getEditToken( $salt, $request );
return substr( $sessionToken, 0, 32 ) == substr( $val, 0, 32 );
}
* @param $type String: message to send, either "created", "changed" or "set"
* @return Status object
*/
- function sendConfirmationMail( $type = 'created' ) {
+ public function sendConfirmationMail( $type = 'created' ) {
global $wgLang;
$expiration = null; // gets passed-by-ref and defined in next line.
$token = $this->confirmationToken( $expiration );
return $this->sendMail( wfMsg( 'confirmemail_subject' ),
wfMsg( $message,
- wfGetIP(),
+ $this->getRequest()->getIP(),
$this->getName(),
$url,
$wgLang->timeanddate( $expiration, false ),
* @param $replyto String Reply-To address
* @return Status
*/
- function sendMail( $subject, $body, $from = null, $replyto = null ) {
+ public function sendMail( $subject, $body, $from = null, $replyto = null ) {
if( is_null( $from ) ) {
global $wgPasswordSender, $wgPasswordSenderName;
$sender = new MailAddress( $wgPasswordSender, $wgPasswordSenderName );
* @note Call saveSettings() after calling this function to commit
* this change to the database.
*
- * @param[out] &$expiration \mixed Accepts the expiration time
+ * @param &$expiration \mixed Accepts the expiration time
* @return String New token
- * @private
*/
- function confirmationToken( &$expiration ) {
+ private function confirmationToken( &$expiration ) {
global $wgUserEmailConfirmationTokenExpiry;
$now = time();
$expires = $now + $wgUserEmailConfirmationTokenExpiry;
* Return a URL the user can use to confirm their email address.
* @param $token String Accepts the email confirmation token
* @return String New token URL
- * @private
*/
- function confirmationTokenUrl( $token ) {
+ private function confirmationTokenUrl( $token ) {
return $this->getTokenUrl( 'ConfirmEmail', $token );
}
* Return a URL the user can use to invalidate their email address.
* @param $token String Accepts the email confirmation token
* @return String New token URL
- * @private
*/
- function invalidationTokenUrl( $token ) {
+ private function invalidationTokenUrl( $token ) {
return $this->getTokenUrl( 'Invalidateemail', $token );
}
/**
* Internal function to format the e-mail validation/invalidation URLs.
- * This uses $wgArticlePath directly as a quickie hack to use the
+ * This uses a quickie hack to use the
* hardcoded English names of the Special: pages, for ASCII safety.
*
* @note Since these URLs get dropped directly into emails, using the
* @return String Formatted URL
*/
protected function getTokenUrl( $page, $token ) {
- global $wgArticlePath;
- return wfExpandUrl(
- str_replace(
- '$1',
- "Special:$page/$token",
- $wgArticlePath ) );
+ // Hack to bypass localization of 'Special:'
+ $title = Title::makeTitle( NS_MAIN, "Special:$page/$token" );
+ return $title->getCanonicalUrl();
}
/**
* Mark the e-mail address confirmed.
*
* @note Call saveSettings() after calling this function to commit the change.
+ *
+ * @return true
*/
- function confirmEmail() {
+ public function confirmEmail() {
$this->setEmailAuthenticationTimestamp( wfTimestampNow() );
wfRunHooks( 'ConfirmEmailComplete', array( $this ) );
return true;
* address if it was already confirmed.
*
* @note Call saveSettings() after calling this function to commit the change.
+ * @return true
*/
function invalidateEmail() {
$this->load();
* site configuration?
* @return Bool
*/
- function canSendEmail() {
+ public function canSendEmail() {
global $wgEnableEmail, $wgEnableUserEmail;
if( !$wgEnableEmail || !$wgEnableUserEmail || !$this->isAllowed( 'sendemail' ) ) {
return false;
* site configuration?
* @return Bool
*/
- function canReceiveEmail() {
+ public function canReceiveEmail() {
return $this->isEmailConfirmed() && !$this->getOption( 'disablemail' );
}
*
* @return Bool
*/
- function isEmailConfirmed() {
+ public function isEmailConfirmed() {
global $wgEmailAuthentication;
$this->load();
$confirmed = true;
if( wfRunHooks( 'EmailConfirmed', array( &$this, &$confirmed ) ) ) {
- if( $this->isAnon() )
+ if( $this->isAnon() ) {
return false;
- if( !self::isValidEmailAddr( $this->mEmail ) )
+ }
+ if( !Sanitizer::validateEmail( $this->mEmail ) ) {
return false;
- if( $wgEmailAuthentication && !$this->getEmailAuthenticationTimestamp() )
+ }
+ if( $wgEmailAuthentication && !$this->getEmailAuthenticationTimestamp() ) {
return false;
+ }
return true;
} else {
return $confirmed;
* Check whether there is an outstanding request for e-mail confirmation.
* @return Bool
*/
- function isEmailConfirmationPending() {
+ public function isEmailConfirmationPending() {
global $wgEmailAuthentication;
return $wgEmailAuthentication &&
!$this->isEmailConfirmed() &&
* @param $groups Array of Strings List of internal group names
* @return Array of Strings List of permission key names for given groups combined
*/
- static function getGroupPermissions( $groups ) {
+ public static function getGroupPermissions( $groups ) {
global $wgGroupPermissions, $wgRevokePermissions;
$rights = array();
// grant every granted permission first
* @param $role String Role to check
* @return Array of Strings List of internal group names with the given permission
*/
- static function getGroupsWithPermission( $role ) {
+ public static function getGroupsWithPermission( $role ) {
global $wgGroupPermissions;
$allowedGroups = array();
foreach ( $wgGroupPermissions as $group => $rights ) {
* @param $group String Internal group name
* @return String Localized descriptive group name
*/
- static function getGroupName( $group ) {
+ public static function getGroupName( $group ) {
$msg = wfMessage( "group-$group" );
return $msg->isBlank() ? $group : $msg->text();
}
* Get the localized descriptive name for a member of a group, if it exists
*
* @param $group String Internal group name
+ * @param $username String Username for gender (since 1.19)
* @return String Localized name for group member
*/
- static function getGroupMember( $group ) {
- $msg = wfMessage( "group-$group-member" );
+ public static function getGroupMember( $group, $username = '#' ) {
+ $msg = wfMessage( "group-$group-member", $username );
return $msg->isBlank() ? $group : $msg->text();
}
* are not included, as they are defined automatically, not in the database.
* @return Array of internal group names
*/
- static function getAllGroups() {
+ public static function getAllGroups() {
global $wgGroupPermissions, $wgRevokePermissions;
return array_diff(
array_merge( array_keys( $wgGroupPermissions ), array_keys( $wgRevokePermissions ) ),
* Get a list of all available permissions.
* @return Array of permission names
*/
- static function getAllRights() {
+ public static function getAllRights() {
if ( self::$mAllRights === false ) {
global $wgAvailableRights;
if ( count( $wgAvailableRights ) ) {
* @param $group String Internal group name
* @return Title|Bool Title of the page if it exists, false otherwise
*/
- static function getGroupPage( $group ) {
+ public static function getGroupPage( $group ) {
$msg = wfMessage( 'grouppage-' . $group )->inContentLanguage();
if( $msg->exists() ) {
$title = Title::newFromText( $msg->text() );
* @param $text String The text of the link
* @return String HTML link to the group
*/
- static function makeGroupLinkHTML( $group, $text = '' ) {
+ public static function makeGroupLinkHTML( $group, $text = '' ) {
if( $text == '' ) {
$text = self::getGroupName( $group );
}
$title = self::getGroupPage( $group );
if( $title ) {
- global $wgUser;
- $sk = $wgUser->getSkin();
- return $sk->link( $title, htmlspecialchars( $text ) );
+ return Linker::link( $title, htmlspecialchars( $text ) );
} else {
return $text;
}
* @param $text String The text of the link
* @return String Wikilink to the group
*/
- static function makeGroupLinkWiki( $group, $text = '' ) {
+ public static function makeGroupLinkWiki( $group, $text = '' ) {
if( $text == '' ) {
$text = self::getGroupName( $group );
}
* 'add-self' => array( addablegroups to self),
* 'remove-self' => array( removable groups from self) )
*/
- static function changeableByGroup( $group ) {
+ public static function changeableByGroup( $group ) {
global $wgAddGroups, $wgRemoveGroups, $wgGroupsAddToSelf, $wgGroupsRemoveFromSelf;
$groups = array( 'add' => array(), 'remove' => array(), 'add-self' => array(), 'remove-self' => array() );
* 'add-self' => array( addablegroups to self),
* 'remove-self' => array( removable groups from self) )
*/
- function changeableGroups() {
+ public function changeableGroups() {
if( $this->isAllowed( 'userrights' ) ) {
// This group gives the right to modify everything (reverse-
// compatibility with old "userrights lets you change
* Increment the user's edit-count field.
* Will have no effect for anonymous users.
*/
- function incEditCount() {
+ public function incEditCount() {
if( !$this->isAnon() ) {
$dbw = wfGetDB( DB_MASTER );
$dbw->update( 'user',
* @param $right String Right to query
* @return String Localized description of the right
*/
- static function getRightDescription( $right ) {
+ public static function getRightDescription( $right ) {
$key = "right-$right";
- $name = wfMsg( $key );
- return $name == '' || wfEmptyMsg( $key )
- ? $right
- : $name;
+ $msg = wfMessage( $key );
+ return $msg->isBlank() ? $right : $msg->text();
}
/**
* @param $userId String User ID
* @return String Password hash
*/
- static function oldCrypt( $password, $userId ) {
+ public static function oldCrypt( $password, $userId ) {
global $wgPasswordSalt;
if ( $wgPasswordSalt ) {
return md5( $userId . '-' . md5( $password ) );
* Make a new-style password hash
*
* @param $password String Plain-text password
- * @param $salt String Optional salt, may be random or the user ID.
+ * @param bool|string $salt Optional salt, may be random or the user ID.
+
* If unspecified or false, will generate one automatically
* @return String Password hash
*/
- static function crypt( $password, $salt = false ) {
+ public static function crypt( $password, $salt = false ) {
global $wgPasswordSalt;
$hash = '';
*
* @param $hash String Password hash
* @param $password String Plain-text password to compare
- * @param $userId String User ID for old-style password salt
- * @return Boolean:
+ * @param $userId String|bool User ID for old-style password salt
+ *
+ * @return Boolean
*/
- static function comparePasswords( $hash, $password, $userId = false ) {
+ public static function comparePasswords( $hash, $password, $userId = false ) {
$type = substr( $hash, 0, 3 );
$result = false;
}
/**
- * Add a newuser log entry for this user
+ * Add a newuser log entry for this user. Before 1.19 the return value was always true.
*
* @param $byEmail Boolean: account made by email?
* @param $reason String: user supplied reason
+ *
+ * @return int|bool True if not $wgNewUserLog; otherwise ID of log item or 0 on failure
*/
public function addNewUserLogEntry( $byEmail = false, $reason = '' ) {
global $wgUser, $wgContLang, $wgNewUserLog;
}
}
$log = new LogPage( 'newusers' );
- $log->addEntry(
+ return (int)$log->addEntry(
$action,
$this->getUserPage(),
$reason,
array( $this->getId() )
);
- return true;
}
/**
* Add an autocreate newuser log entry for this user
* Used by things like CentralAuth and perhaps other authplugins.
+ *
+ * @return true
*/
public function addNewUserLogEntryAutoCreate() {
global $wgNewUserLog;
return true;
}
+ /**
+ * @todo document
+ */
protected function loadOptions() {
$this->load();
if ( $this->mOptionsLoaded || !$this->getId() )
wfRunHooks( 'UserLoadOptions', array( $this, &$this->mOptions ) );
}
+ /**
+ * @todo document
+ */
protected function saveOptions() {
global $wgAllowPrefChange;
// Allow hooks to abort, for instance to save to a global profile.
// Reset options to default state before saving.
- if( !wfRunHooks( 'UserSaveOptions', array( $this, &$saveOptions ) ) )
+ if( !wfRunHooks( 'UserSaveOptions', array( $this, &$saveOptions ) ) ) {
return;
+ }
foreach( $saveOptions as $key => $value ) {
# Don't bother storing default values
}
}
- $dbw->begin();
$dbw->delete( 'user_properties', array( 'up_user' => $this->getId() ), __METHOD__ );
$dbw->insert( 'user_properties', $insert_rows, __METHOD__ );
- $dbw->commit();
}
/**
* actually just returns array() unconditionally at the moment. May as
* well keep it around for when the browser bugs get fixed, though.
*
- * FIXME : This does not belong here; put it in Html or Linker or somewhere
+ * @todo FIXME: This does not belong here; put it in Html or Linker or somewhere
*
* @return array Array of HTML attributes suitable for feeding to
* Html::element(), directly or indirectly. (Don't feed to Xml::*()!
# Note that the pattern requirement will always be satisfied if the
# input is empty, so we need required in all cases.
#
- # FIXME (bug 23769): This needs to not claim the password is required
+ # @todo FIXME: Bug 23769: This needs to not claim the password is required
# if e-mail confirmation is being used. Since HTML5 input validation
# is b0rked anyway in some browsers, just return nothing. When it's
# re-enabled, fix this code to not output required for e-mail
dépôts / lhc / web / wiklou.git / blobdiff