SettingsManager::saveSettings() - Code Metrics - Inspection of "Add SettingsManager class" - chamilo/chamilo-lms - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 82664b...176635 )

by Julito

created 2016-11-21 15:09 UTC

SettingsManager::saveSettings() B

↳ Parent: SettingsManager

Complexity

Conditions	8
Paths	48

Size

Total Lines	57
Code Lines	31

Duplication

Lines	28
Ratio	49.12 %

Importance

Changes

Metric	Value
cc	8
eloc	31
c	0
b	0
f	0
nc	48
nop	2
dl	28
loc	57
rs	7.2648

How to fix Long Method

<?php
/* For licensing terms, see /license.txt */

namespace Chamilo\CourseBundle\Manager;

use Doctrine\Common\Cache\Cache;
use Doctrine\Common\Persistence\ObjectManager;
use Sylius\Bundle\SettingsBundle\Model\Settings;
use Sylius\Bundle\SettingsBundle\Schema\SchemaRegistryInterface;
use Sylius\Bundle\SettingsBundle\Schema\SettingsBuilder;
use Sylius\Component\Resource\Repository\RepositoryInterface;
use Symfony\Component\Validator\ConstraintViolationListInterface;
use Symfony\Component\Validator\Exception\ValidatorException;
use Symfony\Component\Validator\ValidatorInterface;
use Chamilo\SettingsBundle\Manager\SettingsManager as ChamiloSettingsManager;
use Chamilo\CourseBundle\Entity\CCourseSetting;
use Chamilo\CoreBundle\Entity\Course;
use Sylius\Bundle\SettingsBundle\Manager\SettingsManagerInterface;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;

/**
 * Class SettingsManager
 * Course settings manager.
 * @package Chamilo\CourseBundle\Manager
 */
class SettingsManager extends ChamiloSettingsManager implements SettingsManagerInterface
{
    protected $course;

    /**
     * @return Course
     */
    public function getCourse()
    {
        return $this->course;
    }

    /**
     * @param Course $course
     */
    public function setCourse(Course $course)
    {
        $this->course = $course;
    }

    /**
     * {@inheritdoc}
     */
    public function loadSettings($namespace)
    {
        if (isset($this->resolvedSettings[$namespace])) {
            return $this->resolvedSettings[$namespace];
        }

        /*if ($this->cache->contains($namespace)) {
            $parameters = $this->cache->fetch($namespace);
        } else {
            $parameters = $this->getParameters($namespace);
        }*/
        $parameters = $this->getParameters($namespace);

        $schema = $this->schemaRegistry->getSchema($namespace);

        $settingsBuilder = new SettingsBuilder();
        $schema->buildSettings($settingsBuilder);

        foreach ($settingsBuilder->getTransformers() as $parameter => $transformer) {
            if (array_key_exists($parameter, $parameters)) {
                $parameters[$parameter] = $transformer->reverseTransform($parameters[$parameter]);
            }
        }

        $parameters = $settingsBuilder->resolve($parameters);

        return $this->resolvedSettings[$namespace] = new Settings($parameters);
    }

    /**
     * {@inheritdoc}
     * @throws ValidatorException
     */
    public function saveSettings($namespace, Settings $settings)
    {
        $schema = $this->schemaRegistry->getSchema($namespace);

        $settingsBuilder = new SettingsBuilder();
        $schema->buildSettings($settingsBuilder);

        $parameters = $settingsBuilder->resolve($settings->getParameters());

        foreach ($settingsBuilder->getTransformers() as $parameter => $transformer) {
            if (array_key_exists($parameter, $parameters)) {
                $parameters[$parameter] = $transformer->transform($parameters[$parameter]);
            }
        }

        if (isset($this->resolvedSettings[$namespace])) {
            $this->resolvedSettings[$namespace]->setParameters($parameters);
        }

        $persistedParameters = $this->parameterRepository->findBy(
            array('category' => $namespace, 'cId' => $this->getCourse()->getId())
        );

        $persistedParametersMap = array();

        foreach ($persistedParameters as $parameter) {
            $persistedParametersMap[$parameter->getName()] = $parameter;
        }

        foreach ($parameters as $name => $value) {
            if (isset($persistedParametersMap[$name])) {
                $persistedParametersMap[$name]->setValue($value);
            } else {
                /** @var CCourseSetting $parameter */
                //$parameter = $this->parameterFactory->createNew();
                $parameter = new CCourseSetting();
                $parameter
                    ->setNamespace($namespace)
                    ->setName($name)
                    ->setValue($value)
                    ->setCId($this->getCourse()->getId())
                ;

                /* @var $errors ConstraintViolationListInterface */
                $errors = $this->validator->validate($parameter);
                if (0 < $errors->count()) {
                    throw new ValidatorException($errors->get(0)->getMessage());
                }

                $this->parameterManager->persist($parameter);
            }
        }

        $this->parameterManager->flush();

        $this->cache->save($namespace, $parameters);
    }

    /**
     * Load parameter from database.
     *
     * @param string $namespace
     *
     * @return array
     */
    private function getParameters($namespace)

    {
        $parameters = array();
        foreach ($this->parameterRepository->findBy(array('category' => $namespace)) as $parameter) {
            $parameters[$parameter->getName()] = $parameter->getValue();
        }

        return $parameters;
    }
}


1		<?php
2		/* For licensing terms, see /license.txt */
3
4		namespace Chamilo\CourseBundle\Manager;
5
6		use Doctrine\Common\Cache\Cache;
7		use Doctrine\Common\Persistence\ObjectManager;
8		use Sylius\Bundle\SettingsBundle\Model\Settings;
9		use Sylius\Bundle\SettingsBundle\Schema\SchemaRegistryInterface;
10		use Sylius\Bundle\SettingsBundle\Schema\SettingsBuilder;
11		use Sylius\Component\Resource\Repository\RepositoryInterface;
12		use Symfony\Component\Validator\ConstraintViolationListInterface;
13		use Symfony\Component\Validator\Exception\ValidatorException;
14		use Symfony\Component\Validator\ValidatorInterface;
15		use Chamilo\SettingsBundle\Manager\SettingsManager as ChamiloSettingsManager;
16		use Chamilo\CourseBundle\Entity\CCourseSetting;
17		use Chamilo\CoreBundle\Entity\Course;
18		use Sylius\Bundle\SettingsBundle\Manager\SettingsManagerInterface;
19		use Symfony\Component\EventDispatcher\EventDispatcherInterface;
20
21		/**
22		* Class SettingsManager
23		* Course settings manager.
24		* @package Chamilo\CourseBundle\Manager
25		*/
26		class SettingsManager extends ChamiloSettingsManager implements SettingsManagerInterface
27		{
28		protected $course;
29
30		/**
31		* @return Course
32		*/
33		public function getCourse()
34		{
35		return $this->course;
36		}
37
38		/**
39		* @param Course $course
40		*/
41		public function setCourse(Course $course)
42		{
43		$this->course = $course;
44		}
45
46		/**
47		* {@inheritdoc}
48		*/
49		public function loadSettings($namespace)
50		{
51		if (isset($this->resolvedSettings[$namespace])) {
52		return $this->resolvedSettings[$namespace];
53		}
54
55		/*if ($this->cache->contains($namespace)) {
56		$parameters = $this->cache->fetch($namespace);
57		} else {
58		$parameters = $this->getParameters($namespace);
59		}*/
60		$parameters = $this->getParameters($namespace);
61
62		$schema = $this->schemaRegistry->getSchema($namespace);
63
64		$settingsBuilder = new SettingsBuilder();
65		$schema->buildSettings($settingsBuilder);
66
67	View Code Duplication	foreach ($settingsBuilder->getTransformers() as $parameter => $transformer) {
68		if (array_key_exists($parameter, $parameters)) {
69		$parameters[$parameter] = $transformer->reverseTransform($parameters[$parameter]);
70		}
71		}
72
73		$parameters = $settingsBuilder->resolve($parameters);
74
75		return $this->resolvedSettings[$namespace] = new Settings($parameters);
76		}
77
78		/**
79		* {@inheritdoc}
80		* @throws ValidatorException
81		*/
82		public function saveSettings($namespace, Settings $settings)
83		{
84		$schema = $this->schemaRegistry->getSchema($namespace);
85
86		$settingsBuilder = new SettingsBuilder();
87		$schema->buildSettings($settingsBuilder);
88
89		$parameters = $settingsBuilder->resolve($settings->getParameters());
90
91	View Code Duplication	foreach ($settingsBuilder->getTransformers() as $parameter => $transformer) {
92		if (array_key_exists($parameter, $parameters)) {
93		$parameters[$parameter] = $transformer->transform($parameters[$parameter]);
94		}
95		}
96
97		if (isset($this->resolvedSettings[$namespace])) {
98		$this->resolvedSettings[$namespace]->setParameters($parameters);
99		}
100
101		$persistedParameters = $this->parameterRepository->findBy(
102		array('category' => $namespace, 'cId' => $this->getCourse()->getId())
103		);
104
105		$persistedParametersMap = array();
106
107		foreach ($persistedParameters as $parameter) {
108		$persistedParametersMap[$parameter->getName()] = $parameter;
109		}
110
111	View Code Duplication	foreach ($parameters as $name => $value) {
112		if (isset($persistedParametersMap[$name])) {
113		$persistedParametersMap[$name]->setValue($value);
114		} else {
115		/** @var CCourseSetting $parameter */
116		//$parameter = $this->parameterFactory->createNew();
117		$parameter = new CCourseSetting();
118		$parameter
119		->setNamespace($namespace)
120		->setName($name)
121		->setValue($value)
122		->setCId($this->getCourse()->getId())
123		;
124
125		/* @var $errors ConstraintViolationListInterface */
126		$errors = $this->validator->validate($parameter);
127		if (0 < $errors->count()) {
128		throw new ValidatorException($errors->get(0)->getMessage());
129		}
130
131		$this->parameterManager->persist($parameter);
132		}
133		}
134
135		$this->parameterManager->flush();
136
137		$this->cache->save($namespace, $parameters);
138		}
139
140		/**
141		* Load parameter from database.
142		*
143		* @param string $namespace
144		*
145		* @return array
146		*/
147	View Code Duplication	private function getParameters($namespace)
		0 ignored issues – show Bug introduced 2016-03-01 01:58 UTC by Report Bug Copy Issue Report Consider using a different method name as you override a private method of the parent class. Overwriting private methods is generally fine as long as you also use private visibility. It might still be preferable for understandability to use a different method name. Loading history...
148		{
149		$parameters = array();
150		foreach ($this->parameterRepository->findBy(array('category' => $namespace)) as $parameter) {
151		$parameters[$parameter->getName()] = $parameter->getValue();
152		}
153
154		return $parameters;
155		}
156		}
157

chamilo / chamilo-lms

Push — master ( 82664b...176635 )

SettingsManager::saveSettings() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like