ElggSession.php

Go to the documentation of this file.

<?php

use Symfony\Component\HttpFoundation\Session\SessionInterface;
use Symfony\Component\HttpFoundation\Session\Storage\MockArraySessionStorage;
use Symfony\Component\HttpFoundation\Session\Session;

class ElggSession implements \ArrayAccess {

    protected $storage;

    protected $logged_in_user;

    protected $ignore_access = false;

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

    public function start() {
        $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();
        return $result;
    }

    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 del($key) {
        elgg_deprecated_notice(__METHOD__ . " has been deprecated.", 1.9);
        $this->remove($key);
    }

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

    public function setLoggedInUser(\ElggUser $user) {
        $this->set('guid', $user->guid);
        $this->logged_in_user = $user;
    }

    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');
    }

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

    public function setIgnoreAccess($ignore = true) {
        _elgg_services()->accessCache->clear();

        $prev = $this->ignore_access;
        $this->ignore_access = $ignore;

        return $prev;
    }

    // @codingStandardsIgnoreStart
    public function get_ignore_access() {
        return $this->getIgnoreAccess();
    }
    // @codingStandardsIgnoreEnd

    // @codingStandardsIgnoreStart
    public function set_ignore_access($ignore = true) {
        return $this->setIgnoreAccess($ignore);
    }
    // @codingStandardsIgnoreEnd

    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 function __isset($key) {
        elgg_deprecated_notice(__METHOD__ . " has been deprecated.", 1.9);
        // Note: We use offsetExists() for BC
        return $this->offsetExists($key);
    }

    public function offsetSet($key, $value) {
        elgg_deprecated_notice(__METHOD__ . " has been deprecated.", 1.9);
        $this->set($key, $value);
    }

    public function offsetGet($key) {
        elgg_deprecated_notice(__METHOD__ . " has been deprecated.", 1.9);

        if (in_array($key, array('user', 'id', 'name', 'username'))) {
            elgg_deprecated_notice("Only 'guid' is stored in session for user now", 1.9);
            if ($this->logged_in_user) {
                switch ($key) {
                    case 'user':
                        return $this->logged_in_user;
                        break;
                    case 'id':
                        return $this->logged_in_user->guid;
                        break;
                    case 'name':
                    case 'username':
                        return $this->logged_in_user->$key;
                        break;
                }
            } else {
                return null;
            }
        }

        if ($this->has($key)) {
            return $this->get($key);
        }

        $orig_value = null;
        $value = _elgg_services()->hooks->trigger('session:get', $key, null, $orig_value);
        if ($orig_value !== $value) {
            elgg_deprecated_notice("Plugin hook session:get has been deprecated.", 1.9);
        }

        $this->set($key, $value);
        return $value;
    }

    public function offsetUnset($key) {
        elgg_deprecated_notice(__METHOD__ . " has been deprecated.", 1.9);
        $this->remove($key);
    }

    public function offsetExists($offset) {
        elgg_deprecated_notice(__METHOD__ . " has been deprecated.", 1.9);

        if (in_array($offset, array('user', 'id', 'name', 'username'))) {
            elgg_deprecated_notice("Only 'guid' is stored in session for user now", 1.9);
            return (bool)$this->logged_in_user;
        }

        if ($this->has($offset)) {
            return true;
        }

        // Note: We use offsetGet() for BC
        if ($this->offsetGet($offset)) {
            return true;
        }

        return false;
    }

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