ONGR\SettingsBundle\Settings\Personal\PersonalSettingsManager

Complexity

Total Complexity

25

Size/Duplication

Total Lines	251
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	6

Importance

Changes	7
Bugs	0	Features	1

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	setSettingsFromStash()	0	8	2
A	setSettings()	0	4	1
A	getSettingEnabled()	0	12	4
A	save()	0	8	1
A	stashClear()	0	4	1
A	isAuthenticated()	0	4	1
A	getSettings()	0	4	1
A	getActiveProfiles()	0	12	4
A	getSettingsMap()	0	4	1
A	getCategoryMap()	0	4	1
A	getStashName()	0	19	3
A	guessPropertyOrMethodName()	0	9	2
A	toCamelCase()	0	8	2

<?php

/*
 * This file is part of the ONGR package.
 *
 * (c) NFQ Technologies UAB <info@nfq.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace ONGR\SettingsBundle\Settings\Personal;

use Stash\Pool;
use ONGR\SettingsBundle\Settings\Personal\SettingsStructure;
use Symfony\Component\Security\Core\Authorization\AuthorizationChecker;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorage;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use ONGR\SettingsBundle\Event\SettingChangeEvent;

/**
 * Service responsible as a gateway to user settings.
 */
class PersonalSettingsManager
{
    /**
     * @var string
     */
    const ROLE_GRANTED = 'ROLE_ADMIN';

    /**
     * @var string
     */
    const STASH_NAME = 'ongr_settings';

    /**
     * @var EventDispatcherInterface
     */
    protected $eventDispatcher;

    /**
     * @var string
     */
    private $userParam;

    /**
     * Stash name for the current user
     *
     * @var string
     */
    private $stash;

    /**
     * @var AuthorizationChecker
     */
    private $securityContext;

    /**
     * @var TokenStorage
     */
    private $token;

    /**
     * @var SettingsStructure
     */
    private $settingsStructure;

    /**
     * @var array;
     */
    private $userSettings = [];

    /**
     * Stash for storing personal settings
     *
     * @var \Pool
     */
    private $pool;

    /**
     * @param String                   $userParam
     * @param SettingsStructure        $settingsStructure
     * @param EventDispatcherInterface $eventDispatcher
     * @param AuthorizationChecker     $authorization
     * @param TokenStorage             $token
     * @param Pool                     $pool
     */
    public function __construct($userParam, $settingsStructure, $eventDispatcher, $authorization, $token, $pool)
    {
        $this->settingsStructure = $settingsStructure;
        $this->eventDispatcher = $eventDispatcher;
        $this->securityContext = $authorization;
        $this->token = $token;
        $this->pool = $pool;

It seems like $pool of type object<Stash\Pool> is incompatible with the declared type object<Pool> of property $pool.

        $this->userParam = $userParam;
    }

    /**
     * Sets settings for the current user from stash
     */
    public function setSettingsFromStash()
    {
        $this->stash = $this->getStashName($this->token->getToken()->getUser());
        $stashedSettings = $this->pool->getItem($this->stash)->get();
        if (is_array($stashedSettings)) {
            $this->userSettings = $stashedSettings;
        }
    }

    /**
     * @param array $settings
     */
    public function setSettings(array $settings)
    {
        $this->userSettings = $settings;
    }

    /**
     * If user logged in, returns setting value from cookie. Else, returns false.
     *
     * @param string $settingName
     * @param bool   $mustAuthorize
     *
     * @return bool
     */
    public function getSettingEnabled($settingName, $mustAuthorize = true)
    {
        if ($mustAuthorize && !$this->isAuthenticated()) {
            return false;
        }
        $this->setSettingsFromStash();
        if (isset($this->userSettings[$settingName])) {
            return $this->userSettings[$settingName];
        }

        return false;
    }

    /**
     * Saves the current settings to stash
     *
     * @throws \BadMethodCallException
     */
    public function save()
    {
        $stashedSettings = $this->pool->getItem($this->stash);
        $stashedSettings->set($this->userSettings);
        $this->pool->save($stashedSettings);

        $this->eventDispatcher->dispatch('ongr_settings.setting_change', new SettingChangeEvent('save'));

'save' is of type string, but the function expects a object<ONGR\SettingsBundle\Event\Action>.

    }

    /**
     * Clears the stash
     */
    public function stashClear()
    {
        $this->pool->deleteItem($this->stash);
    }

    /**
     * @return bool
     */
    public function isAuthenticated()
    {
        return $this->securityContext->isGranted(self::ROLE_GRANTED);
    }

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

    /**
     * Gets active profiles
     *
     * @return array
     */
    public function getActiveProfiles()
    {
        $profiles = [];
        $this->setSettingsFromStash();
        foreach ($this->userSettings as $name => $userSetting) {
            if (preg_match('/^ongr_settings_profile_.*/', $name) && $userSetting) {
                $escapedProfile = mb_substr($name, 22, null, 'UTF-8');
                $profiles[] = UnderscoreEscaper::unescape($escapedProfile);
            }
        }
        return $profiles;
    }

    /**
     * @return array
     */
    public function getSettingsMap()
    {
        return $this->settingsStructure->getStructure();
    }

    /**
     * @return array
     */
    public function getCategoryMap()
    {
        return $this->settingsStructure->getCategoriesStructure();
    }

    /**
     * Returns the full name of the stash for the current
     * User. If the unique user property value cant be determined
     * returns false.
     *
     * @param $user
     *
     * @return string
     * @throws \BadMethodCallException
     */
    private function getStashName($user)
    {
        $property = $this->guessPropertyOrMethodName($user);
        $stashName =  self::STASH_NAME.'_';
        try {
            if ($property[0] == 'public') {
                $stashName = $stashName . $user->$property[1];
            } else {
                $method = $property[1];
                $stashName = $stashName . $user->$method();
            }
            $this->stash = $stashName;
            return $stashName;
        } catch (\Exception $e) {
            throw new \BadMethodCallException(
                'Ongr could not guess the getter method for your defined user property.'
            );
        }
    }

    /**
     * Returns the property visibility and if its
     * private, guesses the name of the getter
     *
     * @param $user
     *
     * @return array
     */
    private function guessPropertyOrMethodName($user)
    {
        $property = $this->userParam;
        if (isset($user->$property)) {
            return ['public', $this->userParam];
        } else {
            return ['private', $this->toCamelCase($this->userParam)];
        }
    }

    /**
     * Converts a string to camel case
     *
     * @param string $name
     *
     * @return string
     */
    private function toCamelCase($name)
    {
        $return = explode('_', $name);
        foreach ($return as $key => $item) {
            $return[$key] = ucfirst($item);
        }
        return 'get'.implode('', $return);
    }
}