ElggUser.php

Go to the documentation of this file.

<?php

use Elgg\Exceptions\InvalidArgumentException as ElggInvalidArgumentException;
use Elgg\Exceptions\InvalidParameterException;
use Elgg\Exceptions\Configuration\RegistrationException;
use Elgg\Traits\Entity\Friends;
use Elgg\Traits\Entity\PluginSettings;
use Elgg\Traits\Entity\ProfileData;

class ElggUser extends \ElggEntity {

    use Friends;
    use PluginSettings {
        setPluginSetting as protected psSetPluginSetting;
        getPluginSetting as protected psGetPluginSetting;
    }
    use ProfileData;
    
    protected function initializeAttributes() {
        parent::initializeAttributes();
        $this->attributes['subtype'] = 'user';
        
        $this->attributes['access_id'] = ACCESS_PUBLIC;
        $this->attributes['owner_guid'] = 0; // Users aren't owned by anyone, even if they are admin created.
        $this->attributes['container_guid'] = 0; // Users aren't contained by anyone, even if they are admin created.
        
        // Before Elgg 3.0 this was handled by database logic
        $this->setMetadata('banned', 'no');
        $this->setMetadata('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_services()->accounts->assertValidEmail($value);
                } catch (RegistrationException $ex) {
                    throw new InvalidParameterException($ex->getMessage(), $ex->getCode(), $ex);
                }
                break;
            case 'username':
                try {
                    _elgg_services()->accounts->assertValidUsername($value);
                } catch (RegistrationException $ex) {
                    throw new InvalidParameterException($ex->getMessage(), $ex->getCode(), $ex);
                }
                $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':
                throw new ElggInvalidArgumentException(_elgg_services()->translator->translate('ElggUser:Error:SetAdmin', ['makeAdmin() / removeAdmin()']));
            case 'banned':
                throw new ElggInvalidArgumentException(_elgg_services()->translator->translate('ElggUser:Error:SetBanned', ['ban() / unban()']));
        }
        
        parent::__set($name, $value);
    }
    
    public function ban($reason = '') {

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

        $this->ban_reason = $reason;
        $this->setMetadata('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->setMetadata('banned', 'no');

        $this->invalidateCache();

        return true;
    }

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

    public function isAdmin() {
        return $this->admin === 'yes';
    }

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

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

        $this->setMetadata('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->setMetadata('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(bool $status, string $method = ''): void {
        if ($status === $this->isValidated()) {
            // no change needed
            return;
        }
        
        $this->validated = $status;
        
        if ($status) {
            $this->validated_method = $method;
            $this->validated_ts = time();
        
            // 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 {
            // invalidating
            unset($this->validated_ts);
            unset($this->validated_method);
            _elgg_services()->events->triggerAfter('invalidate', 'user', $this);
        }
    }

    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->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 setPassword($password) {
        $this->setMetadata('password_hash', _elgg_services()->passwords->generateHash($password));
    }

    public function setNotificationSetting(string $method, bool $enabled = true, string $purpose = 'default') {
        if (empty($purpose)) {
            throw new ElggInvalidArgumentException(__METHOD__ . ' requires $purpose to be set to a non-empty string');
        }
        
        $this->{"notification:{$purpose}:{$method}"} = (int) $enabled;
        return $this->save();
    }

    public function getNotificationSettings(string $purpose = 'default') {
        if (empty($purpose)) {
            throw new ElggInvalidArgumentException(__METHOD__ . ' requires $purpose to be set to a non-empty string');
        }
        
        $settings = [];

        $methods = _elgg_services()->notifications->getMethods();
        foreach ($methods as $method) {
            if ($purpose !== 'default' && !isset($this->{"notification:{$purpose}:{$method}"})) {
                // fallback to the default settings
                $settings[$method] = (bool) $this->{"notification:default:{$method}"};
            } else {
                $settings[$method] = (bool) $this->{"notification:{$purpose}:{$method}"};
            }
        }

        return $settings;
    
    }
    
    public function delete($recursive = true) {
        $result = parent::delete($recursive);
        if ($result) {
            // cleanup remember me cookie records
            _elgg_services()->users_remember_me_cookies_table->deleteAllHashes($this);
        }
        
        return $result;
    }
    
    public function setPluginSetting(string $plugin_id, string $name, $value): bool {
        $value = _elgg_services()->hooks->triggerDeprecated('usersetting', 'plugin', [
            'user' => $this,
            'plugin' => _elgg_services()->plugins->get($plugin_id),
            'plugin_id' => $plugin_id,
            'name' => $name,
            'value' => $value,
        ], $value, "Please user the plugin hook 'plugin_settings', '{$this->getType()}'", '4.0');
        
        return $this->psSetPluginSetting($plugin_id, $name, $value);
    }
    
    public function getPluginSetting(string $plugin_id, string $name, $default = null): string {
        $plugin = _elgg_services()->plugins->get($plugin_id);
        if ($plugin instanceof \ElggPlugin) {
            $static_defaults = (array) $plugin->getStaticConfig('user_settings', []);
            
            $default = elgg_extract($name, $static_defaults, $default);
        }
        
        return $this->psGetPluginSetting($plugin_id, $name, $default);
    }
}