PHP username_exists函数代码示例

function wppb_check_username_value($message, $field, $request_data, $form_location)
{
    global $wpdb;
    if ($field['required'] == 'Yes') {
        if (isset($request_data['username']) && trim($request_data['username']) == '' || $form_location == 'register' && !isset($request_data['username'])) {
            return wppb_required_field_error($field["field-title"]);
        }
    }
    if (!empty($request_data['username'])) {
        if ($form_location == 'register') {
            if (username_exists($request_data['username'])) {
                return __('This username already exists.', 'profile-builder') . '<br/>' . __('Please try a different one!', 'profile-builder');
            }
            if (!validate_username($request_data['username'])) {
                return __('This username is invalid because it uses illegal characters.', 'profile-builder') . '<br/>' . __('Please enter a valid username.', 'profile-builder');
            }
        }
        $wppb_generalSettings = get_option('wppb_general_settings');
        if ($wppb_generalSettings['emailConfirmation'] == 'yes') {
            if (is_multisite() && $request_data['username'] != preg_replace('/\\s+/', '', $request_data['username'])) {
                return __('This username is invalid because it uses illegal characters.', 'profile-builder') . '<br/>' . __('Please enter a valid username.', 'profile-builder');
            }
            $userSignup = $wpdb->get_results($wpdb->prepare("SELECT * FROM " . $wpdb->prefix . "signups WHERE user_login = %s", $request_data['username']));
            if (!empty($userSignup)) {
                return __('This username is already reserved to be used soon.', 'profile-builder') . '<br/>' . __('Please try a different one!', 'profile-builder');
            }
        }
    }
    return $message;
}

function registration_validation($username, $password, $email)
{
    global $reg_errors;
    $reg_errors = new WP_Error();
    if (empty($username) || empty($password) || empty($email)) {
        $reg_errors->add('field', 'Required form field is missing');
    }
    if (4 > strlen($username)) {
        $reg_errors->add('username_length', 'Username too short. At least 4 characters is required');
    }
    if (username_exists($username)) {
        $reg_errors->add('user_name', 'Sorry, that username already exists!');
    }
    if (!validate_username($username)) {
        $reg_errors->add('username_invalid', 'Sorry, the username you entered is not valid');
    }
    if (5 > strlen($password)) {
        $reg_errors->add('password', 'Password length must be greater than 5');
    }
    if (!is_email($email)) {
        $reg_errors->add('email_invalid', 'Email is not valid');
    }
    if (email_exists($email)) {
        $reg_errors->add('email', 'Email Already in use');
    }
    if (is_wp_error($reg_errors)) {
        foreach ($reg_errors->get_error_messages() as $error) {
            echo '<div>';
            echo '<strong>ERROR</strong>:';
            echo $error . '<br/>';
            echo '</div>';
        }
    }
}

 function checkauthor($author)
 {
     global $wpdb;
     //mtnames is an array with the names in the mt import file
     $pass = 'changeme';
     if (!in_array($author, $this->mtnames)) {
         //a new mt author name is found
         ++$this->j;
         $this->mtnames[$this->j] = $author;
         //add that new mt author name to an array
         $user_id = username_exists($this->newauthornames[$j]);
         //check if the new author name defined by the user is a pre-existing wp user
         if (!$user_id) {
             //banging my head against the desk now.
             if ($newauthornames[$this->j] == 'left_blank') {
                 //check if the user does not want to change the authorname
                 $user_id = wp_create_user($author, $pass);
                 $this->newauthornames[$this->j] = $author;
                 //now we have a name, in the place of left_blank.
             } else {
                 $user_id = wp_create_user($this->newauthornames[$this->j], $pass);
             }
         } else {
             return $user_id;
             // return pre-existing wp username if it exists
         }
     } else {
         $key = array_search($author, $this->mtnames);
         //find the array key for $author in the $mtnames array
         $user_id = username_exists($this->newauthornames[$key]);
         //use that key to get the value of the author's name from $newauthornames
     }
     return $user_id;
 }

function lls_authenticate($user, $username)
{
    // 1. Get all active session for this user
    if (!username_exists($username) || !($user = get_user_by('login', $username))) {
        return null;
    }
    // will trigger WP default no username/password matched error
    // setup vars
    $max_sessions = 5;
    $max_oldest_allowed_session_hours = 4;
    $error_code = 'max_session_reached';
    $error_message = "Maximum {$max_sessions} login sessions are allowed. Please contact site administrator.";
    $manager = WP_Session_Tokens::get_instance($user->ID);
    $sessions = $manager->get_all();
    // 2. Count all active session
    $session_count = count($sessions);
    // 3. Return okay if active session less then $max_sessions
    if ($session_count < $max_sessions) {
        return $user;
    }
    $oldest_activity_session = lls_get_oldest_activity_session($sessions);
    // 4. If active sessions is equal to 5 then check if a session has no activity last 4 hours
    // 5. if oldest session have activity return error
    if ($session_count >= $max_sessions && !$oldest_activity_session || $session_count >= $max_sessions && $oldest_activity_session['last_activity'] + $max_oldest_allowed_session_hours * HOUR_IN_SECONDS > time()) {
        return new WP_Error($error_code, $error_message);
    }
    // 5. Oldest activity session doesn't have activity is given recent hours
    // destroy oldest active session and authenticate the user
    $verifier = lls_get_verifier_by_session($oldest_activity_session, $user->ID);
    lls_destroy_session($verifier, $user->ID);
    return $user;
}

 function validate_signup()
 {
     require_once WPPR_PLUGIN_DIR . '/models/signup-model.php';
     $model = new Signup_Model();
     if (username_exists($this->username)) {
         return new WP_Error('username_unavailable', 'Username already taken');
     }
     if (!validate_username($this->username)) {
         // invalid username
         return new WP_Error('username_invalid', 'Username is invalid');
     }
     if (strlen($this->username) < 4) {
         return new WP_Error('username_length', 'Username too short. At least 4 characters is required');
     }
     if (!is_email($this->email)) {
         return new WP_Error('email_invalid', 'Email is not valid');
     }
     if (email_exists($this->email)) {
         return new WP_Error('email', 'Email is already in used.');
     }
     if ($model->validate_email($this->email)) {
         return new WP_Error('email', 'You already used this email to signup. Please check your email for confirmation.');
     }
     if (strlen($this->password) <= 5) {
         return new WP_Error('password_too_short', 'Password is too short.');
     }
 }

 function validate_form_saved($fields)
 {
     if (isset($_POST['submit'])) {
         $current_user = wp_get_current_user();
         $user_email = $_POST['user_email'];
         // receiving email address
         //Si cambio de usuario y existe es error y no continua
         if ($current_user->user_email != $_POST['user_email'] && username_exists($user_email) != false) {
             ?>
             <script>
                 jQuery(document).on('ready', function(){
                     jQuery("#emailErr").html("Intenta con otro email, este ya está registrado");
                     jQuery("#emailErr").show();
                 }); </script>
             <?php 
             return;
         }
         //Actualiza los daos basicos
         $current_user->user_email = $user_email;
         $current_user->user_login = $user_email;
         $current_user->first_name = $_POST['user_first_name'];
         wp_update_user($current_user);
         //Recorre todos los campos del formulario y valida
         foreach ($fields as $field) {
             $keyfield = sanitize_key($field->Name) . "_" . $field->Id;
             update_user_meta($current_user->ID, sanitize_key($field->Name), $_POST[$keyfield], $current_user->get(sanitize_key($field->Name)));
         }
     }
 }

function um_submit_form_errors_hook_login($args)
{
    global $ultimatemember;
    $is_email = false;
    $form_id = $args['form_id'];
    $mode = $args['mode'];
    if (isset($args['username']) && $args['username'] == '') {
        $ultimatemember->form->add_error('username', __('Please enter your username or email', 'ultimatemember'));
    }
    if (isset($args['user_login']) && $args['user_login'] == '') {
        $ultimatemember->form->add_error('user_login', __('Please enter your username', 'ultimatemember'));
    }
    if (isset($args['user_email']) && $args['user_email'] == '') {
        $ultimatemember->form->add_error('user_email', __('Please enter your email', 'ultimatemember'));
    }
    if (isset($args['username'])) {
        $field = 'username';
        if (is_email($args['username'])) {
            $is_email = true;
            $data = get_user_by('email', $args['username']);
            $user_name = isset($data->user_login) ? $data->user_login : null;
        } else {
            $user_name = $args['username'];
        }
    } else {
        if (isset($args['user_email'])) {
            $field = 'user_email';
            $is_email = true;
            $data = get_user_by('email', $args['user_email']);
            $user_name = isset($data->user_login) ? $data->user_login : null;
        } else {
            $field = 'user_login';
            $user_name = $args['user_login'];
        }
    }
    if (!username_exists($user_name)) {
        if ($is_email) {
            $ultimatemember->form->add_error($field, __(' Sorry, we can\'t find an account with that email address', 'ultimatemember'));
        } else {
            $ultimatemember->form->add_error($field, __(' Sorry, we can\'t find an account with that username', 'ultimatemember'));
        }
    } else {
        if ($args['user_password'] == '') {
            $ultimatemember->form->add_error('user_password', __('Please enter your password', 'ultimatemember'));
        }
    }
    $user = get_user_by('login', $user_name);
    if ($user && wp_check_password($args['user_password'], $user->data->user_pass, $user->ID)) {
        $ultimatemember->login->auth_id = username_exists($user_name);
    } else {
        $ultimatemember->form->add_error('user_password', __('Password is incorrect. Please try again.', 'ultimatemember'));
    }
    // add a way for other plugins like wp limit login
    // to limit the login attempts
    $user = apply_filters('authenticate', null, $user_name, $args['user_password']);
    // if there is an error notify wp
    if ($ultimatemember->form->has_error($field) || $ultimatemember->form->has_error($user_password)) {
        do_action('wp_login_failed', $user_name);
    }
}

 /**
  * Installs the blog
  *
  * {@internal Missing Long Description}}
  *
  * @since 2.1.0
  *
  * @param string $blog_title Blog title.
  * @param string $user_name User's username.
  * @param string $user_email User's email.
  * @param bool $public Whether blog is public.
  * @param string $deprecated Optional. Not used.
  * @param string $user_password Optional. User's chosen password. Will default to a random password.
  * @param string $language Optional. Language chosen.
  * @return array Array keys 'url', 'user_id', 'password', 'password_message'.
  */
 function wp_install($blog_title, $user_name, $user_email, $public, $deprecated = '', $user_password = '', $language = '')
 {
     if (!empty($deprecated)) {
         _deprecated_argument(__FUNCTION__, '2.6');
     }
     wp_check_mysql_version();
     wp_cache_flush();
     make_db_current_silent();
     populate_options();
     populate_roles();
     update_option('blogname', $blog_title);
     update_option('admin_email', $user_email);
     update_option('blog_public', $public);
     if ($language) {
         update_option('WPLANG', $language);
     }
     $guessurl = wp_guess_url();
     update_option('siteurl', $guessurl);
     // If not a public blog, don't ping.
     if (!$public) {
         update_option('default_pingback_flag', 0);
     }
     /*
      * Create default user. If the user already exists, the user tables are
      * being shared among blogs. Just set the role in that case.
      */
     $user_id = username_exists($user_name);
     $user_password = trim($user_password);
     $email_password = false;
     if (!$user_id && empty($user_password)) {
         $user_password = wp_generate_password(12, false);
         $message = __('<strong><em>Note that password</em></strong> carefully! It is a <em>random</em> password that was generated just for you.');
         $user_id = wp_create_user($user_name, $user_password, $user_email);
         update_user_option($user_id, 'default_password_nag', true, true);
         $email_password = true;
     } else {
         if (!$user_id) {
             // Password has been provided
             $message = '<em>' . __('Your chosen password.') . '</em>';
             $user_id = wp_create_user($user_name, $user_password, $user_email);
         } else {
             $message = __('User already exists. Password inherited.');
         }
     }
     $user = new WP_User($user_id);
     $user->set_role('administrator');
     wp_install_defaults($user_id);
     flush_rewrite_rules();
     wp_new_blog_notification($blog_title, $guessurl, $user_id, $email_password ? $user_password : __('The password you chose during the install.'));
     wp_cache_flush();
     /**
      * Fires after a site is fully installed.
      *
      * @since 3.9.0
      *
      * @param WP_User $user The site owner.
      */
     do_action('wp_install', $user);
     return array('url' => $guessurl, 'user_id' => $user_id, 'password' => $user_password, 'password_message' => $message);
 }

 public function test_add_a_guardian()
 {
     $guardian_id = username_exists('sam');
     $this->plugin->addGuardian($guardian_id, get_current_user_id());
     $this->assertTrue(in_array($guardian_id, get_user_meta(get_current_user_id(), 'better-angels_guardians')));
     return $guardian_id;
 }

 function wp_install($blog_title, $user_name, $user_email, $public, $deprecated = '')
 {
     global $wp_rewrite;
     wp_check_mysql_version();
     wp_cache_flush();
     make_db_current_silent();
     populate_options();
     populate_roles();
     update_option('blogname', $blog_title);
     update_option('admin_email', $user_email);
     update_option('blog_public', $public);
     $guessurl = wp_guess_url();
     update_option('siteurl', $guessurl);
     // If not a public blog, don't ping.
     if (!$public) {
         update_option('default_pingback_flag', 0);
     }
     // Create default user.  If the user already exists, the user tables are
     // being shared among blogs.  Just set the role in that case.
     $user_id = username_exists($user_name);
     if (!$user_id) {
         $random_password = wp_generate_password();
         $user_id = wp_create_user($user_name, $random_password, $user_email);
     } else {
         $random_password = __('User already exists.  Password inherited.');
     }
     $user = new WP_User($user_id);
     $user->set_role('administrator');
     wp_install_defaults($user_id);
     $wp_rewrite->flush_rules();
     wp_new_blog_notification($blog_title, $guessurl, $user_id, $random_password);
     wp_cache_flush();
     return array('url' => $guessurl, 'user_id' => $user_id, 'password' => $random_password);
 }

 /**
  * Processes credentials to pass into wp_signon to log a user into WordPress.
  *
  * @uses check_ajax_referer()
  * @uses wp_signon()
  * @uses is_wp_error()
  *
  * @param $user_login (string) Defaults to $_POST['user_login']
  * @param $password (string)
  * @param $is_ajax (bool) Process as an AJAX request
  * @package AJAX
  *
  * @return userlogin on success; 0 on false;
  */
 public function login_submit($user_login = null, $password = null, $is_ajax = true)
 {
     /**
      * Verify the AJAX request
      */
     if ($is_ajax) {
         check_ajax_referer('login_submit', 'security');
     }
     $username = empty($_POST['user_login']) ? $user_login : sanitize_text_field($_POST['user_login']);
     $password = empty($_POST['password']) ? $password : sanitize_text_field($_POST['password']);
     $remember = !empty($_POST['rememberme']) ? true : false;
     // Currently wp_signon returns the same error code 'invalid_username' if
     // a username does not exists or is invalid
     if (validate_username($username)) {
         if (username_exists($username)) {
             $creds = array('user_login' => $username, 'user_password' => $password, 'remember' => $remember);
             $user = wp_signon($creds, false);
             $status = is_wp_error($user) ? $this->status($user->get_error_code()) : $this->status('success_login');
         } else {
             $status = $this->status('username_does_not_exists');
         }
     } else {
         $status = $this->status('invalid_username');
     }
     if ($is_ajax) {
         wp_send_json($status);
     } else {
         return $status;
     }
 }

/**
 * Searches through the content of an activity item to locate usernames,
 * designated by an @ sign.
 *
 * @since BuddyPress (1.5)
 *
 * @param string $content The content of the activity, usually found in $activity->content.
 * @return mixed Associative array with user ID as key and username as value. Boolean false if no mentions found.
 */
function bp_activity_find_mentions($content)
{
    $pattern = '/[@]+([A-Za-z0-9-_\\.@]+)\\b/';
    preg_match_all($pattern, $content, $usernames);
    // Make sure there's only one instance of each username
    if (!($usernames = array_unique($usernames[1]))) {
        return false;
    }
    $mentioned_users = array();
    // We've found some mentions! Check to see if users exist
    foreach ((array) $usernames as $key => $username) {
        if (bp_is_username_compatibility_mode()) {
            $user_id = username_exists($username);
        } else {
            $user_id = bp_core_get_userid_from_nicename($username);
        }
        // user ID exists, so let's add it to our array
        if (!empty($user_id)) {
            $mentioned_users[$user_id] = $username;
        }
    }
    if (empty($mentioned_users)) {
        return false;
    }
    return $mentioned_users;
}

 function wp_install($blog_title, $user_name, $user_email, $public, $meta = '')
 {
     global $wp_rewrite;
     wp_check_mysql_version();
     wp_cache_flush();
     make_db_current_silent();
     populate_options();
     populate_roles();
     update_option('blogname', $blog_title);
     update_option('admin_email', $user_email);
     update_option('blog_public', $public);
     $schema = isset($_SERVER['HTTPS']) && strtolower($_SERVER['HTTPS']) == 'on' ? 'https://' : 'http://';
     $guessurl = preg_replace('|/wp-admin/.*|i', '', $schema . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI']);
     update_option('siteurl', $guessurl);
     // If not a public blog, don't ping.
     if (!$public) {
         update_option('default_pingback_flag', 0);
     }
     // Create default user.  If the user already exists, the user tables are
     // being shared among blogs.  Just set the role in that case.
     $user_id = username_exists($user_name);
     if (!$user_id) {
         $random_password = substr(md5(uniqid(microtime())), 0, 6);
         $user_id = wp_create_user($user_name, $random_password, $user_email);
     } else {
         $random_password = __('User already exists.  Password inherited.');
     }
     $user = new WP_User($user_id);
     $user->set_role('administrator');
     wp_install_defaults($user_id);
     $wp_rewrite->flush_rules();
     wp_new_blog_notification($blog_title, $guessurl, $user_id, $random_password);
     wp_cache_flush();
     return array('url' => $guessurl, 'user_id' => $user_id, 'password' => $random_password);
 }

 public function user_register()
 {
     global $wpdb;
     $data = $_POST;
     $login_data = array();
     $resp = new ajax_response($data['action'], true);
     $code_data = $wpdb->get_results('SELECT * FROM ' . $wpdb->register_codes . ' WHERE 1=1 AND register_code == ' . $wpdb->escape($data['sec_code']));
     if ($code_data->register_code_used == 0) {
         $username = $wpdb->escape($data['user_name']);
         $exists = username_exists($username);
         if (!$exists) {
             $user_id = wp_create_user($username, wp_generate_password($length = 12, $include_standard_special_chars = false), $username);
             wp_new_user_notification($user_id, null, true);
             if (!is_wp_error($user_id)) {
                 $user = get_user_by('id', $user_id);
                 $wpdb->update($wpdb->register_codes, array('register_code_used' => 1, 'register_code_used_by' => $user->data->user_login), array('register_code' => $wpdb->escape($data['sec_code'])));
                 $resp->set_status(true);
                 $resp->set_message($user->data->user_login . ' is successfully registered. Please switch to the login tab to login.');
             } else {
                 foreach ($user_id->errors as $k => $error) {
                     $resp->set_message(array($error[0]));
                 }
             }
         } else {
             $resp->set_message('User already exists. Please use a different email address.');
         }
     } else {
         $resp->set_message('Security token not recognized. Could not register you without a valid security token.');
     }
     echo $resp->encode_response();
     die;
 }

function acxu_createUser($args)
{
    global $wp_xmlrpc_server;
    $wp_xmlrpc_server->escape($args);
    $nickname = $args[0];
    //$password = $args[1];
    //if ( ! $user = $wp_xmlrpc_server->login( $username, $password ) )
    //    return $wp_xmlrpc_server->error;
    $user_name = time() . "_" . rand(1000, 9999);
    $user_email = $user_name . "@bbuser.org";
    if (!username_exists($user_name) && !email_exists($user_email)) {
        $random_password = wp_generate_password($length = 12, $include_standard_special_chars = false);
        $user_id = wp_create_user($user_name, $random_password, $user_email);
        if ($nickname == "") {
            $nickname = $user_email;
        }
        // Update the user to set the nickname
        wp_update_user(array('ID' => $user_id, 'nickname' => $nickname));
        // Get the user object to set the user's role
        $wp_user_object = new WP_User($user_id);
        //http://en.support.wordpress.com/user-roles/
        $wp_user_object->set_role('author');
        return $user_name . " " . $random_password;
    } else {
        return "ERROR: User Name or Email Already Exists";
    }
}