/wp-includes/user.php

Large files files are truncated, but you can click here to view the full file

<?php

/**

 * WordPress User API

 *

 * @package WordPress

 * @subpackage Users

 */



/**

 * Authenticate user with remember capability.

 *

 * The credentials is an array that has 'user_login', 'user_password', and

 * 'remember' indices. If the credentials is not given, then the log in form

 * will be assumed and used if set.

 *

 * The various authentication cookies will be set by this function and will be

 * set for a longer period depending on if the 'remember' credential is set to

 * true.

 *

 * @since 2.5.0

 *

 * @param array $credentials Optional. User info in order to sign on.

 * @param bool $secure_cookie Optional. Whether to use secure cookie.

 * @return WP_User|WP_Error WP_User on success, WP_Error on failure.

 */

function wp_signon( $credentials = array(), $secure_cookie = '' ) {

	if ( empty($credentials) ) {

		if ( ! empty($_POST['log']) )

			$credentials['user_login'] = $_POST['log'];

		if ( ! empty($_POST['pwd']) )

			$credentials['user_password'] = $_POST['pwd'];

		if ( ! empty($_POST['rememberme']) )

			$credentials['remember'] = $_POST['rememberme'];

	}



	if ( !empty($credentials['remember']) )

		$credentials['remember'] = true;

	else

		$credentials['remember'] = false;



	/**

	 * Fires before the user is authenticated.

	 *

	 * The variables passed to the callbacks are passed by reference,

	 * and can be modified by callback functions.

	 *

	 * @since 1.5.1

	 *

	 * @todo Decide whether to deprecate the wp_authenticate action.

	 *

	 * @param string $user_login    Username, passed by reference.

	 * @param string $user_password User password, passed by reference.

	 */

	do_action_ref_array( 'wp_authenticate', array( &$credentials['user_login'], &$credentials['user_password'] ) );



	if ( '' === $secure_cookie )

		$secure_cookie = is_ssl();



	/**

	 * Filter whether to use a secure sign-on cookie.

	 *

	 * @since 3.1.0

	 *

	 * @param bool  $secure_cookie Whether to use a secure sign-on cookie.

	 * @param array $credentials {

 	 *     Array of entered sign-on data.

 	 *

 	 *     @type string $user_login    Username.

 	 *     @type string $user_password Password entered.

	 *     @type bool   $remember      Whether to 'remember' the user. Increases the time

	 *                                 that the cookie will be kept. Default false.

 	 * }

	 */

	$secure_cookie = apply_filters( 'secure_signon_cookie', $secure_cookie, $credentials );



	global $auth_secure_cookie; // XXX ugly hack to pass this to wp_authenticate_cookie

	$auth_secure_cookie = $secure_cookie;



	add_filter('authenticate', 'wp_authenticate_cookie', 30, 3);



	$user = wp_authenticate($credentials['user_login'], $credentials['user_password']);



	if ( is_wp_error($user) ) {

		if ( $user->get_error_codes() == array('empty_username', 'empty_password') ) {

			$user = new WP_Error('', '');

		}



		return $user;

	}



	wp_set_auth_cookie($user->ID, $credentials['remember'], $secure_cookie);

	/**

	 * Fires after the user has successfully logged in.

	 *

	 * @since 1.5.0

	 *

	 * @param string  $user_login Username.

	 * @param WP_User $user       WP_User object of the logged-in user.

	 */

	do_action( 'wp_login', $user->user_login, $user );

	return $user;

}



/**

 * Authenticate the user using the username and password.

 *

 * @since 2.8.0

 *

 * @param WP_User|WP_Error|null $user     WP_User or WP_Error object from a previous callback. Default null.

 * @param string                $username Username for authentication.

 * @param string                $password Password for authentication.

 * @return WP_User|WP_Error WP_User on success, WP_Error on failure.

 */

function wp_authenticate_username_password($user, $username, $password) {

	if ( is_a( $user, 'WP_User' ) ) {

		return $user;

	}



	if ( empty($username) || empty($password) ) {

		if ( is_wp_error( $user ) )

			return $user;



		$error = new WP_Error();



		if ( empty($username) )

			$error->add('empty_username', __('<strong>ERROR</strong>: The username field is empty.'));



		if ( empty($password) )

			$error->add('empty_password', __('<strong>ERROR</strong>: The password field is empty.'));



		return $error;

	}



	$user = get_user_by('login', $username);



	if ( !$user )

		return new WP_Error( 'invalid_username', sprintf( __( '<strong>ERROR</strong>: Invalid username. <a href="%s">Lost your password</a>?' ), wp_lostpassword_url() ) );



	/**

	 * Filter whether the given user can be authenticated with the provided $password.

	 *

	 * @since 2.5.0

	 *

	 * @param WP_User|WP_Error $user     WP_User or WP_Error object if a previous

	 *                                   callback failed authentication.

	 * @param string           $password Password to check against the user.

	 */

	$user = apply_filters( 'wp_authenticate_user', $user, $password );

	if ( is_wp_error($user) )

		return $user;



	if ( !wp_check_password($password, $user->user_pass, $user->ID) )

		return new WP_Error( 'incorrect_password', sprintf( __( '<strong>ERROR</strong>: The password you entered for the username <strong>%1$s</strong> is incorrect. <a href="%2$s">Lost your password</a>?' ),

		$username, wp_lostpassword_url() ) );



	return $user;

}



/**

 * Authenticate the user using the WordPress auth cookie.

 *

 * @since 2.8.0

 *

 * @param WP_User|WP_Error|null $user     WP_User or WP_Error object from a previous callback. Default null.

 * @param string                $username Username. If not empty, cancels the cookie authentication.

 * @param string                $password Password. If not empty, cancels the cookie authentication.

 * @return WP_User|WP_Error WP_User on success, WP_Error on failure.

 */

function wp_authenticate_cookie($user, $username, $password) {

	if ( is_a( $user, 'WP_User' ) ) {

		return $user;

	}



	if ( empty($username) && empty($password) ) {

		$user_id = wp_validate_auth_cookie();

		if ( $user_id )

			return new WP_User($user_id);



		global $auth_secure_cookie;



		if ( $auth_secure_cookie )

			$auth_cookie = SECURE_AUTH_COOKIE;

		else

			$auth_cookie = AUTH_COOKIE;



		if ( !empty($_COOKIE[$auth_cookie]) )

			return new WP_Error('expired_session', __('Please log in again.'));



		// If the cookie is not set, be silent.

	}



	return $user;

}



/**

 * For Multisite blogs, check if the authenticated user has been marked as a

 * spammer, or if the user's primary blog has been marked as spam.

 *

 * @since 3.7.0

 *

 * @param WP_User|WP_Error|null $user WP_User or WP_Error object from a previous callback. Default null.

 * @return WP_User|WP_Error WP_User on success, WP_Error if the user is considered a spammer.

 */

function wp_authenticate_spam_check( $user ) {

	if ( $user && is_a( $user, 'WP_User' ) && is_multisite() ) {

		/**

		 * Filter whether the user has been marked as a spammer.

		 *

		 * @since 3.7.0

		 *

		 * @param bool    $spammed Whether the user is considered a spammer.

		 * @param WP_User $user    User to check against.

		 */

		$spammed = apply_filters( 'check_is_user_spammed', is_user_spammy(), $user );



		if ( $spammed )

			return new WP_Error( 'spammer_account', __( '<strong>ERROR</strong>: Your account has been marked as a spammer.' ) );

	}

	return $user;

}



/**

 * Validate the logged-in cookie.

 *

 * Checks the logged-in cookie if the previous auth cookie could not be

 * validated and parsed.

 *

 * This is a callback for the determine_current_user filter, rather than API.

 *

 * @since 3.9.0

 *

 * @param int|bool $user The user ID (or false) as received from the

 *                       determine_current_user filter.

 * @return int|bool User ID if validated, false otherwise. If a user ID from

 *                  an earlier filter callback is received, that value is returned.

 */

function wp_validate_logged_in_cookie( $user_id ) {

	if ( $user_id ) {

		return $user_id;

	}



	if ( is_blog_admin() || is_network_admin() || empty( $_COOKIE[LOGGED_IN_COOKIE] ) ) {

		return false;

	}



	return wp_validate_auth_cookie( $_COOKIE[LOGGED_IN_COOKIE], 'logged_in' );

}



/**

 * Number of posts user has written.

 *

 * @since 3.0.0

 *

 * @global wpdb $wpdb WordPress database object for queries.

 *

 * @param int $userid User ID.

 * @return int Amount of posts user has written.

 */

function count_user_posts($userid) {

	global $wpdb;



	$where = get_posts_by_author_sql('post', true, $userid);



	$count = $wpdb->get_var( "SELECT COUNT(*) FROM $wpdb->posts $where" );



	/**

	 * Filter the number of posts a user has written.

	 *

	 * @since 2.7.0

	 *

	 * @param int $count  The user's post count.

	 * @param int $userid User ID.

	 */

	return apply_filters( 'get_usernumposts', $count, $userid );

}



/**

 * Number of posts written by a list of users.

 *

 * @since 3.0.0

 *

 * @param array $users Array of user IDs.

 * @param string $post_type Optional. Post type to check. Defaults to post.

 * @param bool $public_only Optional. Only return counts for public posts.  Defaults to false.

 * @return array Amount of posts each user has written.

 */

function count_many_users_posts( $users, $post_type = 'post', $public_only = false ) {

	global $wpdb;



	$count = array();

	if ( empty( $users ) || ! is_array( $users ) )

		return $count;



	$userlist = implode( ',', array_map( 'absint', $users ) );

	$where = get_posts_by_author_sql( $post_type, true, null, $public_only );



	$result = $wpdb->get_results( "SELECT post_author, COUNT(*) FROM $wpdb->posts $where AND post_author IN ($userlist) GROUP BY post_author", ARRAY_N );

	foreach ( $result as $row ) {

		$count[ $row[0] ] = $row[1];

	}



	foreach ( $users as $id ) {

		if ( ! isset( $count[ $id ] ) )

			$count[ $id ] = 0;

	}



	return $count;

}



//

// User option functions

//



/**

 * Get the current user's ID

 *

 * @since MU

 *

 * @uses wp_get_current_user

 *

 * @return int The current user's ID

 */

function get_current_user_id() {

	if ( ! function_exists( 'wp_get_current_user' ) )

		return 0;

	$user = wp_get_current_user();

	return ( isset( $user->ID ) ? (int) $user->ID : 0 );

}



/**

 * Retrieve user option that can be either per Site or per Network.

 *

 * If the user ID is not given, then the current user will be used instead. If

 * the user ID is given, then the user data will be retrieved. The filter for

 * the result, will also pass the original option name and finally the user data

 * object as the third parameter.

 *

 * The option will first check for the per site name and then the per Network name.

 *

 * @since 2.0.0

 *

 * @global wpdb $wpdb WordPress database object for queries.

 *

 * @param string $option     User option name.

 * @param int    $user       Optional. User ID.

 * @param bool   $deprecated Use get_option() to check for an option in the options table.

 * @return mixed User option value on success, false on failure.

 */

function get_user_option( $option, $user = 0, $deprecated = '' ) {

	global $wpdb;



	if ( !empty( $deprecated ) )

		_deprecated_argument( __FUNCTION__, '3.0' );



	if ( empty( $user ) )

		$user = get_current_user_id();



	if ( ! $user = get_userdata( $user ) )

		return false;



	$prefix = $wpdb->get_blog_prefix();

	if ( $user->has_prop( $prefix . $option ) ) // Blog specific

		$result = $user->get( $prefix . $option );

	elseif ( $user->has_prop( $option ) ) // User specific and cross-blog

		$result = $user->get( $option );

	else

		$result = false;



	/**

	 * Filter a specific user option value.

	 *

	 * The dynamic portion of the hook name, $option, refers to the user option name.

	 *

	 * @since 2.5.0

	 *

	 * @param mixed   $result Value for the user's option.

	 * @param string  $option Name of the option being retrieved.

	 * @param WP_User $user   WP_User object of the user whose option is being retrieved.

	 */

	return apply_filters( "get_user_option_{$option}", $result, $option, $user );

}



/**

 * Update user option with global blog capability.

 *

 * User options are just like user metadata except that they have support for

 * global blog options. If the 'global' parameter is false, which it is by default

 * it will prepend the WordPress table prefix to the option name.

 *

 * Deletes the user option if $newvalue is empty.

 *

 * @since 2.0.0

 *

 * @global wpdb $wpdb WordPress database object for queries.

 *

 * @param int    $user_id     User ID.

 * @param string $option_name User option name.

 * @param mixed  $newvalue    User option value.

 * @param bool   $global      Optional. Whether option name is global or blog specific.

 *                            Default false (blog specific).

 * @return int|bool User meta ID if the option didn't exist, true on successful update,

 *                  false on failure.

 */

function update_user_option( $user_id, $option_name, $newvalue, $global = false ) {

	global $wpdb;



	if ( !$global )

		$option_name = $wpdb->get_blog_prefix() . $option_name;



	return update_user_meta( $user_id, $option_name, $newvalue );

}



/**

 * Delete user option with global blog capability.

 *

 * User options are just like user metadata except that they have support for

 * global blog options. If the 'global' parameter is false, which it is by default

 * it will prepend the WordPress table prefix to the option name.

 *

 * @since 3.0.0

 *

 * @global wpdb $wpdb WordPress database object for queries.

 *

 * @param int    $user_id     User ID

 * @param string $option_name User option name.

 * @param bool   $global      Optional. Whether option name is global or blog specific.

 *                            Default false (blog specific).

 * @return bool True on success, false on failure.

 */

function delete_user_option( $user_id, $option_name, $global = false ) {

	global $wpdb;



	if ( !$global )

		$option_name = $wpdb->get_blog_prefix() . $option_name;

	return delete_user_meta( $user_id, $option_name );

}



/**

 * WordPress User Query class.

 *

 * @since 3.1.0

 */

class WP_User_Query {



	/**

	 * Query vars, after parsing

	 *

	 * @since 3.5.0

	 * @access public

	 * @var array

	 */

	public $query_vars = array();



	/**

	 * List of found user ids

	 *

	 * @since 3.1.0

	 * @access private

	 * @var array

	 */

	private $results;



	/**

	 * Total number of found users for the current query

	 *

	 * @since 3.1.0

	 * @access private

	 * @var int

	 */

	private $total_users = 0;



	// SQL clauses

	public $query_fields;

	public $query_from;

	public $query_where;

	public $query_orderby;

	public $query_limit;



	/**

	 * PHP5 constructor.

	 *

	 * @since 3.1.0

	 *

	 * @param string|array $args Optional. The query variables.

	 * @return WP_User_Query

	 */

	public function __construct( $query = null ) {

		if ( ! empty( $query ) ) {

			$this->prepare_query( $query );

			$this->query();

		}

	}



	/**

	 * Prepare the query variables.

	 *

	 * @since 3.1.0

	 *

	 * @param string|array $args Optional. The query variables.

	 */

	public function prepare_query( $query = array() ) {

		global $wpdb;



		if ( empty( $this->query_vars ) || ! empty( $query ) ) {

			$this->query_limit = null;

			$this->query_vars = wp_parse_args( $query, array(

				'blog_id' => $GLOBALS['blog_id'],

				'role' => '',

				'meta_key' => '',

				'meta_value' => '',

				'meta_compare' => '',

				'include' => array(),

				'exclude' => array(),

				'search' => '',

				'search_columns' => array(),

				'orderby' => 'login',

				'order' => 'ASC',

				'offset' => '',

				'number' => '',

				'count_total' => true,

				'fields' => 'all',

				'who' => ''

			) );

		}



		/**

		 * Fires before the WP_User_Query has been parsed.

		 *

		 * The passed WP_User_Query object contains the query variables, not

		 * yet passed into SQL.

		 *

		 * @since 4.0.0

		 *

		 * @param WP_User_Query $this The current WP_User_Query instance,

		 *                            passed by reference.

		 */

		do_action( 'pre_get_users', $this );



		$qv =& $this->query_vars;



		if ( is_array( $qv['fields'] ) ) {

			$qv['fields'] = array_unique( $qv['fields'] );



			$this->query_fields = array();

			foreach ( $qv['fields'] as $field ) {

				$field = 'ID' === $field ? 'ID' : sanitize_key( $field );

				$this->query_fields[] = "$wpdb->users.$field";

			}

			$this->query_fields = implode( ',', $this->query_fields );

		} elseif ( 'all' == $qv['fields'] ) {

			$this->query_fields = "$wpdb->users.*";

		} else {

			$this->query_fields = "$wpdb->users.ID";

		}



		if ( isset( $qv['count_total'] ) && $qv['count_total'] )

			$this->query_fields = 'SQL_CALC_FOUND_ROWS ' . $this->query_fields;



		$this->query_from = "FROM $wpdb->users";

		$this->query_where = "WHERE 1=1";



		// sorting

		if ( isset( $qv['orderby'] ) ) {

			if ( in_array( $qv['orderby'], array('nicename', 'email', 'url', 'registered') ) ) {

				$orderby = 'user_' . $qv['orderby'];

			} elseif ( in_array( $qv['orderby'], array('user_nicename', 'user_email', 'user_url', 'user_registered') ) ) {

				$orderby = $qv['orderby'];

			} elseif ( 'name' == $qv['orderby'] || 'display_name' == $qv['orderby'] ) {

				$orderby = 'display_name';

			} elseif ( 'post_count' == $qv['orderby'] ) {

				// todo: avoid the JOIN

				$where = get_posts_by_author_sql('post');

				$this->query_from .= " LEFT OUTER JOIN (

					SELECT post_author, COUNT(*) as post_count

					FROM $wpdb->posts

					$where

					GROUP BY post_author

				) p ON ({$wpdb->users}.ID = p.post_author)

				";

				$orderby = 'post_count';

			} elseif ( 'ID' == $qv['orderby'] || 'id' == $qv['orderby'] ) {

				$orderby = 'ID';

			} elseif ( 'meta_value' == $qv['orderby'] ) {

				$orderby = "$wpdb->usermeta.meta_value";

			} else {

				$orderby = 'user_login';

			}

		}



		if ( empty( $orderby ) )

			$orderby = 'user_login';



		$qv['order'] = isset( $qv['order'] ) ? strtoupper( $qv['order'] ) : '';

		if ( 'ASC' == $qv['order'] )

			$order = 'ASC';

		else

			$order = 'DESC';

		$this->query_orderby = "ORDER BY $orderby $order";



		// limit

		if ( isset( $qv['number'] ) && $qv['number'] ) {

			if ( $qv['offset'] )

				$this->query_limit = $wpdb->prepare("LIMIT %d, %d", $qv['offset'], $qv['number']);

			else

				$this->query_limit = $wpdb->prepare("LIMIT %d", $qv['number']);

		}



		$search = '';

		if ( isset( $qv['search'] ) )

			$search = trim( $qv['search'] );



		if ( $search ) {

			$leading_wild = ( ltrim($search, '*') != $search );

			$trailing_wild = ( rtrim($search, '*') != $search );

			if ( $leading_wild && $trailing_wild )

				$wild = 'both';

			elseif ( $leading_wild )

				$wild = 'leading';

			elseif ( $trailing_wild )

				$wild = 'trailing';

			else

				$wild = false;

			if ( $wild )

				$search = trim($search, '*');



			$search_columns = array();

			if ( $qv['search_columns'] )

				$search_columns = array_intersect( $qv['search_columns'], array( 'ID', 'user_login', 'user_email', 'user_url', 'user_nicename' ) );

			if ( ! $search_columns ) {

				if ( false !== strpos( $search, '@') )

					$search_columns = array('user_email');

				elseif ( is_numeric($search) )

					$search_columns = array('user_login', 'ID');

				elseif ( preg_match('|^https?://|', $search) && ! ( is_multisite() && wp_is_large_network( 'users' ) ) )

					$search_columns = array('user_url');

				else

					$search_columns = array('user_login', 'user_nicename');

			}



			/**

			 * Filter the columns to search in a WP_User_Query search.

			 *

			 * The default columns depend on the search term, and include 'user_email',

			 * 'user_login', 'ID', 'user_url', and 'user_nicename'.

			 *

			 * @since 3.6.0

			 *

			 * @param array         $search_columns Array of column names to be searched.

			 * @param string        $search         Text being searched.

			 * @param WP_User_Query $this           The current WP_User_Query instance.

			 */

			$search_columns = apply_filters( 'user_search_columns', $search_columns, $search, $this );



			$this->query_where .= $this->get_search_sql( $search, $search_columns, $wild );

		}



		$blog_id = 0;

		if ( isset( $qv['blog_id'] ) )

			$blog_id = absint( $qv['blog_id'] );



		if ( isset( $qv['who'] ) && 'authors' == $qv['who'] && $blog_id ) {

			$qv['meta_key'] = $wpdb->get_blog_prefix( $blog_id ) . 'user_level';

			$qv['meta_value'] = 0;

			$qv['meta_compare'] = '!=';

			$qv['blog_id'] = $blog_id = 0; // Prevent extra meta query

		}



		$role = '';

		if ( isset( $qv['role'] ) )

			$role = trim( $qv['role'] );



		if ( $blog_id && ( $role || is_multisite() ) ) {

			$cap_meta_query = array();

			$cap_meta_query['key'] = $wpdb->get_blog_prefix( $blog_id ) . 'capabilities';



			if ( $role ) {

				$cap_meta_query['value'] = '"' . $role . '"';

				$cap_meta_query['compare'] = 'like';

			}



			if ( empty( $qv['meta_query'] ) || ! in_array( $cap_meta_query, $qv['meta_query'], true ) ) {

				$qv['meta_query'][] = $cap_meta_query;

			}

		}



		$meta_query = new WP_Meta_Query();

		$meta_query->parse_query_vars( $qv );



		if ( !empty( $meta_query->queries ) ) {

			$clauses = $meta_query->get_sql( 'user', $wpdb->users, 'ID', $this );

			$this->query_from .= $clauses['join'];

			$this->query_where .= $clauses['where'];



			if ( 'OR' == $meta_query->relation )

				$this->query_fields = 'DISTINCT ' . $this->query_fields;

		}



		if ( ! empty( $qv['include'] ) ) {

			$ids = implode( ',', wp_parse_id_list( $qv['include'] ) );

			$this->query_where .= " AND $wpdb->users.ID IN ($ids)";

		} elseif ( ! empty( $qv['exclude'] ) ) {

			$ids = implode( ',', wp_parse_id_list( $qv['exclude'] ) );

			$this->query_where .= " AND $wpdb->users.ID NOT IN ($ids)";

		}



		/**

		 * Fires after the WP_User_Query has been parsed, and before

		 * the query is executed.

		 *

		 * The passed WP_User_Query object contains SQL parts formed

		 * from parsing the given query.

		 *

		 * @since 3.1.0

		 *

		 * @param WP_User_Query $this The current WP_User_Query instance,

		 *                            passed by reference.

		 */

		do_action_ref_array( 'pre_user_query', array( &$this ) );

	}



	/**

	 * Execute the query, with the current variables.

	 *

	 * @since 3.1.0

	 *

	 * @global wpdb $wpdb WordPress database object for queries.

	 */

	public function query() {

		global $wpdb;



		$qv =& $this->query_vars;



		$query = "SELECT $this->query_fields $this->query_from $this->query_where $this->query_orderby $this->query_limit";



		if ( is_array( $qv['fields'] ) || 'all' == $qv['fields'] ) {

			$this->results = $wpdb->get_results( $query );

		} else {

			$this->results = $wpdb->get_col( $query );

		}



		/**

		 * Filter SELECT FOUND_ROWS() query for the current WP_User_Query instance.

		 *

		 * @since 3.2.0

		 *

		 * @global wpdb $wpdb WordPress database object.

		 *

		 * @param string $sql The SELECT FOUND_ROWS() query for the current WP_User_Query.

		 */

		if ( isset( $qv['count_total'] ) && $qv['count_total'] )

			$this->total_users = $wpdb->get_var( apply_filters( 'found_users_query', 'SELECT FOUND_ROWS()' ) );



		if ( !$this->results )

			return;



		if ( 'all_with_meta' == $qv['fields'] ) {

			cache_users( $this->results );



			$r = array();

			foreach ( $this->results as $userid )

				$r[ $userid ] = new WP_User( $userid, '', $qv['blog_id'] );



			$this->results = $r;

		} elseif ( 'all' == $qv['fields'] ) {

			foreach ( $this->results as $key => $user ) {

				$this->results[ $key ] = new WP_User( $user );

			}

		}

	}



	/**

	 * Retrieve query variable.

	 *

	 * @since 3.5.0

	 * @access public

	 *

	 * @param string $query_var Query variable key.

	 * @return mixed

	 */

	public function get( $query_var ) {

		if ( isset( $this->query_vars[$query_var] ) )

			return $this->query_vars[$query_var];



		return null;

	}



	/**

	 * Set query variable.

	 *

	 * @since 3.5.0

	 * @access public

	 *

	 * @param string $query_var Query variable key.

	 * @param mixed $value Query variable value.

	 */

	public function set( $query_var, $value ) {

		$this->query_vars[$query_var] = $value;

	}



	/**

	 * Used internally to generate an SQL string for searching across multiple columns

	 *

	 * @access protected

	 * @since 3.1.0

	 *

	 * @param string $string

	 * @param array $cols

	 * @param bool $wild Whether to allow wildcard searches. Default is false for Network Admin, true for

	 *  single site. Single site allows leading and trailing wildcards, Network Admin only trailing.

	 * @return string

	 */

	protected function get_search_sql( $string, $cols, $wild = false ) {

		global $wpdb;



		$searches = array();

		$leading_wild = ( 'leading' == $wild || 'both' == $wild ) ? '%' : '';

		$trailing_wild = ( 'trailing' == $wild || 'both' == $wild ) ? '%' : '';

		$like = $leading_wild . $wpdb->esc_like( $string ) . $trailing_wild;



		foreach ( $cols as $col ) {

			if ( 'ID' == $col ) {

				$searches[] = $wpdb->prepare( "$col = %s", $string );

			} else {

				$searches[] = $wpdb->prepare( "$col LIKE %s", $like );

			}

		}



		return ' AND (' . implode(' OR ', $searches) . ')';

	}



	/**

	 * Return the list of users.

	 *

	 * @since 3.1.0

	 * @access public

	 *

	 * @return array Array of results.

	 */

	public function get_results() {

		return $this->results;

	}



	/**

	 * Return the total number of users for the current query.

	 *

	 * @since 3.1.0

	 * @access public

	 *

	 * @return array Array of total users.

	 */

	public function get_total() {

		return $this->total_users;

	}



	/**

	 * Make private properties readable for backwards compatibility.

	 *

	 * @since 4.0.0

	 * @access public

	 *

	 * @param string $name Property to get.

	 * @return mixed Property.

	 */

	public function __get( $name ) {

		return $this->$name;

	}



	/**

	 * Make private properties settable for backwards compatibility.

	 *

	 * @since 4.0.0

	 * @access public

	 *

	 * @param string $name  Property to set.

	 * @param mixed  $value Property value.

	 * @return mixed Newly-set property.

	 */

	public function __set( $name, $value ) {

		return $this->$name = $value;

	}



	/**

	 * Make private properties checkable for backwards compatibility.

	 *

	 * @since 4.0.0

	 * @access public

	 *

	 * @param string $name Property to check if set.

	 * @return bool Whether the property is set.

	 */

	public function __isset( $name ) {

		return isset( $this->$name );

	}



	/**

	 * Make private properties un-settable for backwards compatibility.

	 *

	 * @since 4.0.0

	 * @access public

	 *

	 * @param string $name Property to unset.

	 */

	public function __unset( $name ) {

		unset( $this->$name );

	}



	/**

	 * Make private/protected methods readable for backwards compatibility.

	 *

	 * @since 4.0.0

	 * @access public

	 *

	 * @param callable $name      Method to call.

	 * @param array    $arguments Arguments to pass when calling.

	 * @return mixed|bool Return value of the callback, false otherwise.

	 */

	public function __call( $name, $arguments ) {

		return call_user_func_array( array( $this, $name ), $arguments );

	}

}



/**

 * Retrieve list of users matching criteria.

 *

 * @since 3.1.0

 *

 * @uses WP_User_Query See for default arguments and information.

 *

 * @param array $args Optional. Array of arguments.

 * @return array List of users.

 */

function get_users( $args = array() ) {



	$args = wp_parse_args( $args );

	$args['count_total'] = false;



	$user_search = new WP_User_Query($args);



	return (array) $user_search->get_results();

}



/**

 * Get the blogs a user belongs to.

 *

 * @since 3.0.0

 *

 * @global wpdb $wpdb WordPress database object for queries.

 *

 * @param int  $user_id User ID

 * @param bool $all     Whether to retrieve all blogs, or only blogs that are not

 *                      marked as deleted, archived, or spam.

 * @return array A list of the user's blogs. An empty array if the user doesn't exist

 *               or belongs to no blogs.

 */

function get_blogs_of_user( $user_id, $all = false ) {

	global $wpdb;



	$user_id = (int) $user_id;



	// Logged out users can't have blogs

	if ( empty( $user_id ) )

		return array();



	$keys = get_user_meta( $user_id );

	if ( empty( $keys ) )

		return array();



	if ( ! is_multisite() ) {

		$blog_id = get_current_blog_id();

		$blogs = array( $blog_id => new stdClass );

		$blogs[ $blog_id ]->userblog_id = $blog_id;

		$blogs[ $blog_id ]->blogname = get_option('blogname');

		$blogs[ $blog_id ]->domain = '';

		$blogs[ $blog_id ]->path = '';

		$blogs[ $blog_id ]->site_id = 1;

		$blogs[ $blog_id ]->siteurl = get_option('siteurl');

		$blogs[ $blog_id ]->archived = 0;

		$blogs[ $blog_id ]->spam = 0;

		$blogs[ $blog_id ]->deleted = 0;

		return $blogs;

	}



	$blogs = array();



	if ( isset( $keys[ $wpdb->base_prefix . 'capabilities' ] ) && defined( 'MULTISITE' ) ) {

		$blog = get_blog_details( 1 );

		if ( $blog && isset( $blog->domain ) && ( $all || ( ! $blog->archived && ! $blog->spam && ! $blog->deleted ) ) ) {

			$blogs[ 1 ] = (object) array(

				'userblog_id' => 1,

				'blogname'    => $blog->blogname,

				'domain'      => $blog->domain,

				'path'        => $blog->path,

				'site_id'     => $blog->site_id,

				'siteurl'     => $blog->siteurl,

				'archived'    => 0,

				'spam'        => 0,

				'deleted'     => 0

			);

		}

		unset( $keys[ $wpdb->base_prefix . 'capabilities' ] );

	}



	$keys = array_keys( $keys );



	foreach ( $keys as $key ) {

		if ( 'capabilities' !== substr( $key, -12 ) )

			continue;

		if ( $wpdb->base_prefix && 0 !== strpos( $key, $wpdb->base_prefix ) )

			continue;

		$blog_id = str_replace( array( $wpdb->base_prefix, '_capabilities' ), '', $key );

		if ( ! is_numeric( $blog_id ) )

			continue;



		$blog_id = (int) $blog_id;

		$blog = get_blog_details( $blog_id );

		if ( $blog && isset( $blog->domain ) && ( $all || ( ! $blog->archived && ! $blog->spam && ! $blog->deleted ) ) ) {

			$blogs[ $blog_id ] = (object) array(

				'userblog_id' => $blog_id,

				'blogname'    => $blog->blogname,

				'domain'      => $blog->domain,

				'path'        => $blog->path,

				'site_id'     => $blog->site_id,

				'siteurl'     => $blog->siteurl,

				'archived'    => 0,

				'spam'        => 0,

				'deleted'     => 0

			);

		}

	}



	/**

	 * Filter the list of blogs a user belongs to.

	 *

	 * @since MU

	 *

	 * @param array $blogs   An array of blog objects belonging to the user.

	 * @param int   $user_id User ID.

	 * @param bool  $all     Whether the returned blogs array should contain all blogs, including

	 *                       those marked 'deleted', 'archived', or 'spam'. Default false.

	 */

	return apply_filters( 'get_blogs_of_user', $blogs, $user_id, $all );

}



/**

 * Find out whether a user is a member of a given blog.

 *

 * @since MU 1.1

 * @uses get_blogs_of_user()

 *

 * @param int $user_id Optional. The unique ID of the user. Defaults to the current user.

 * @param int $blog_id Optional. ID of the blog to check. Defaults to the current site.

 * @return bool

 */

function is_user_member_of_blog( $user_id = 0, $blog_id = 0 ) {

	$user_id = (int) $user_id;

	$blog_id = (int) $blog_id;



	if ( empty( $user_id ) )

		$user_id = get_current_user_id();



	if ( empty( $blog_id ) )

		$blog_id = get_current_blog_id();



	$blogs = get_blogs_of_user( $user_id );

	return array_key_exists( $blog_id, $blogs );

}



/**

 * Add meta data field to a user.

 *

 * Post meta data is called "Custom Fields" on the Administration Screens.

 *

 * @since 3.0.0

 * @uses add_metadata()

 * @link http://codex.wordpress.org/Function_Reference/add_user_meta

 *

 * @param int $user_id User ID.

 * @param string $meta_key Metadata name.

 * @param mixed $meta_value Metadata value.

 * @param bool $unique Optional, default is false. Whether the same key should not be added.

 * @return int|bool Meta ID on success, false on failure.

 */

function add_user_meta($user_id, $meta_key, $meta_value, $unique = false) {

	return add_metadata('user', $user_id, $meta_key, $meta_value, $unique);

}



/**

 * Remove metadata matching criteria from a user.

 *

 * You can match based on the key, or key and value. Removing based on key and

 * value, will keep from removing duplicate metadata with the same key. It also

 * allows removing all metadata matching key, if needed.

 *

 * @since 3.0.0

 * @uses delete_metadata()

 * @link http://codex.wordpress.org/Function_Reference/delete_user_meta

 *

 * @param int $user_id user ID

 * @param string $meta_key Metadata name.

 * @param mixed $meta_value Optional. Metadata value.

 * @return bool True on success, false on failure.

 */

function delete_user_meta($user_id, $meta_key, $meta_value = '') {

	return delete_metadata('user', $user_id, $meta_key, $meta_value);

}



/**

 * Retrieve user meta field for a user.

 *

 * @since 3.0.0

 * @uses get_metadata()

 * @link http://codex.wordpress.org/Function_Reference/get_user_meta

 *

 * @param int $user_id User ID.

 * @param string $key Optional. The meta key to retrieve. By default, returns data for all keys.

 * @param bool $single Whether to return a single value.

 * @return mixed Will be an array if $single is false. Will be value of meta data field if $single

 *  is true.

 */

function get_user_meta($user_id, $key = '', $single = false) {

	return get_metadata('user', $user_id, $key, $single);

}



/**

 * Update user meta field based on user ID.

 *

 * Use the $prev_value parameter to differentiate between meta fields with the

 * same key and user ID.

 *

 * If the meta field for the user does not exist, it will be added.

 *

 * @since 3.0.0

 * @uses update_metadata

 * @link http://codex.wordpress.org/Function_Reference/update_user_meta

 *

 * @param int $user_id User ID.

 * @param string $meta_key Metadata key.

 * @param mixed $meta_value Metadata value.

 * @param mixed $prev_value Optional. Previous value to check before removing.

 * @return int|bool Meta ID if the key didn't exist, true on successful update, false on failure.

 */

function update_user_meta($user_id, $meta_key, $meta_value, $prev_value = '') {

	return update_metadata('user', $user_id, $meta_key, $meta_value, $prev_value);

}



/**

 * Count number of users who have each of the user roles.

 *

 * Assumes there are neither duplicated nor orphaned capabilities meta_values.

 * Assumes role names are unique phrases. Same assumption made by WP_User_Query::prepare_query()

 * Using $strategy = 'time' this is CPU-intensive and should handle around 10^7 users.

 * Using $strategy = 'memory' this is memory-intensive and should handle around 10^5 users, but see WP Bug #12257.

 *

 * @since 3.0.0

 * @param string $strategy 'time' or 'memory'

 * @return array Includes a grand total and an array of counts indexed by role strings.

 */

function count_users($strategy = 'time') {

	global $wpdb, $wp_roles;



	// Initialize

	$id = get_current_blog_id();

	$blog_prefix = $wpdb->get_blog_prefix($id);

	$result = array();



	if ( 'time' == $strategy ) {

		global $wp_roles;



		if ( ! isset( $wp_roles ) )

			$wp_roles = new WP_Roles();



		$avail_roles = $wp_roles->get_names();



		// Build a CPU-intensive query that will return concise information.

		$select_count = array();

		foreach ( $avail_roles as $this_role => $name ) {

			$select_count[] = $wpdb->prepare( "COUNT(NULLIF(`meta_value` LIKE %s, false))", '%' . $wpdb->esc_like( '"' . $this_role . '"' ) . '%');

		}

		$select_count = implode(', ', $select_count);



		// Add the meta_value index to the selection list, then run the query.

		$row = $wpdb->get_row( "SELECT $select_count, COUNT(*) FROM $wpdb->usermeta WHERE meta_key = '{$blog_prefix}capabilities'", ARRAY_N );



		// Run the previous loop again to associate results with role names.

		$col = 0;

		$role_counts = array();

		foreach ( $avail_roles as $this_role => $name ) {

			$count = (int) $row[$col++];

			if ($count > 0) {

				$role_counts[$this_role] = $count;

			}

		}



		// Get the meta_value index from the end of the result set.

		$total_users = (int) $row[$col];



		$result['total_users'] = $total_users;

		$result['avail_roles'] =& $role_counts;

	} else {

		$avail_roles = array();



		$users_of_blog = $wpdb->get_col( "SELECT meta_value FROM $wpdb->usermeta WHERE meta_key = '{$blog_prefix}capabilities'" );



		foreach ( $users_of_blog as $caps_meta ) {

			$b_roles = maybe_unserialize($caps_meta);

			if ( ! is_array( $b_roles ) )

				continue;

			foreach ( $b_roles as $b_role => $val ) {

				if ( isset($avail_roles[$b_role]) ) {

					$avail_roles[$b_role]++;

				} else {

					$avail_roles[$b_role] = 1;

				}

			}

		}



		$result['total_users'] = count( $users_of_blog );

		$result['avail_roles'] =& $avail_roles;

	}



	return $result;

}



//

// Private helper functions

//



/**

 * Set up global user vars.

 *

 * Used by wp_set_current_user() for back compat. Might be deprecated in the future.

 *

 * @since 2.0.4

 * @global string $userdata User description.

 * @global string $user_login The user username for logging in

 * @global int $user_level The level of the user

 * @global int $user_ID The ID of the user

 * @global string $user_email The email address of the user

 * @global string $user_url The url in the user's profile

 * @global string $user_identity The display name of the user

 *

 * @param int $for_user_id Optional. User ID to set up global data.

 */

function setup_userdata($for_user_id = '') {

	global $user_login, $userdata, $user_level, $user_ID, $user_email, $user_url, $user_identity;



	if ( '' == $for_user_id )

		$for_user_id = get_current_user_id();

	$user = get_userdata( $for_user_id );



	if ( ! $user ) {

		$user_ID = 0;

		$user_level = 0;

		$userdata = null;

		$user_login = $user_email = $user_url = $user_identity = '';

		return;

	}



	$user_ID    = (int) $user->ID;

	$user_level = (int) $user->user_level;

	$userdata   = $user;

	$user_login = $user->user_login;

	$user_email = $user->user_email;

	$user_url   = $user->user_url;

	$user_identity = $user->display_name;

}



/**

 * Create dropdown HTML content of users.

 *

 * The content can either be displayed, which it is by default or retrieved by

 * setting the 'echo' argument. The 'include' and 'exclude' arguments do not

 * need to be used; all users will be displayed in that case. Only one can be

 * used, either 'include' or 'exclude', but not both.

 *

 * The available arguments are as follows:

 *

 * @since 2.3.0

 *

 * @global wpdb $wpdb WordPress database object for queries.

 *

 * @param array|string $args {

 *     Optional. Array or string of arguments to generate a drop-down of users.

 *     {@see WP_User_Query::prepare_query() for additional available arguments.

 *

 *     @type string       $show_option_all         Text to show as the drop-down default (all).

 *                                                 Default empty.

 *     @type string       $show_option_none        Text to show as the drop-down default when no

 *                                                 users were found. Default empty.

 *     @type int|string   $option_none_value       Value to use for $show_option_non when no users

 *                                                 were found. Default -1.

 *     @type string       $hide_if_only_one_author Whether to skip generating the drop-down

 *                                                 if only one user was found. Default empty.

 *     @type string       $orderby                 Field to order found users by. Accepts user fields.

 *                                                 Default 'display_name'.

 *     @type string       $order                   Whether to order users in ascending or descending

 *                                                 order. Accepts 'ASC' (ascending) or 'DESC' (descending).

 *                                                 Default 'ASC'.

 *     @type array|string $include                 Array or comma-separated list of user IDs to include.

 *                                                 Default empty.

 *     @type array|string $exclude                 Array or comma-separated list of user IDs to exclude.

 *                                                 Default empty.

 *     @type bool|int     $multi                   Whether to skip the ID attribute on the 'select' element.

 *                                                 Accepts 1|true or 0|false. Default 0|false.

 *     @type string       $show                    User table column to display. If the selected item is empty

 *                                                 then the 'user_login' will be displayed in parentheses.

 *                                                 Accepts user fields. Default 'display_name'.

 *     @type int|bool     $echo                    Whether to echo or return the drop-down. Accepts 1|true (echo)

 *                                                 or 0|false (return). Default 1|true.

 *     @type int          $selected                Which user ID should be selected. Default 0.

 *     @type bool         $include_selected        Whether to always include the selected user ID in the drop-

 *                                                 down. Default false.

 *     @type string       $name                    Name attribute of select element. Default 'user'.

 *     @type string       $id                      ID attribute of the select element. Default is the value of $name.

 *     @type string       $class                   Class attribute of the select element. Default empty.

 *     @type int          $blog_id                 ID of blog (Multisite only). Default is ID of the current blog.

 *     @type string       $who                     Which type of users to query. Accepts only an empty string or

 *                                                 'authors'. Default empty.

 * }

 * @return string|null Null on display. String of HTML content on retrieve.

 */

function wp_dropdown_users( $args = '' ) {

	$defaults = array(

		'show_option_all' => '', 'show_option_none' => '', 'hide_if_only_one_author' => '',

		'orderby' => 'display_name', 'order' => 'ASC',

		'include' => '', 'exclude' => '', 'multi' => 0,

		'show' => 'display_name', 'echo' => 1,

		'selected' => 0, 'name' => 'user', 'class' => '', 'id' => '',

		'blog_id' => $GLOBALS['blog_id'], 'who' => '', 'include_selected' => false,

		'option_none_value' => -1

	);



	$defaults['selected'] = is_author() ? get_query_var( 'author' ) : 0;



	$r = wp_parse_args( $args, $defaults );

	$show = $r['show'];

	$show_option_all = $r['show_option_all'];

	$show_option_none = $r['show_option_none'];

	$option_none_value = $r['option_none_value'];



	$query_args = wp_array_slice_assoc( $r, array( 'blog_id', 'include', 'exclude', 'orderby', 'order', 'who' ) );

	$query_args['fields'] = array( 'ID', 'user_login', $show );

	$users = get_users( $query_args );



	$output = '';

	if ( ! empty( $users ) && ( empty( $r['hide_if_only_one_author'] ) || count( $users ) > 1 ) ) {

		$name = esc_attr( $r['name'] );

		if ( $r['multi'] && ! $r['id'] ) {

			$id = '';

		} else {

			$id = $r['id'] ? " id='" . esc_attr( $r['id'] ) . "'" : " id='$name'";

		}

		$output = "<select name='{$name}'{$id} class='" . $r['class'] . "'>\n";



		if ( $show_option_all ) {

			$output .= "\t<option value='0'>$show_option_all</option>\n";

		}



		if ( $show_option_none ) {

			$_selected = selected( $option_none_value, $r['selected'], false );

			$output .= "\t<option value='" . esc_attr( $option_none_value ) . "'$_selected>$show_option_none</option>\n";

		}



		$found_selected = false;

		foreach ( (array) $users as $user ) {

			$user->ID = (int) $user->ID;

			$_selected = selected( $user->ID, $r['selected'], false );

			if ( $_selected ) {

				$found_selected = true;

			}

			$display = ! empty( $user->$show ) ? $user->$show : '('. $user->user_login . ')';

			$output .= "\t<option value='$user->ID'$_selected>" . esc_html( $display ) . "</option>\n";

		}



		if ( $r['include_selected'] && ! $found_selected && ( $r['selected'] > 0 ) ) {

			$user = get_userdata( $r['selected'] );

			$_selected = selected( $user->ID, $r['selected'], false );

			$display = ! empty( $user->$show ) ? $user->$show : '('. $user->user_login . ')';

			$output .= "\t<option value='$user->ID'$_selected>" . esc_html( $display ) . "</option>\n";

		}



		$output .= "</select>";

	}



	/**

	 * Filter the wp_dropdown_users() HTML output.

	 *

	 * @since 2.3.0

	 *

	 * @param string $output HTML output generated by wp_dropdown_users().

	 */

	$html = apply_filters( 'wp_dropdown_users', $output );



	if ( $r['echo'] ) {

		echo $html;

	}

	return $html;

}



/**

 * Sanitize user field based on context.

 *

 * Possible context values are:  'raw', 'edit', 'db', 'display', 'attribute' and 'js'. The

 * 'display' context is used by default. 'attribute' and 'js' contexts are treated like 'display'

 * when calling filters.

 *

 * @since 2.3.0

 *

 * @param string $field The user Object field name.

 * @param mixed $value The user Object value.

 * @param int $user_id user ID.

 * @param string $context How to sanitize user fields. Looks for 'raw', 'edit', 'db', 'display',

 *               'attribute' and 'js'.

 * @return mixed Sanitized value.

 */

function sanitize_user_field($field, $value, $user_id, $context) {

	$int_fields = array('ID');

	if ( in_array($field, $int_fields) )

		$value = (int) $value;



	if ( 'raw' == $context )

		return $value;



	if ( !is_string($value) && !is_numeric($value) )

		return $value;



	$prefixed = false !== strpos( $field, 'user_' );



	if ( 'edit' == $context ) {

		if ( $prefixed ) {



			/** This filter is documented in wp-includes/post.php */

			$value = apply_filters( "edit_{$field}", $value, $user_id );

		} else {



			/**

			 * Filter a user field value in the 'edit' context.

			 *

			 * The dynamic portion of the hook name, $field, refers to the prefixed user

			 * field being filtered, such as 'user_login', 'user_email', 'first_name', etc.

			 *

			 * @since 2.9.0

			 *

			 * @param mixed $value   Value of the prefixed user field.

			 * @param int   $user_id User ID.

			 */

			$value = apply_filters( "edit_user_{$field}", $value, $user_id );

		}



		if ( 'description' == $field )

			$value = esc_html( $value ); // textarea_escaped?

		else

			$value = esc_attr($value);

	} else if ( 'db' == $context ) {

		if ( $prefixed ) {

			/** This filter is documented in wp-includes/post.php */

			$value = apply_filters( "pre_{$field}", $value );

		} else {



			/**

			 * Filter the value of a user field in the 'db' context.

			 *

			 * The dynamic portion of the hook name, $field, refers to the prefixed user

			 * field being filtered, such as 'user_login', 'user_email', 'first_name', etc.

 			 *

			 * @since 2.9.0

			 *

			 * @param mixed $value Value of the prefixed user field.

			 */

			$value = apply_filters( "pre_user_{$field}", $value );

		}

	} else {

		// Use display filters by default.

		if ( $prefixed ) {



			/** This filter is documented in wp-includes/post.php */

			$value = apply_filters( $field, $value, $user_id, $context );

		} else {



			/**

			 * Filter the value of a user field in a standard context.

			 *

			 * The dynamic portion of the hook name, $field, refers to the prefixed user

			 * field being filtered, such as 'user_login', 'user_email', 'first_name', etc.

			 *

			 * @since 2.9.0

			 *

			 * @param mixed  $value   The user object value to sanitize.

			 * @param int    $user_id User ID.

			 * @param string $context The context to filter within.

			 */

			$value = apply_filters( "user_{$field}", $value, $user_id, $context );

		}

	}



	if ( 'user_url' == $field )

		$value = esc_url($value);



	if ( 'attribute' == $context )

		$value = esc_attr($value);

	else if ( 'js' == $context )

		$value = esc_js($value);



	return $value;

}



/**

 * Update all user caches

 *

 * @since 3.0.0

 *

 * @param object $user User object to be cached

 */

function update_user_caches($user) {

	wp_cache_add($user->ID, $user, 'users');

	wp_cache_add($user->user_login, $user->ID, 'userlogins');

	wp_cache_add($user->user_email, $user->ID, 'useremail');

	wp_cache_add($user->user_nicename, $user->ID, 'userslugs');

}



/**

 * Clean all user caches

 *

 * @since 3.0.0

 *

 * @param WP_User|int $user User object or ID to be cleaned from the cache

 */

function clean_user_cache( $user ) {

	if ( is_numeric( $user ) )

		$user = new WP_User( $user );



	if ( ! $user->exists() )

		return;



	wp_cache_delete( $user->ID, 'users' );

	wp_cache_delete( $user->user_login, 'userlogins' );

	wp_cache_delete( $user->user_email, 'useremail' );

	wp_cache_delete( $user->user_nicename, 'userslugs' );

}



/**

 * Checks whether the given username exists.

 *

 * @since 2.0.0

 *

 * @param string $username Username.

 * @return null|int The user's ID on success, and null on failure.

 */

function username_exists( $username ) {

	if ( $user = get_user_by('login', $username ) ) {

		return $user->ID;

	} else {

		return null;

	}

}



/**

 * Checks whether the given email exists.

 *

 * @since 2.1.0

 *

 * @param string $email Email.

 * @return bool|int The user's ID on success, and false on failure.

 */

function email_exists( $email ) {

	if ( $user = get_user_by('email', $email) )

		return $user->ID;



	return false;

}



/**

 * Checks whether an username is valid.

 *

 * @since 2.0.1

 * @uses apply_filters() Calls 'validate_user…