SumoCoders\FrameworkSettingsBundle\SettingsManager

Complexity

Total Complexity

20

Size/Duplication

Total Lines	186
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

88.71%

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	initialize()	0	7	2
A	clear()	0	4	1
A	add()	0	15	3
A	all()	0	12	3
A	get()	0	9	2
A	set()	0	23	2
A	has()	0	7	1
A	resolve()	0	4	1
A	resolveValue()	0	4	1
A	escapeValue()	0	4	1
A	unescapeValue()	0	4	1
A	remove()	0	4	1

<?php

namespace SumoCoders\FrameworkSettingsBundle;

use Doctrine\ORM\EntityManager;
use SumoCoders\FrameworkSettingsBundle\Entity\Setting;
use SumoCoders\FrameworkSettingsBundle\Entity\SettingRepository;
use SumoCoders\FrameworkSettingsBundle\Exception\DontUseException;
use SumoCoders\FrameworkSettingsBundle\Exception\InvalidInstanceException;
use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;

class SettingsManager implements ParameterBagInterface
{
    /**
     * @var EntityManager
     */
    protected $entityManager;

    /**
     * @var SettingRepository
     */
    protected $repository;

    /**
     * Parameter storage.
     *
     * @var array
     */
    protected $settings;

    /**
     * Is the class initialized
     *
     * @var bool
     */
    protected $isInitialized = false;

    /**
     * @param EntityManager     $entityManager
     * @param SettingRepository $repository
     */
    public function __construct($entityManager, $repository)

You have injected the EntityManager via parameter $entityManager. This is generally not recommended as it might get closed and become unusable. Instead, it is recommended to inject the ManagerRegistry and retrieve the EntityManager via getManager() each time you need it.

    {
        $this->entityManager = $entityManager;
        $this->repository = $repository;
    }

    /**
     * Initialize the settings
     */
    protected function initialize()
    {
        if (!$this->isInitialized) {
            $this->all();
        }
        $this->isInitialized = true;
    }

    /**
     * {@inheritdoc}
     */
    public function clear()
    {
        throw new DontUseException();
    }

    /**
     * {@inheritdoc}
     */
    public function add(array $parameters)
    {
        $this->isInitialized = false;
        foreach ($parameters as $setting) {
            if (!($setting instanceof Setting)) {
                throw new InvalidInstanceException('This is not an instance of the Setting-class.');
            }

            $this->set(
                $setting->getName(),
                $setting->getValue(),
                $setting->isEditable()
            );
        }
    }

    /**
     * {@inheritdoc}
     */
    public function all()
    {
        $settings = $this->repository->findAll();

        if (!empty($settings)) {
            foreach ($settings as $setting) {
                $this->settings[$setting->getName()] = $setting;
            }
        }

        return $this->settings;
    }

    /**
     * {@inheritdoc}
     */
    public function get($name, $defaultValue = null)
    {
        $this->initialize();
        if (!isset($this->settings[$name])) {
            return $defaultValue;
        }

        return $this->settings[$name]->getValue();
    }

    /**
     * Store a setting
     *
     * @param string $name
     * @param mixed  $value
     * @param bool   $isEditable
     * @return $this
     */
    public function set($name, $value, $isEditable = false)
    {
        $this->isInitialized = false;

        if ($this->has($name)) {
            $setting = $this->settings[$name];
        } else {
            $setting = new Setting();
            $setting->setName($name);
        }

        $setting->setValue($value);
        $setting->setEditable($isEditable);

        // store and flush
        $this->entityManager->persist($setting);
        $this->entityManager->flush();

        // reset it
        $this->settings[$name] = $setting;

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function has($name)
    {
        $this->isInitialized = false;
        $this->initialize();

        return isset($this->settings[$name]);
    }

    /**
     * {@inheritdoc}
     */
    public function resolve()
    {
        throw new DontUseException();
    }

    /**
     * {@inheritdoc}
     */
    public function resolveValue($value)
    {
        throw new DontUseException();
    }

    /**
     * {@inheritdoc}
     */
    public function escapeValue($value)
    {
        throw new DontUseException();
    }

    /**
     * {@inheritdoc}
     */
    public function unescapeValue($value)
    {
        throw new DontUseException();
    }

    /**
     * {@inheritdoc}
     */
    public function remove($name)
    {
        throw new DontUseException();
    }
}