ElggSession.php

Go to the documentation of this file.

<?php

use Elgg\Config;
use Elgg\Database;
use Elgg\Http\DatabaseSessionHandler;
use Symfony\Component\HttpFoundation\Session\Session;
use Symfony\Component\HttpFoundation\Session\SessionInterface;
use Symfony\Component\HttpFoundation\Session\Storage\MockArraySessionStorage;
use Symfony\Component\HttpFoundation\Session\Storage\NativeSessionStorage;

class ElggSession {

    protected $storage;

    protected $logged_in_user;

    protected $ignore_access = false;

    protected $show_disabled_entities = false;

    public function __construct(SessionInterface $storage) {
        $this->storage = $storage;
    }

    public function start() {
        
        if ($this->storage->getId()) {
            return true;
        }

        $result = $this->storage->start();
        $this->generateSessionToken();
        return $result;
    }

    public function migrate($destroy = false) {
        return $this->storage->migrate($destroy);
    }

    public function invalidate() {
        $this->storage->clear();
        $this->logged_in_user = null;
        $result = $this->migrate(true);
        $this->generateSessionToken();
        _elgg_services()->sessionCache->clear();
        return $result;
    }

    public function save() {
        $this->storage->save();
    }

    public function isStarted() {
        return $this->storage->isStarted();
    }

    public function getId() {
        return $this->storage->getId();
    }

    public function setId($id) {
        $this->storage->setId($id);
    }

    public function getName() {
        return $this->storage->getName();
    }

    public function setName($name) {
        $this->storage->setName($name);
    }

    public function get($name, $default = null) {
        return $this->storage->get($name, $default);
    }

    public function set($name, $value) {
        $this->storage->set($name, $value);
    }

    public function remove($name) {
        return $this->storage->remove($name);
    }

    public function has($name) {
        return $this->storage->has($name);
    }

    public function setLoggedInUser(\ElggUser $user) {
        $current_user = $this->getLoggedInUser();
        if ($current_user != $user) {
            $this->set('guid', $user->guid);
            $this->logged_in_user = $user;
            _elgg_services()->sessionCache->clear();
            _elgg_services()->translator->setCurrentLanguage($user->language);
        }
    }

    public function getLoggedInUser() {
        return $this->logged_in_user;
    }

    public function getLoggedInUserGuid() {
        $user = $this->getLoggedInUser();
        return $user ? $user->guid : 0;
    }
    
    public function isAdminLoggedIn() {
        $user = $this->getLoggedInUser();
    
        return $user && $user->isAdmin();
    }
    
    public function isLoggedIn() {
        return (bool) $this->getLoggedInUser();
    }

    public function removeLoggedInUser() {
        $this->logged_in_user = null;
        $this->remove('guid');
        _elgg_services()->sessionCache->clear();
    }

    public function getIgnoreAccess() {
        return $this->ignore_access;
    }

    public function setIgnoreAccess($ignore = true) {
        $prev = $this->ignore_access;
        $this->ignore_access = $ignore;

        return $prev;
    }

    public function getDisabledEntityVisibility() {
        global $ENTITY_SHOW_HIDDEN_OVERRIDE;
        if (isset($ENTITY_SHOW_HIDDEN_OVERRIDE)) {
            return $ENTITY_SHOW_HIDDEN_OVERRIDE;
        }

        return $this->show_disabled_entities;
    }

    public function setDisabledEntityVisibility($show = true) {
        global $ENTITY_SHOW_HIDDEN_OVERRIDE;
        $ENTITY_SHOW_HIDDEN_OVERRIDE = $show;

        $prev = $this->show_disabled_entities;
        $this->show_disabled_entities = $show;

        return $prev;
    }

    protected function generateSessionToken() {
        // Generate a simple token that we store server side
        if (!$this->has('__elgg_session')) {
            $this->set('__elgg_session', _elgg_services()->crypto->getRandomString(22));
        }
    }

    public static function getMock() {
        $storage = new MockArraySessionStorage();
        $session = new Session($storage);
        return new self($session);
    }

    public static function fromDatabase(Config $config, Database $db) {
        $params = $config->getCookieConfig()['session'];
        $options = [
            // session.cache_limiter is unfortunately set to "" by the NativeSessionStorage
            // constructor, so we must capture and inject it directly.
            'cache_limiter' => session_cache_limiter(),

            'name' => $params['name'],
            'cookie_path' => $params['path'],
            'cookie_domain' => $params['domain'],
            'cookie_secure' => $params['secure'],
            'cookie_httponly' => $params['httponly'],
            'cookie_lifetime' => $params['lifetime'],
        ];

        $handler = new DatabaseSessionHandler($db);
        $storage = new NativeSessionStorage($options, $handler);
        $session = new Session($storage);
        return new self($session);
    }

    public static function fromFiles(Config $config) {
        $params = $config->getCookieConfig()['session'];
        $options = [
            // session.cache_limiter is unfortunately set to "" by the NativeSessionStorage
            // constructor, so we must capture and inject it directly.
            'cache_limiter' => session_cache_limiter(),

            'name' => $params['name'],
            'cookie_path' => $params['path'],
            'cookie_domain' => $params['domain'],
            'cookie_secure' => $params['secure'],
            'cookie_httponly' => $params['httponly'],
            'cookie_lifetime' => $params['lifetime'],
        ];

        $storage = new NativeSessionStorage($options);
        $session = new Session($storage);
        return new self($session);
    }
}