engine/classes/ElggUser.php

Go to the documentation of this file.

<?php
class ElggUser extends ElggEntity
    implements Friendable {

    protected function initializeAttributes() {
        parent::initializeAttributes();

        $this->attributes['type'] = "user";
        $this->attributes['name'] = NULL;
        $this->attributes['username'] = NULL;
        $this->attributes['password'] = NULL;
        $this->attributes['salt'] = NULL;
        $this->attributes['email'] = NULL;
        $this->attributes['language'] = NULL;
        $this->attributes['code'] = NULL;
        $this->attributes['banned'] = "no";
        $this->attributes['admin'] = 'no';
        $this->attributes['prev_last_action'] = NULL;
        $this->attributes['last_login'] = NULL;
        $this->attributes['prev_last_login'] = NULL;
        $this->attributes['tables_split'] = 2;
    }

    function __construct($guid = null) {
        $this->initializeAttributes();

        // compatibility for 1.7 api.
        $this->initialise_attributes(false);

        if (!empty($guid)) {
            // Is $guid is a DB entity row
            if ($guid instanceof stdClass) {
                // Load the rest
                if (!$this->load($guid)) {
                    $msg = elgg_echo('IOException:FailedToLoadGUID', array(get_class(), $guid->guid));
                    throw new IOException($msg);
                }
            } else if (is_string($guid)) {
                // $guid is a username
                $user = get_user_by_username($guid);
                if ($user) {
                    foreach ($user->attributes as $key => $value) {
                        $this->attributes[$key] = $value;
                    }
                }
            } else if ($guid instanceof ElggUser) {
                // $guid is an ElggUser so this is a copy constructor
                elgg_deprecated_notice('This type of usage of the ElggUser constructor was deprecated. Please use the clone method.', 1.7);

                foreach ($guid->attributes as $key => $value) {
                    $this->attributes[$key] = $value;
                }
            } else if ($guid instanceof ElggEntity) {
                // @todo why have a special case here
                throw new InvalidParameterException(elgg_echo('InvalidParameterException:NonElggUser'));
            } else if (is_numeric($guid)) {
                // $guid is a GUID so load entity
                if (!$this->load($guid)) {
                    throw new IOException(elgg_echo('IOException:FailedToLoadGUID', array(get_class(), $guid)));
                }
            } else {
                throw new InvalidParameterException(elgg_echo('InvalidParameterException:UnrecognisedValue'));
            }
        }
    }

    protected function load($guid) {
        $attr_loader = new ElggAttributeLoader(get_class(), 'user', $this->attributes);
        $attr_loader->secondary_loader = 'get_user_entity_as_row';

        $attrs = $attr_loader->getRequiredAttributes($guid);
        if (!$attrs) {
            return false;
        }

        $this->attributes = $attrs;
        $this->attributes['tables_loaded'] = 2;
        _elgg_cache_entity($this);

        return true;
    }

    public function save() {
        // Save generic stuff
        if (!parent::save()) {
            return false;
        }

        // Now save specific stuff
        _elgg_disable_caching_for_entity($this->guid);
        $ret = create_user_entity($this->get('guid'), $this->get('name'), $this->get('username'),
            $this->get('password'), $this->get('salt'), $this->get('email'), $this->get('language'),
            $this->get('code'));
        _elgg_enable_caching_for_entity($this->guid);

        return $ret;
    }

    public function delete() {
        global $USERNAME_TO_GUID_MAP_CACHE, $CODE_TO_GUID_MAP_CACHE;

        // clear cache
        if (isset($USERNAME_TO_GUID_MAP_CACHE[$this->username])) {
            unset($USERNAME_TO_GUID_MAP_CACHE[$this->username]);
        }
        if (isset($CODE_TO_GUID_MAP_CACHE[$this->code])) {
            unset($CODE_TO_GUID_MAP_CACHE[$this->code]);
        }

        clear_user_files($this);

        // Delete entity
        return parent::delete();
    }

    public function ban($reason = "") {
        return ban_user($this->guid, $reason);
    }

    public function unban() {
        return unban_user($this->guid);
    }

    public function isBanned() {
        return $this->banned == 'yes';
    }

    public function isAdmin() {

        // for backward compatibility we need to pull this directly
        // from the attributes instead of using the magic methods.
        // this can be removed in 1.9
        // return $this->admin == 'yes';
        return $this->attributes['admin'] == 'yes';
    }

    public function makeAdmin() {
        // If already saved, use the standard function.
        if ($this->guid && !make_user_admin($this->guid)) {
            return FALSE;
        }

        // need to manually set attributes since they've already been loaded.
        $this->attributes['admin'] = 'yes';

        return TRUE;
    }

    public function removeAdmin() {
        // If already saved, use the standard function.
        if ($this->guid && !remove_user_admin($this->guid)) {
            return FALSE;
        }

        // need to manually set attributes since they've already been loaded.
        $this->attributes['admin'] = 'no';

        return TRUE;
    }

    function getSites($subtype = "", $limit = 10, $offset = 0) {
        return get_user_sites($this->getGUID(), $subtype, $limit, $offset);
    }

    function addToSite($site_guid) {
        return add_site_user($site_guid, $this->getGUID());
    }

    function removeFromSite($site_guid) {
        return remove_site_user($site_guid, $this->getGUID());
    }

    function addFriend($friend_guid) {
        return user_add_friend($this->getGUID(), $friend_guid);
    }

    function removeFriend($friend_guid) {
        return user_remove_friend($this->getGUID(), $friend_guid);
    }

    function isFriend() {
        return $this->isFriendOf(elgg_get_logged_in_user_guid());
    }

    function isFriendsWith($user_guid) {
        return user_is_friend($this->getGUID(), $user_guid);
    }

    function isFriendOf($user_guid) {
        return user_is_friend($user_guid, $this->getGUID());
    }

    function getFriends($subtype = "", $limit = 10, $offset = 0) {
        return get_user_friends($this->getGUID(), $subtype, $limit, $offset);
    }

    function getFriendsOf($subtype = "", $limit = 10, $offset = 0) {
        return get_user_friends_of($this->getGUID(), $subtype, $limit, $offset);
    }

    function listFriends($subtype = "", $limit = 10, array $vars = array()) {
        $defaults = array(
            'type' => 'user',
            'relationship' => 'friend',
            'relationship_guid' => $this->guid,
            'limit' => $limit,
            'full_view' => false,
        );

        $options = array_merge($defaults, $vars);

        if ($subtype) {
            $options['subtype'] = $subtype;
        }

        return elgg_list_entities_from_relationship($options);
    }

    function getGroups($subtype = "", $limit = 10, $offset = 0) {
        $options = array(
            'type' => 'group',
            'relationship' => 'member',
            'relationship_guid' => $this->guid,
            'limit' => $limit,
            'offset' => $offset,
        );

        if ($subtype) {
            $options['subtype'] = $subtype;
        }

        return elgg_get_entities_from_relationship($options);
    }

    function listGroups($subtype = "", $limit = 10, $offset = 0) {
        $options = array(
            'type' => 'group',
            'relationship' => 'member',
            'relationship_guid' => $this->guid,
            'limit' => $limit,
            'offset' => $offset,
            'full_view' => false,
        );

        if ($subtype) {
            $options['subtype'] = $subtype;
        }

        return elgg_list_entities_from_relationship($options);
    }

    public function getObjects($subtype = "", $limit = 10, $offset = 0) {
        $params = array(
            'type' => 'object',
            'subtype' => $subtype,
            'owner_guid' => $this->getGUID(),
            'limit' => $limit,
            'offset' => $offset
        );
        return elgg_get_entities($params);
    }

    public function getFriendsObjects($subtype = "", $limit = 10, $offset = 0) {
        return get_user_friends_objects($this->getGUID(), $subtype, $limit, $offset);
    }

    public function countObjects($subtype = "") {
        return count_user_objects($this->getGUID(), $subtype);
    }

    public function getCollections($subtype = "", $limit = 10, $offset = 0) {
        elgg_deprecated_notice("ElggUser::getCollections() has been deprecated", 1.8);
        return false;
    }

    function getOwnerGUID() {
        if ($this->owner_guid == 0) {
            return $this->guid;
        }

        return $this->owner_guid;
    }

    function getOwner() {
        elgg_deprecated_notice("ElggUser::getOwner deprecated for ElggUser::getOwnerGUID", 1.8);
        $this->getOwnerGUID();
    }

    // EXPORTABLE INTERFACE ////////////////////////////////////////////////////////////

    public function getExportableValues() {
        return array_merge(parent::getExportableValues(), array(
            'name',
            'username',
            'language',
        ));
    }

    public function __set($name, $value) {
        if ($name == 'admin' || $name == 'siteadmin') {
            elgg_deprecated_notice('The admin/siteadmin metadata are not longer used.  Use ElggUser->makeAdmin() and ElggUser->removeAdmin().', 1.7);

            if ($value == 'yes' || $value == '1') {
                $this->makeAdmin();
            } else {
                $this->removeAdmin();
            }
        }
        return parent::__set($name, $value);
    }

    public function __get($name) {
        if ($name == 'admin' || $name == 'siteadmin') {
            elgg_deprecated_notice('The admin/siteadmin metadata are not longer used.  Use ElggUser->isAdmin().', 1.7);
            return $this->isAdmin();
        }

        return parent::__get($name);
    }

    public function canComment($user_guid = 0) {
        $result = parent::canComment($user_guid);
        if ($result !== null) {
            return $result;
        }
        return false;
    }
}

---