DoS\UserBundle\Confirmation\ConfirmationFactory

Complexity

Total Complexity

15

Size/Duplication

Total Lines	132
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	1

Importance

Changes	4
Bugs	0	Features	2

7 Methods

Rating	Name	Duplication	Size	Complexity
A	has()	0	4	1
A	__construct()	0	5	1
A	getSettingsParameter()	0	14	2
A	setActivedService()	0	8	3
A	add()	0	8	2
A	create()	0	15	3
A	createActivedConfirmation()	0	12	3

<?php

namespace DoS\UserBundle\Confirmation;

use Sylius\Bundle\SettingsBundle\Manager\SettingsManagerInterface;

class ConfirmationFactory
{
    /**
     * @var array
     */
    protected $types = array();

    /**
     * @var array
     */
    protected $options = array();

    /**
     * @var null|string
     */
    protected $activedService = null;

    /**
     * @var SettingsManagerInterface
     */
    protected $settingsManager;

    public function __construct(SettingsManagerInterface $settingsManager)
    {
        $this->settingsManager = $settingsManager;
        // TODO: apply options from settings
    }

    /**
     * Load settings parameter for given namespace and name.
     *
     * @param string $name
     *
     * @return mixed
     *
     * @throws \InvalidArgumentException
     */
    protected function getSettingsParameter($name)
    {
        if (false === strpos($name, '.')) {
            throw new \InvalidArgumentException(
                sprintf('Parameter must be in format "namespace.name", "%s" given.', $name)
            );
        }

        list($namespace, $name) = explode('.', $name);

        $settings = $this->settingsManager->load($namespace);

        return $settings->get($name);
    }

    /**
     * @param $name
     *
     * @throws \Exception
     */
    public function setActivedService($name)
    {
        if ($name && !$this->has($name)) {
            throw new \Exception(sprintf('Cannot set unregistered confirmation type "%s".', $name));
        }

        $this->activedService = $name;
    }

    /**
     * @param ConfirmationInterface $confirmation
     * @param array                 $options
     */
    public function add(ConfirmationInterface $confirmation, array $options = array())
    {
        $this->types[$confirmation->getType()] = $confirmation;

        if (!empty($options)) {
            $this->options[$confirmation->getType()] = $options;
        }
    }

    /**
     * @param $name
     *
     * @return bool
     */
    public function has($name)
    {
        return array_key_exists($name, $this->types);
    }

    /**
     * @param $name
     *
     * @return ConfirmationInterface
     *
     * @throws \Exception
     */
    public function create($name)
    {
        if (!$this->has($name)) {
            throw new \Exception(sprintf('Not found confirmation type "%s".', $name));
        }

        /** @var ConfirmationInterface $instance */
        $instance = $this->types[$name];

        if (array_key_exists($name, $this->options)) {
            $instance->resetOptions($this->options[$name]);
        }

        return $instance;
    }

    /**
     * @param bool $invalidException
     *
     * @return ConfirmationInterface|null
     *
     * @throws \Exception
     */
    public function createActivedConfirmation($invalidException = false)
    {
        try {
            return $this->create($this->activedService);
        } catch (\Exception $e) {
            if ($invalidException) {
                throw $e;
            }
        }

        return;
    }
}