Saito\User\SaitoUser

Complexity

Total Complexity

25

Size/Duplication

Total Lines	198
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	2
B	setSettings()	0	42	8
A	get()	0	8	2
A	set()	0	4	1
A	getSettings()	0	4	1
A	getId()	0	4	1
A	isLoggedIn()	0	4	1
A	isUser()	0	12	4
A	isLocked()	0	4	1
A	isActivated()	0	4	1
A	getRole()	0	8	2
A	permission()	0	6	1

<?php

/**
 * Saito - The Threaded Web Forum
 *
 * @copyright Copyright (c) the Saito Project Developers
 * @link https://github.com/Schlaefer/Saito
 * @license http://opensource.org/licenses/MIT
 */

namespace Saito\User;

use App\Model\Entity\User;
use Cake\Utility\Hash;
use Saito\App\Registry;

/**
 * Class SaitoUser
 */
class SaitoUser implements ForumsUserInterface
{
    public $Categories;

    /**
     * User ID
     *
     * @var int
     */
    protected $_id = null;

    /**
     * Stores if a user is logged in
     *
     * @var bool
     */
    protected $_isLoggedIn = false;

    /**
     * User settings
     *
     * @var array
     */
    protected $_settings = null;

    /**
     * Constructor.
     *
     * @param mixed $settings user-settings
     */
    public function __construct($settings = null)
    {
        if ($settings !== null) {
            $this->setSettings($settings);
            $this->Categories = new Categories($this);
        }
    }

    /**
     * {@inheritDoc}
     */
    public function setSettings($settings)
    {
        if (empty($settings)) {
            $this->_id = null;
            $this->_settings = null;

It seems like null of type null is incompatible with the declared type array of property $_settings.

            $this->_isLoggedIn = false;

            return;
        } elseif ($settings instanceof User) {
            $settings = $settings->toArray();
        }

        if (empty($settings) || !is_array($settings)) {
            throw new \RuntimeException("Can't set user.", 1434705388);
        }

        if (!empty($settings['id'])) {
            $this->_id = (int)$settings['id'];
            $this->_isLoggedIn = true;
        }

        $this->_settings = $settings;

        // perf-cheat
        if (!empty($this->_settings['last_refresh'])) {
            $this->_settings['last_refresh_unix'] = dateToUnix($this->_settings['last_refresh']);
        }

        //// performance cheat
        // adds a property 'ignores' which in a array holds all users ignored by this users as keys:
        // ['<key is user-id of ignored user> => <trueish>, …]
        if (!empty($this->_settings['user_ignores'])) {
            $this->_settings['ignores'] = array_fill_keys(
                Hash::extract(
                    $this->_settings,
                    'user_ignores.{n}.blocked_user_id'
                ),
                1
            );
            unset($this->_settings['user_ignores']);
        }
    }

    /**
     * Get single user setting.
     *
     * @param string $setting setting-key
     * @return null|mixed null if setting not found
     */
    public function get($setting)
    {
        if (!isset($this->_settings[$setting])) {
            return null;
        }

        return $this->_settings[$setting];
    }

    /**
     * Set single setting.
     *
     * @param string $setting setting-key
     * @param mixed $value value to set
     * @return void
     */
    public function set($setting, $value)
    {
        $this->_settings[$setting] = $value;
    }

    /**
     * {@inheritDoc}
     */
    public function getSettings()
    {
        return $this->_settings;
    }

    /**
     * {@inheritDoc}
     */
    public function getId()
    {
        return $this->_id;
    }

    /**
     * {@inheritDoc}
     */
    public function isLoggedIn()
    {
        return $this->_isLoggedIn;
    }

    /**
     * {@inheritDoc}
     */
    public function isUser($user)
    {
        if (is_numeric($user)) {
            $id = (int)$user;
        } elseif ($user instanceof ForumsUserInterface || $user instanceof User) {
            $id = $user->get('id');
        } else {
            throw new \InvalidArgumentException("Can't compare users.", 1434704215);
        }

        return $id === $this->getId();
    }

    /**
     * Checks if user is forbidden.
     *
     * @return bool
     */
    public function isLocked(): bool
    {
        return (bool)$this->get('user_lock');
    }

    /**
     * Checks if user is forbidden.
     *
     * @return bool
     */
    public function isActivated() : bool
    {
        return !$this->get('activate_code');
    }

    /**
     * Get role.
     *
     * @return string
     */
    public function getRole()
    {
        if ($this->_id === null) {
            return 'anon';
        } else {
            return $this->get('user_type');
        }
    }

    /**
     * Check if user has permission to access a resource.
     *
     * @param string $resource resource
     * @return bool
     */
    public function permission($resource)
    {
        $permission = Registry::get('Permission');

        return $permission->check($this->getRole(), $resource);
    }
}