ElggUser.php

Go to the documentation of this file.

<?php
 
use Elgg\Exceptions\InvalidArgumentException as ElggInvalidArgumentException;
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 {
        getPluginSetting as protected psGetPluginSetting;
    }
    use ProfileData;
    
    protected function initializeAttributes() {
        parent::initializeAttributes();
        
        $this->attributes['type'] = 'user';
        $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 getLanguage(?string $fallback = null): string {
        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 ElggInvalidArgumentException($ex->getMessage(), $ex->getCode(), $ex);
                }
                break;
            case 'username':
                try {
                    _elgg_services()->accounts->assertValidUsername($value);
                } catch (RegistrationException $ex) {
                    throw new ElggInvalidArgumentException($ex->getMessage(), $ex->getCode(), $ex);
                }
                
                $existing_user = elgg_get_user_by_username($value);
                if ($existing_user instanceof \ElggUser && ($existing_user->guid !== $this->guid)) {
                    throw new ElggInvalidArgumentException("{$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(string $reason = ''): bool {
        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(): bool {
        
        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(): bool {
        return $this->banned === 'yes';
    }
 
    public function isAdmin(): bool {
        return $this->admin === 'yes';
    }
 
    public function makeAdmin(): bool {
        
        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(): bool {
 
        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(): void {
        $time = $this->getCurrentTime()->getTimestamp();
        
        if ($this->last_login == $time) {
            // no change required
            return;
        }
        
        elgg_call(ELGG_IGNORE_ACCESS | ELGG_DISABLE_SYSTEM_LOG, function() use ($time) {
            // these writes actually work, we just type hint read-only.
            $this->prev_last_login = $this->last_login;
            $this->last_login = $time;
        });
    }
    
    public function setLastAction(): void {
        
        $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(): ?bool {
        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(): int {
        $owner_guid = parent::getOwnerGUID();
        if ($owner_guid === 0) {
            $owner_guid = (int) $this->guid;
        }
 
        return $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(string $password): void {
        $this->setMetadata('password_hash', _elgg_services()->passwords->generateHash($password));
        if ($this->guid === elgg_get_logged_in_user_guid()) {
            // update the session user token, so this session remains valid
            // other sessions for this user will be invalidated
            _elgg_services()->session_manager->setUserToken();
        }
    }
 
    public function setNotificationSetting(string $method, bool $enabled = true, string $purpose = 'default'): bool {
        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', bool $only_active_methods = false): array {
        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 $only_active_methods ? array_keys(array_filter($settings)) : $settings;
    }
    
    public function persistentDelete(bool $recursive = true): bool {
        $result = parent::persistentDelete($recursive);
        if ($result) {
            // cleanup remember me cookie records
            _elgg_services()->users_remember_me_cookies_table->deleteAllHashes($this);
        }
        
        return $result;
    }
    
    public function getPluginSetting(string $plugin_id, string $name, $default = null) {
        $plugin = _elgg_services()->plugins->get($plugin_id);
        if (!$plugin instanceof \ElggPlugin || !$plugin->isActive()) {
            return $default;
        }
        
        $static_defaults = (array) $plugin->getStaticConfig('user_settings', []);
        
        $default = elgg_extract($name, $static_defaults, $default);
        
        return $this->psGetPluginSetting($plugin_id, $name, $default);
    }
    
    public function notify(string $action, \ElggData $subject, array $params = [], ?\ElggEntity $from = null): array {
        return _elgg_services()->notifications->sendInstantNotification($this, $action, $subject, $params, $from);
    }
}