users.php

Go to the documentation of this file.

<?php
 
global $USERNAME_TO_GUID_MAP_CACHE;
$USERNAME_TO_GUID_MAP_CACHE = array();
 
function get_user_entity_as_row($guid) {
    global $CONFIG;
 
    $guid = (int)$guid;
    return get_data_row("SELECT * from {$CONFIG->dbprefix}users_entity where guid=$guid");
}
 
function disable_user_entities($owner_guid) {
    global $CONFIG;
    $owner_guid = (int) $owner_guid;
    if ($entity = get_entity($owner_guid)) {
        if (elgg_trigger_event('disable', $entity->type, $entity)) {
            if ($entity->canEdit()) {
                $query = "UPDATE {$CONFIG->dbprefix}entities
                    set enabled='no' where owner_guid={$owner_guid}
                    or container_guid = {$owner_guid}";
 
                $res = update_data($query);
                return $res;
            }
        }
    }
 
    return false;
}
 
function ban_user($user_guid, $reason = "") {
    global $CONFIG;
 
    $user_guid = (int)$user_guid;
 
    $user = get_entity($user_guid);
 
    if (($user) && ($user->canEdit()) && ($user instanceof ElggUser)) {
        if (elgg_trigger_event('ban', 'user', $user)) {
            // Add reason
            if ($reason) {
                create_metadata($user_guid, 'ban_reason', $reason, '', 0, ACCESS_PUBLIC);
            }
 
            // invalidate memcache for this user
            static $newentity_cache;
            if ((!$newentity_cache) && (is_memcache_available())) {
                $newentity_cache = new ElggMemcache('new_entity_cache');
            }
 
            if ($newentity_cache) {
                $newentity_cache->delete($user_guid);
            }
 
            // Set ban flag
            $query = "UPDATE {$CONFIG->dbprefix}users_entity set banned='yes' where guid=$user_guid";
            return update_data($query);
        }
 
        return false;
    }
 
    return false;
}
 
function unban_user($user_guid) {
    global $CONFIG;
 
    $user_guid = (int)$user_guid;
 
    $user = get_entity($user_guid);
 
    if (($user) && ($user->canEdit()) && ($user instanceof ElggUser)) {
        if (elgg_trigger_event('unban', 'user', $user)) {
            create_metadata($user_guid, 'ban_reason', '', '', 0, ACCESS_PUBLIC);
 
            // invalidate memcache for this user
            static $newentity_cache;
            if ((!$newentity_cache) && (is_memcache_available())) {
                $newentity_cache = new ElggMemcache('new_entity_cache');
            }
 
            if ($newentity_cache) {
                $newentity_cache->delete($user_guid);
            }
 
 
            $query = "UPDATE {$CONFIG->dbprefix}users_entity set banned='no' where guid=$user_guid";
            return update_data($query);
        }
 
        return false;
    }
 
    return false;
}
 
function make_user_admin($user_guid) {
    global $CONFIG;
 
    $user = get_entity((int)$user_guid);
 
    if (($user) && ($user instanceof ElggUser) && ($user->canEdit())) {
        if (elgg_trigger_event('make_admin', 'user', $user)) {
 
            // invalidate memcache for this user
            static $newentity_cache;
            if ((!$newentity_cache) && (is_memcache_available())) {
                $newentity_cache = new ElggMemcache('new_entity_cache');
            }
 
            if ($newentity_cache) {
                $newentity_cache->delete($user_guid);
            }
 
            $r = update_data("UPDATE {$CONFIG->dbprefix}users_entity set admin='yes' where guid=$user_guid");
            _elgg_invalidate_cache_for_entity($user_guid);
            return $r;
        }
 
        return false;
    }
 
    return false;
}
 
function remove_user_admin($user_guid) {
    global $CONFIG;
 
    $user = get_entity((int)$user_guid);
 
    if (($user) && ($user instanceof ElggUser) && ($user->canEdit())) {
        if (elgg_trigger_event('remove_admin', 'user', $user)) {
 
            // invalidate memcache for this user
            static $newentity_cache;
            if ((!$newentity_cache) && (is_memcache_available())) {
                $newentity_cache = new ElggMemcache('new_entity_cache');
            }
 
            if ($newentity_cache) {
                $newentity_cache->delete($user_guid);
            }
 
            $r = update_data("UPDATE {$CONFIG->dbprefix}users_entity set admin='no' where guid=$user_guid");
            _elgg_invalidate_cache_for_entity($user_guid);
            return $r;
        }
 
        return false;
    }
 
    return false;
}
 
function get_user($guid) {
    // Fixes "Exception thrown without stack frame" when db_select fails
    if (!empty($guid)) {
        $result = get_entity($guid);
    }
 
    if ((!empty($result)) && (!($result instanceof ElggUser))) {
        return false;
    }
 
    if (!empty($result)) {
        return $result;
    }
 
    return false;
}
 
function get_user_by_username($username) {
    global $CONFIG, $USERNAME_TO_GUID_MAP_CACHE;
 
    // Fixes #6052. Username is frequently sniffed from the path info, which,
    // unlike $_GET, is not URL decoded. If the username was not URL encoded,
    // this is harmless.
    $username = rawurldecode($username);
 
    $username = sanitise_string($username);
    $access = _elgg_get_access_where_sql();
 
    // Caching
    if ((isset($USERNAME_TO_GUID_MAP_CACHE[$username]))
            && (_elgg_retrieve_cached_entity($USERNAME_TO_GUID_MAP_CACHE[$username]))) {
        return _elgg_retrieve_cached_entity($USERNAME_TO_GUID_MAP_CACHE[$username]);
    }
 
    $query = "SELECT e.* FROM {$CONFIG->dbprefix}users_entity u
        JOIN {$CONFIG->dbprefix}entities e ON e.guid = u.guid
        WHERE u.username = '$username' AND $access";
 
    $entity = get_data_row($query, 'entity_row_to_elggstar');
    if ($entity) {
        $USERNAME_TO_GUID_MAP_CACHE[$username] = $entity->guid;
    } else {
        $entity = false;
    }
 
    return $entity;
}
 
function get_user_by_code($hash) {
    _elgg_services()->persistentLogin->getUserFromHash($hash);
}
 
function get_user_by_email($email) {
    global $CONFIG;
 
    $email = sanitise_string($email);
 
    $access = _elgg_get_access_where_sql();
 
    $query = "SELECT e.* FROM {$CONFIG->dbprefix}entities e
        JOIN {$CONFIG->dbprefix}users_entity u ON e.guid = u.guid
        WHERE email = '$email' AND $access";
 
    return get_data($query, 'entity_row_to_elggstar');
}
 
function find_active_users($options = array(), $limit = 10, $offset = 0, $count = false) {
 
    $seconds = 600; //default value
 
    if (!is_array($options)) {
        elgg_deprecated_notice("find_active_users() now accepts an \$options array", 1.9);
        if (!$options) {
            $options = $seconds; //assign default value
        }
        $options = array('seconds' => $options);
    }
 
    $options = array_merge(array(
        'seconds' => $seconds,
        'limit' => $limit,
        'offset' => $offset,
        'count' => $count,
    ), $options);
 
    // cast options we're sending to hook
    foreach (array('seconds', 'limit', 'offset') as $key) {
        $options[$key] = (int)$options[$key];
    }
    $options['count'] = (bool)$options['count'];
 
    // allow plugins to override
    $params = array(
        'seconds' => $options['seconds'],
        'limit' => $options['limit'],
        'offset' => $options['offset'],
        'count' => $options['count'],
        'options' => $options,
    );
    $data = elgg_trigger_plugin_hook('find_active_users', 'system', $params, null);
    // check null because the handler could legitimately return falsey values.
    if ($data !== null) {
        return $data;
    }
 
    $dbprefix = elgg_get_config('dbprefix');
    $time = time() - $options['seconds'];
    return elgg_get_entities(array(
        'type' => 'user',
        'limit' => $options['limit'],
        'offset' => $options['offset'],
        'count' => $options['count'],
        'joins' => array("join {$dbprefix}users_entity u on e.guid = u.guid"),
        'wheres' => array("u.last_action >= {$time}"),
        'order_by' => "u.last_action desc",
    ));
}
 
function send_new_password_request($user_guid) {
    $user_guid = (int)$user_guid;
 
    $user = get_entity($user_guid);
    if ($user instanceof ElggUser) {
        // generate code
        $code = generate_random_cleartext_password();
        $user->setPrivateSetting('passwd_conf_code', $code);
        $user->setPrivateSetting('passwd_conf_time', time());
 
        // email subject
        $subject = elgg_echo('email:changereq:subject', array(), $user->language);
 
        // link for changing the password
        $link = elgg_get_site_url() . "changepassword?u=$user_guid&c=$code";
 
        // IP address of the current user
        $ip_address = _elgg_services()->request->getClientIp();
 
        // email message body
        $email = elgg_echo('email:changereq:body', array(
            $user->name,
            $ip_address,
            $link
        ), $user->language);
 
        return notify_user($user->guid, elgg_get_site_entity()->guid,
            $subject, $email, array(), 'email');
    }
 
    return false;
}
 
function force_user_password_reset($user_guid, $password) {
    $user = get_entity($user_guid);
    if ($user instanceof ElggUser) {
        $ia = elgg_set_ignore_access();
 
        $user->salt = _elgg_generate_password_salt();
        $hash = generate_user_password($user, $password);
        $user->password = $hash;
        $result = (bool)$user->save();
 
        elgg_set_ignore_access($ia);
 
        return $result;
    }
 
    return false;
}
 
function execute_new_password_request($user_guid, $conf_code, $password = null) {
 
    $user_guid = (int)$user_guid;
    $user = get_entity($user_guid);
 
    if ($password === null) {
        $password = generate_random_cleartext_password();
        $reset = true;
    }
 
    if (!elgg_instanceof($user, 'user')) {
        return false;
    }
 
    $saved_code = $user->getPrivateSetting('passwd_conf_code');
    $code_time = (int) $user->getPrivateSetting('passwd_conf_time');
 
    if (!$saved_code || $saved_code != $conf_code) {
        return false;
    }
 
    // Discard for security if it is 24h old
    if (!$code_time || $code_time < time() - 24 * 60 * 60) {
        return false;
    }
 
    if (force_user_password_reset($user_guid, $password)) {
        remove_private_setting($user_guid, 'passwd_conf_code');
        remove_private_setting($user_guid, 'passwd_conf_time');
        // clean the logins failures
        reset_login_failure_count($user_guid);
 
        $ns = $reset ? 'resetpassword' : 'changepassword';
 
        notify_user($user->guid,
            elgg_get_site_entity()->guid,
            elgg_echo("email:$ns:subject", array(), $user->language),
            elgg_echo("email:$ns:body", array($user->username, $password), $user->language),
            array(),
            'email'
        );
 
        return true;
    }
 
    return false;
}
 
function generate_random_cleartext_password() {
    return _elgg_services()->crypto->getRandomString(12, ElggCrypto::CHARS_PASSWORD);
}
 
function _elgg_generate_password_salt() {
    return _elgg_services()->crypto->getRandomString(8);
}
 
function generate_user_password(ElggUser $user, $password) {
    return md5($password . $user->salt);
}
 
function validate_username($username) {
    global $CONFIG;
 
    // Basic, check length
    if (!isset($CONFIG->minusername)) {
        $CONFIG->minusername = 4;
    }
 
    if (strlen($username) < $CONFIG->minusername) {
        $msg = elgg_echo('registration:usernametooshort', array($CONFIG->minusername));
        throw new RegistrationException($msg);
    }
 
    // username in the database has a limit of 128 characters
    if (strlen($username) > 128) {
        $msg = elgg_echo('registration:usernametoolong', array(128));
        throw new RegistrationException($msg);
    }
 
    // Blacklist for bad characters (partially nicked from mediawiki)
    $blacklist = '/[' .
        '\x{0080}-\x{009f}' . // iso-8859-1 control chars
        '\x{00a0}' .          // non-breaking space
        '\x{2000}-\x{200f}' . // various whitespace
        '\x{2028}-\x{202f}' . // breaks and control chars
        '\x{3000}' .          // ideographic space
        '\x{e000}-\x{f8ff}' . // private use
        ']/u';
 
    if (preg_match($blacklist, $username)) {
        // @todo error message needs work
        throw new RegistrationException(elgg_echo('registration:invalidchars'));
    }
 
    // Belts and braces
    // @todo Tidy into main unicode
    $blacklist2 = '\'/\\"*& ?#%^(){}[]~?<>;|¬`@-+=';
 
    for ($n = 0; $n < strlen($blacklist2); $n++) {
        if (strpos($username, $blacklist2[$n]) !== false) {
            $msg = elgg_echo('registration:invalidchars', array($blacklist2[$n], $blacklist2));
            $msg = htmlspecialchars($msg, ENT_QUOTES, 'UTF-8');
            throw new RegistrationException($msg);
        }
    }
 
    $result = true;
    return elgg_trigger_plugin_hook('registeruser:validate:username', 'all',
        array('username' => $username), $result);
}
 
function validate_password($password) {
    global $CONFIG;
 
    if (!isset($CONFIG->min_password_length)) {
        $CONFIG->min_password_length = 6;
    }
 
    if (strlen($password) < $CONFIG->min_password_length) {
        $msg = elgg_echo('registration:passwordtooshort', array($CONFIG->min_password_length));
        throw new RegistrationException($msg);
    }
 
    $result = true;
    return elgg_trigger_plugin_hook('registeruser:validate:password', 'all',
        array('password' => $password), $result);
}
 
function validate_email_address($address) {
    if (!is_email_address($address)) {
        throw new RegistrationException(elgg_echo('registration:notemail'));
    }
 
    // Got here, so lets try a hook (defaulting to ok)
    $result = true;
    return elgg_trigger_plugin_hook('registeruser:validate:email', 'all',
        array('email' => $address), $result);
}
 
function register_user($username, $password, $name, $email, $allow_multiple_emails = false) {
 
    // no need to trim password.
    $username = trim($username);
    $name = trim(strip_tags($name));
    $email = trim($email);
 
    // A little sanity checking
    if (empty($username)
            || empty($password)
            || empty($name)
            || empty($email)) {
        return false;
    }
 
    // Make sure a user with conflicting details hasn't registered and been disabled
    $access_status = access_get_show_hidden_status();
    access_show_hidden_entities(true);
 
    if (!validate_email_address($email)) {
        throw new RegistrationException(elgg_echo('registration:emailnotvalid'));
    }
 
    if (!validate_password($password)) {
        throw new RegistrationException(elgg_echo('registration:passwordnotvalid'));
    }
 
    if (!validate_username($username)) {
        throw new RegistrationException(elgg_echo('registration:usernamenotvalid'));
    }
 
    if ($user = get_user_by_username($username)) {
        throw new RegistrationException(elgg_echo('registration:userexists'));
    }
 
    if ((!$allow_multiple_emails) && (get_user_by_email($email))) {
        throw new RegistrationException(elgg_echo('registration:dupeemail'));
    }
 
    access_show_hidden_entities($access_status);
 
    // Create user
    $user = new ElggUser();
    $user->username = $username;
    $user->email = $email;
    $user->name = $name;
    $user->access_id = ACCESS_PUBLIC;
    $user->salt = _elgg_generate_password_salt();
    $user->password = generate_user_password($user, $password);
    $user->owner_guid = 0; // Users aren't owned by anyone, even if they are admin created.
    $user->container_guid = 0; // Users aren't contained by anyone, even if they are admin created.
    $user->language = get_current_language();
    if ($user->save() === false) {
        return false;
    }
 
    // Turn on email notifications by default
    set_user_notification_setting($user->getGUID(), 'email', true);
 
    return $user->getGUID();
}
 
function generate_invite_code($username) {
    $secret = datalist_get('__site_secret__');
    return md5($username . $secret);
}
 
function elgg_set_user_validation_status($user_guid, $status, $method = '') {
    $result1 = create_metadata($user_guid, 'validated', $status, '', 0, ACCESS_PUBLIC, false);
    $result2 = create_metadata($user_guid, 'validated_method', $method, '', 0, ACCESS_PUBLIC, false);
    if ($result1 && $result2) {
        return true;
    } else {
        return false;
    }
}
 
function elgg_get_user_validation_status($user_guid) {
    $md = elgg_get_metadata(array(
        'guid' => $user_guid,
        'metadata_name' => 'validated'
    ));
    if ($md == false) {
        return null;
    }
 
    if ($md[0]->value) {
        return true;
    }
 
    return false;
}
 
function elgg_user_account_page_handler($page_elements, $handler) {
 
    $base_dir = elgg_get_root_path() . 'pages/account';
    switch ($handler) {
        case 'login':
            require_once("$base_dir/login.php");
            break;
        case 'forgotpassword':
            require_once("$base_dir/forgotten_password.php");
            break;
        case 'changepassword':
            require_once("$base_dir/change_password.php");
            break;
        case 'register':
            require_once("$base_dir/register.php");
            break;
        default:
            return false;
    }
    return true;
}
 
function set_last_action($user_guid) {
    $user_guid = (int) $user_guid;
    global $CONFIG;
    $time = time();
 
    $query = "UPDATE {$CONFIG->dbprefix}users_entity
        set prev_last_action = last_action,
        last_action = {$time} where guid = {$user_guid}";
 
    execute_delayed_write_query($query);
}
 
function set_last_login($user_guid) {
    $user_guid = (int) $user_guid;
    global $CONFIG;
    $time = time();
 
    $query = "UPDATE {$CONFIG->dbprefix}users_entity
        set prev_last_login = last_login, last_login = {$time} where guid = {$user_guid}";
 
    execute_delayed_write_query($query);
}
 
function user_create_hook_add_site_relationship($event, $object_type, $object) {
    add_entity_relationship($object->getGUID(), 'member_of_site', elgg_get_site_entity()->guid);
}
 
function user_avatar_hook($hook, $entity_type, $returnvalue, $params) {
    $user = $params['entity'];
    $size = $params['size'];
 
    if (isset($user->icontime)) {
        return "avatar/view/$user->username/$size/$user->icontime";
    } else {
        return "_graphics/icons/user/default{$size}.gif";
    }
}
 
function elgg_user_hover_menu($hook, $type, $return, $params) {
    $user = $params['entity'];
    /* @var ElggUser $user */
 
    if (elgg_is_logged_in()) {
        if (elgg_get_logged_in_user_guid() == $user->guid) {
            $url = "profile/$user->username/edit";
            $item = new ElggMenuItem('profile:edit', elgg_echo('profile:edit'), $url);
            $item->setSection('action');
            $return[] = $item;
 
            $url = "avatar/edit/$user->username";
            $item = new ElggMenuItem('avatar:edit', elgg_echo('avatar:edit'), $url);
            $item->setSection('action');
            $return[] = $item;
        }
    }
 
    // prevent admins from banning or deleting themselves
    if (elgg_get_logged_in_user_guid() == $user->guid) {
        return $return;
    }
 
    if (elgg_is_admin_logged_in()) {
        $actions = array();
        if (!$user->isBanned()) {
            $actions[] = 'ban';
        } else {
            $actions[] = 'unban';
        }
        $actions[] = 'delete';
        $actions[] = 'resetpassword';
        if (!$user->isAdmin()) {
            $actions[] = 'makeadmin';
        } else {
            $actions[] = 'removeadmin';
        }
 
        foreach ($actions as $action) {
            $url = "action/admin/user/$action?guid={$user->guid}";
            $url = elgg_add_action_tokens_to_url($url);
            $item = new ElggMenuItem($action, elgg_echo($action), $url);
            $item->setSection('admin');
            $item->setLinkClass('elgg-requires-confirmation');
 
            $return[] = $item;
        }
 
        $url = "profile/$user->username/edit";
        $item = new ElggMenuItem('profile:edit', elgg_echo('profile:edit'), $url);
        $item->setSection('admin');
        $return[] = $item;
 
        $url = "settings/user/$user->username";
        $item = new ElggMenuItem('settings:edit', elgg_echo('settings:edit'), $url);
        $item->setSection('admin');
        $return[] = $item;
 
        $url = "activity/owner/$user->username";
        $item = new ElggMenuItem('activity:owner', elgg_echo('activity:owner'), $url);
        $item->setSection('action');
        $return[] = $item;
    }
 
    return $return;
}
 
function elgg_users_setup_entity_menu($hook, $type, $return, $params) {
    if (elgg_in_context('widgets')) {
        return $return;
    }
 
    $entity = $params['entity'];
    if (!elgg_instanceof($entity, 'user')) {
        return $return;
    }
    /* @var ElggUser $entity */
 
    if ($entity->isBanned()) {
        $banned = elgg_echo('banned');
        $options = array(
            'name' => 'banned',
            'text' => "<span>$banned</span>",
            'href' => false,
            'priority' => 0,
        );
        $return = array(ElggMenuItem::factory($options));
    } else {
        $return = array();
        if (isset($entity->location)) {
            $location = htmlspecialchars($entity->location, ENT_QUOTES, 'UTF-8', false);
            $options = array(
                'name' => 'location',
                'text' => "<span>$location</span>",
                'href' => false,
                'priority' => 150,
            );
            $return[] = ElggMenuItem::factory($options);
        }
    }
 
    return $return;
}
 
function elgg_profile_fields_setup() {
    global $CONFIG;
 
    $profile_defaults = array (
        'description' => 'longtext',
        'briefdescription' => 'text',
        'location' => 'location',
        'interests' => 'tags',
        'skills' => 'tags',
        'contactemail' => 'email',
        'phone' => 'text',
        'mobile' => 'text',
        'website' => 'url',
        'twitter' => 'text',
    );
 
    $loaded_defaults = array();
    $fieldlist = elgg_get_config('profile_custom_fields');
    if ($fieldlist || $fieldlist === '0') {
        $fieldlistarray = explode(',', $fieldlist);
        foreach ($fieldlistarray as $listitem) {
            if ($translation = elgg_get_config("admin_defined_profile_{$listitem}")) {
                $type = elgg_get_config("admin_defined_profile_type_{$listitem}");
                $loaded_defaults["admin_defined_profile_{$listitem}"] = $type;
                add_translation(get_current_language(), array("profile:admin_defined_profile_{$listitem}" => $translation));
            }
        }
    }
 
    if (count($loaded_defaults)) {
        $CONFIG->profile_using_custom = true;
        $profile_defaults = $loaded_defaults;
    }
 
    $CONFIG->profile_fields = elgg_trigger_plugin_hook('profile:fields', 'profile', null, $profile_defaults);
 
    // register any tag metadata names
    foreach ($CONFIG->profile_fields as $name => $type) {
        if ($type == 'tags' || $type == 'location' || $type == 'tag') {
            elgg_register_tag_metadata_name($name);
            // register a tag name translation
            add_translation(get_current_language(), array("tag_names:$name" => elgg_echo("profile:$name")));
        }
    }
}
 
function elgg_avatar_page_handler($page) {
    global $CONFIG;
 
    $user = get_user_by_username($page[1]);
    if ($user) {
        elgg_set_page_owner_guid($user->getGUID());
    }
 
    if ($page[0] == 'edit') {
        require_once("{$CONFIG->path}pages/avatar/edit.php");
        return true;
    } else {
        set_input('size', $page[2]);
        require_once("{$CONFIG->path}pages/avatar/view.php");
        return true;
    }
    return false;
}
 
function elgg_profile_page_handler($page) {
    global $CONFIG;
 
    $user = get_user_by_username($page[0]);
    elgg_set_page_owner_guid($user->guid);
 
    if ($page[1] == 'edit') {
        require_once("{$CONFIG->path}pages/profile/edit.php");
        return true;
    }
    return false;
}
 
function users_pagesetup() {
 
    $owner = elgg_get_page_owner_entity();
    $viewer = elgg_get_logged_in_user_entity();
 
    if ($owner) {
        elgg_register_menu_item('page', array(
            'name' => 'edit_avatar',
            'href' => "avatar/edit/{$owner->username}",
            'text' => elgg_echo('avatar:edit'),
            'section' => '1_profile',
            'contexts' => array('settings'),
        ));
 
        elgg_register_menu_item('page', array(
            'name' => 'edit_profile',
            'href' => "profile/{$owner->username}/edit",
            'text' => elgg_echo('profile:edit'),
            'section' => '1_profile',
            'contexts' => array('settings'),
        ));
    }
 
    // topbar
    if ($viewer) {
        elgg_register_menu_item('topbar', array(
            'name' => 'profile',
            'href' => $viewer->getURL(),
            'text' => elgg_view('output/img', array(
                'src' => $viewer->getIconURL('topbar'),
                'alt' => $viewer->name,
                'title' => elgg_echo('profile'),
                'class' => 'elgg-border-plain elgg-transition',
            )),
            'priority' => 100,
            'link_class' => 'elgg-topbar-avatar',
        ));
 
        elgg_register_menu_item('topbar', array(
            'name' => 'usersettings',
            'href' => "settings/user/{$viewer->username}",
            'text' => elgg_view_icon('settings') . elgg_echo('settings'),
            'priority' => 500,
            'section' => 'alt',
        ));
 
        elgg_register_menu_item('topbar', array(
            'name' => 'logout',
            'href' => "action/logout",
            'text' => elgg_echo('logout'),
            'is_action' => true,
            'priority' => 1000,
            'section' => 'alt',
        ));
    }
}
 
function users_init() {
 
    elgg_register_page_handler('register', 'elgg_user_account_page_handler');
    elgg_register_page_handler('forgotpassword', 'elgg_user_account_page_handler');
    elgg_register_page_handler('changepassword', 'elgg_user_account_page_handler');
    elgg_register_page_handler('login', 'elgg_user_account_page_handler');
    elgg_register_page_handler('avatar', 'elgg_avatar_page_handler');
    elgg_register_page_handler('profile', 'elgg_profile_page_handler');
 
    elgg_register_plugin_hook_handler('register', 'menu:user_hover', 'elgg_user_hover_menu');
 
    elgg_register_action('register', '', 'public');
    elgg_register_action('useradd', '', 'admin');
    elgg_register_action('avatar/upload');
    elgg_register_action('avatar/crop');
    elgg_register_action('avatar/remove');
    elgg_register_action('profile/edit');
 
    elgg_register_plugin_hook_handler('entity:icon:url', 'user', 'user_avatar_hook');
 
    elgg_register_action('user/changepassword', '', 'public');
    elgg_register_action('user/requestnewpassword', '', 'public');
 
    // Register the user type
    elgg_register_entity_type('user', '');
 
    elgg_register_plugin_hook_handler('register', 'menu:entity', 'elgg_users_setup_entity_menu', 501);
 
    elgg_register_event_handler('create', 'user', 'user_create_hook_add_site_relationship');
}
 
function users_test($hook, $type, $value, $params) {
    global $CONFIG;
    $value[] = "{$CONFIG->path}engine/tests/ElggUserTest.php";
    return $value;
}
 
elgg_register_event_handler('init', 'system', 'users_init', 0);
elgg_register_event_handler('init', 'system', 'elgg_profile_fields_setup', 10000); // Ensure this runs after other plugins
elgg_register_event_handler('pagesetup', 'system', 'users_pagesetup', 0);
elgg_register_plugin_hook_handler('unit_test', 'system', 'users_test');