ElggUser.php

Go to the documentation of this file.

<?php

class ElggUser extends \ElggEntity
    implements Friendable {

    protected function initializeAttributes() {
        parent::initializeAttributes();
        $this->attributes['subtype'] = 'user';
        
        // Before Elgg 3.0 this was handled by database logic
        $this->banned = 'no';
        $this->admin = 'no';
        $this->language = elgg_get_config('language');
        $this->prev_last_action = 0;
        $this->last_login = 0;
        $this->prev_last_login = 0;
    }

    public function getType() {
        return 'user';
    }
    
    public function getLanguage($fallback = null) {
        if (!empty($this->language)) {
            return $this->language;
        }
        if ($fallback !== null) {
            return $fallback;
        }
        return elgg_get_config('language');
    }

    public function __set($name, $value) {
        switch ($name) {
            case 'salt':
            case 'password':
                _elgg_services()->logger->error("User entities no longer contain {$name}");
                return;
            case 'password_hash':
                _elgg_services()->logger->error("password_hash is a readonly attribute.");
                return;
            case 'email':
                try {
                    elgg()->accounts->assertValidEmail($value);
                } catch (RegistrationException $ex) {
                    throw new InvalidParameterException($ex->getCode());
                }
                break;
            case 'username':
                try {
                    elgg()->accounts->assertValidUsername($value);
                } catch (RegistrationException $ex) {
                    throw new InvalidParameterException($ex->getCode());
                }
                $existing_user = get_user_by_username($value);
                if ($existing_user && ($existing_user->guid !== $this->guid)) {
                    throw new InvalidParameterException("{$name} is supposed to be unique for ElggUser");
                }
                break;
            case 'admin':
            case 'banned':
                if (!in_array($value, ['yes', 'no'], true)) {
                    throw new InvalidArgumentException("{$name} only supports 'yes' or 'no' value");
                }
                break;
        }
        
        parent::__set($name, $value);
    }
    
    public function getURL() {
        
        $result = parent::getURL();
        if ($result !== '') {
            return $result;
        }
        
        return elgg_normalize_url("user/view/{$this->guid}");
    }

    public function ban($reason = '') {

        if (!$this->canEdit()) {
            return false;
        }
        
        if (!_elgg_services()->events->trigger('ban', 'user', $this)) {
            return false;
        }

        $this->ban_reason = $reason;
        $this->banned = 'yes';
                
        $this->invalidateCache();

        return true;
    }

    public function unban() {
        
        if (!$this->canEdit()) {
            return false;
        }

        if (!_elgg_services()->events->trigger('unban', 'user', $this)) {
            return false;
        }

        unset($this->ban_reason);
        $this->banned = 'no';
                
        $this->invalidateCache();

        return true;
    }

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

    public function isAdmin() {
        $ia = _elgg_services()->session->setIgnoreAccess(true);
        $is_admin = ($this->admin == 'yes');
        _elgg_services()->session->setIgnoreAccess($ia);
        
        return $is_admin;
    }

    public function makeAdmin() {
        
        if ($this->isAdmin()) {
            return true;
        }

        if (!_elgg_services()->events->trigger('make_admin', 'user', $this)) {
            return false;
        }

        $this->admin = 'yes';

        $this->invalidateCache();
        
        return true;
    }

    public function removeAdmin() {

        if (!$this->isAdmin()) {
            return true;
        }

        if (!_elgg_services()->events->trigger('remove_admin', 'user', $this)) {
            return false;
        }

        $this->admin = 'no';

        $this->invalidateCache();
        
        return true;
    }
    
    public function setLastLogin() {
        
        $time = $this->getCurrentTime()->getTimestamp();
        
        if ($this->last_login == $time) {
            // no change required
            return;
        }
        
        // these writes actually work, we just type hint read-only.
        $this->prev_last_login = $this->last_login;
        $this->last_login = $time;
    }
    
    public function setLastAction() {
        
        $time = $this->getCurrentTime()->getTimestamp();
        
        if ($this->last_action == $time) {
            // no change required
            return;
        }
        
        $user = $this;
        
        elgg_register_event_handler('shutdown', 'system', function () use ($user, $time) {
            // these writes actually work, we just type hint read-only.
            $user->prev_last_action = $user->last_action;
        
            $user->updateLastAction($time);
        });
    }
    
    public function isValidated() {
        if (!isset($this->validated)) {
            return null;
        }
        return (bool) $this->validated;
    }
    
    public function setValidationStatus($status, $method = '') {
        
        $this->validated = $status;
        $this->validated_method = $method;
        
        if ((bool) $status) {
            // make sure the user is enabled
            if (!$this->isEnabled()) {
                $this->enable();
            }
            
            // let the system know the user is validated
            _elgg_services()->events->triggerAfter('validate', 'user', $this);
        } else {
            _elgg_services()->events->triggerAfter('invalidate', 'user', $this);
        }
    }

    public function addFriend($friend_guid, $create_river_item = false) {
        if (!get_user($friend_guid)) {
            return false;
        }

        if (!add_entity_relationship($this->guid, "friend", $friend_guid)) {
            return false;
        }

        if ($create_river_item) {
            elgg_create_river_item([
                'view' => 'river/relationship/friend/create',
                'action_type' => 'friend',
                'subject_guid' => $this->guid,
                'object_guid' => $friend_guid,
            ]);
        }

        return true;
    }

    public function removeFriend($friend_guid) {
        return $this->removeRelationship($friend_guid, 'friend');
    }

    public function isFriend() {
        return $this->isFriendOf(_elgg_services()->session->getLoggedInUserGuid());
    }

    public function isFriendsWith($user_guid) {
        return (bool) check_entity_relationship($this->guid, "friend", $user_guid);
    }

    public function isFriendOf($user_guid) {
        return (bool) check_entity_relationship($user_guid, "friend", $this->guid);
    }

    public function getFriends(array $options = []) {
        $options['relationship'] = 'friend';
        $options['relationship_guid'] = $this->getGUID();
        $options['type'] = 'user';

        return elgg_get_entities($options);
    }

    public function getFriendsOf(array $options = []) {
        $options['relationship'] = 'friend';
        $options['relationship_guid'] = $this->getGUID();
        $options['inverse_relationship'] = true;
        $options['type'] = 'user';

        return elgg_get_entities($options);
    }

    public function getGroups(array $options = []) {
        $options['type'] = 'group';
        $options['relationship'] = 'member';
        $options['relationship_guid'] = $this->guid;

        return elgg_get_entities($options);
    }

    public function getObjects(array $options = []) {
        $options['type'] = 'object';
        $options['owner_guid'] = $this->getGUID();

        return elgg_get_entities($options);
    }

    public function getFriendsObjects(array $options = []) {
        $options['type'] = 'object';
        $options['relationship'] = 'friend';
        $options['relationship_guid'] = $this->getGUID();
        $options['relationship_join_on'] = 'container_guid';

        return elgg_get_entities($options);
    }

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

        return $this->owner_guid;
    }

    protected function prepareObject(\Elgg\Export\Entity $object) {
        $object = parent::prepareObject($object);
        $object->name = $this->getDisplayName();
        $object->username = $this->username;
        $object->language = $this->language;
        unset($object->read_access);
        return $object;
    }

    public function canComment($user_guid = 0, $default = null) {
        return false;
    }

    public function setPassword($password) {
        $this->setMetadata('password_hash', _elgg_services()->passwords->generateHash($password));
    }

    public function setNotificationSetting($method, $enabled = true) {
        $this->{"notification:method:$method"} = (int) $enabled;
        return (bool) $this->save();
    }

    public function getNotificationSettings() {

        $settings = [];

        $methods = _elgg_services()->notifications->getMethods();
        foreach ($methods as $method) {
            $settings[$method] = (bool) $this->{"notification:method:$method"};
        }

        return $settings;
    
    }

    public function cache($persist = true) {
        if ($persist && $this->username) {
            $tmp = $this->volatile;

            // don't store volatile data
            $this->volatile = [];

            _elgg_services()->dataCache->usernames->save($this->username, $this);

            $this->volatile = $tmp;
        }

        parent::cache($persist);
    }

    public function invalidateCache() {
        if ($this->username) {
            _elgg_services()->dataCache->usernames->delete($this->username);
        }

        parent::invalidateCache();
    }
    
    public function delete($recursive = true) {
        $result = parent::delete($recursive);
        if ($result) {
            // cleanup remember me cookie records
            _elgg_services()->persistentLogin->removeAllHashes($this);
        }
        
        return $result;
    }
}