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

Completed

Push — master ( f7178d...176486 )

by Julito

created 2016-12-05 14:47 UTC

SettingsManager::load() B

↳ Parent: SettingsManager

Complexity

Conditions	5
Paths	4

Size

Total Lines	44
Code Lines	18

Duplication

Lines	44
Ratio	100 %

Importance

Changes

Metric	Value
cc	5
eloc	18
nc	4
nop	3
dl	44
loc	44
rs	8.439
c	0
b	0
f	0

<?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\Model\SettingsInterface;
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
{
    protected $course;

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

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

    /**
     * {@inheritdoc}
     */
    public function load($schemaAlias, $namespace = null, $ignoreUnknown = true)
    {
        /*blog_management
        blog
        course_maintenance //maintenance
        course_setting settings*/


        $schemaAlias = 'chamilo_course.settings.'.$schemaAlias;

        /** @var SchemaInterface $schema */
        $schema = $this->schemaRegistry->get($schemaAlias);

        /** @var SettingsResolverInterface $resolver */
        $resolver = $this->resolverRegistry->get($schemaAlias);

        // try to resolve settings for schema alias and namespace
        $settings = $resolver->resolve($schemaAlias, $namespace);

        if (!$settings) {
            $settings = $this->settingsFactory->createNew();
            $settings->setSchemaAlias($schemaAlias);
        }

         // We need to get a plain parameters array since we use the options resolver on it
        $parameters = $settings->getParameters();

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

        // Remove unknown settings' parameters (e.g. From a previous version of the settings schema)
        if (true === $ignoreUnknown) {
            foreach ($parameters as $name => $value) {
                if (!$settingsBuilder->isDefined($name)) {
                    unset($parameters[$name]);
                }
            }
        }

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

        return $settings;
    }

    /**
     * {@inheritdoc}
     */
    public function save(SettingsInterface $settings)
    {
        $namespace = $settings->getSchemaAlias();

        /** @var SchemaInterface $schema */
        $schema = $this->schemaRegistry->get($settings->getSchemaAlias());

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

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

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

        /*if (isset($this->resolvedSettings[$namespace])) {
            $transformedParameters = $this->transformParameters($settingsBuilder, $parameters);
            $this->resolvedSettings[$namespace]->setParameters($transformedParameters);
        }*/

        $repo = $this->manager->getRepository('ChamiloCoreBundle:SettingsCurrent');
        $persistedParameters = $repo->findBy(array('category' => $settings->getSchemaAlias()));
        $persistedParametersMap = array();

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

        /** @var SettingsEvent $event */
        /*$event = $this->eventDispatcher->dispatch(
            SettingsEvent::PRE_SAVE,
            new SettingsEvent($settings, $parameters)
        );*/

        /** @var \Chamilo\CoreBundle\Entity\SettingsCurrent $url */
        //$url = $event->getArgument('url');
        $url = $this->getUrl();

        $simpleCategoryName = str_replace('chamilo_course.settings.', '', $namespace);

        foreach ($parameters as $name => $value) {
            if (isset($persistedParametersMap[$name])) {
                $persistedParametersMap[$name]->setValue($value);
            } else {
                $parameter = new CCourseSetting();
                $parameter
                    ->setTitle($name)
                    ->setVariable($name)
                    ->setCategory($namespace)
                    ->setValue($value)
                    ->setCId($this->getCourse()->getId())
                ;

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

        $this->manager->flush();

        return;

        $schema = $this->schemaRegistry->getSchema($namespace);
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}

        $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)

    {
        $repo = $this->manager->getRepository('ChamiloCourseBundle:CCourseSetting');
        $parameters = [];
        foreach ($repo->findBy(array('category' => $namespace)) as $parameter) {
            $parameters[$parameter->getName()] = $parameter->getValue();
        }
    }
}


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\Model\SettingsInterface;
10		use Sylius\Bundle\SettingsBundle\Schema\SchemaRegistryInterface;
11		use Sylius\Bundle\SettingsBundle\Schema\SettingsBuilder;
12		use Sylius\Component\Resource\Repository\RepositoryInterface;
13		use Symfony\Component\Validator\ConstraintViolationListInterface;
14		use Symfony\Component\Validator\Exception\ValidatorException;
15		use Symfony\Component\Validator\ValidatorInterface;
16		use Chamilo\SettingsBundle\Manager\SettingsManager as ChamiloSettingsManager;
17		use Chamilo\CourseBundle\Entity\CCourseSetting;
18		use Chamilo\CoreBundle\Entity\Course;
19		use Sylius\Bundle\SettingsBundle\Manager\SettingsManagerInterface;
20		use Symfony\Component\EventDispatcher\EventDispatcherInterface;
21
22		/**
23		* Class SettingsManager
24		* Course settings manager.
25		* @package Chamilo\CourseBundle\Manager
26		*/
27		class SettingsManager extends ChamiloSettingsManager
28		{
29		protected $course;
30
31		/**
32		* @return Course
33		*/
34		public function getCourse()
35		{
36		return $this->course;
37		}
38
39		/**
40		* @param Course $course
41		*/
42		public function setCourse(Course $course)
43		{
44		$this->course = $course;
45		}
46
47		/**
48		* {@inheritdoc}
49		*/
50	View Code Duplication	public function load($schemaAlias, $namespace = null, $ignoreUnknown = true)
51		{
52		/*blog_management
53		blog
54		course_maintenance //maintenance
55		course_setting settings*/
56
57
58		$schemaAlias = 'chamilo_course.settings.'.$schemaAlias;
59
60		/** @var SchemaInterface $schema */
61		$schema = $this->schemaRegistry->get($schemaAlias);
62
63		/** @var SettingsResolverInterface $resolver */
64		$resolver = $this->resolverRegistry->get($schemaAlias);
65
66		// try to resolve settings for schema alias and namespace
67		$settings = $resolver->resolve($schemaAlias, $namespace);
68
69		if (!$settings) {
70		$settings = $this->settingsFactory->createNew();
71		$settings->setSchemaAlias($schemaAlias);
72		}
73
74		// We need to get a plain parameters array since we use the options resolver on it
75		$parameters = $settings->getParameters();
76
77		$settingsBuilder = new SettingsBuilder();
78		$schema->buildSettings($settingsBuilder);
79
80		// Remove unknown settings' parameters (e.g. From a previous version of the settings schema)
81		if (true === $ignoreUnknown) {
82		foreach ($parameters as $name => $value) {
83		if (!$settingsBuilder->isDefined($name)) {
84		unset($parameters[$name]);
85		}
86		}
87		}
88
89		$parameters = $settingsBuilder->resolve($parameters);
90		$settings->setParameters($parameters);
91
92		return $settings;
93		}
94
95		/**
96		* {@inheritdoc}
97		*/
98		public function save(SettingsInterface $settings)
99		{
100		$namespace = $settings->getSchemaAlias();
101
102		/** @var SchemaInterface $schema */
103		$schema = $this->schemaRegistry->get($settings->getSchemaAlias());
104
105		$settingsBuilder = new SettingsBuilder();
106		$schema->buildSettings($settingsBuilder);
107
108		$parameters = $settingsBuilder->resolve($settings->getParameters());
109		$settings->setParameters($parameters);
110
111		/*foreach ($settingsBuilder->getTransformers() as $parameter => $transformer) {
112		if (array_key_exists($parameter, $parameters)) {
113		$parameters[$parameter] = $transformer->transform($parameters[$parameter]);
114		}
115		}*/
116
117		/*if (isset($this->resolvedSettings[$namespace])) {
118		$transformedParameters = $this->transformParameters($settingsBuilder, $parameters);
119		$this->resolvedSettings[$namespace]->setParameters($transformedParameters);
120		}*/
121
122		$repo = $this->manager->getRepository('ChamiloCoreBundle:SettingsCurrent');
123		$persistedParameters = $repo->findBy(array('category' => $settings->getSchemaAlias()));
124		$persistedParametersMap = array();
125
126		foreach ($persistedParameters as $parameter) {
127		$persistedParametersMap[$parameter->getTitle()] = $parameter;
128		}
129
130		/** @var SettingsEvent $event */
131		/*$event = $this->eventDispatcher->dispatch(
132		SettingsEvent::PRE_SAVE,
133		new SettingsEvent($settings, $parameters)
134		);*/
135
136		/** @var \Chamilo\CoreBundle\Entity\SettingsCurrent $url */
137		//$url = $event->getArgument('url');
138		$url = $this->getUrl();
139
140		$simpleCategoryName = str_replace('chamilo_course.settings.', '', $namespace);
141
142	View Code Duplication	foreach ($parameters as $name => $value) {
143		if (isset($persistedParametersMap[$name])) {
144		$persistedParametersMap[$name]->setValue($value);
145		} else {
146		$parameter = new CCourseSetting();
147		$parameter
148		->setTitle($name)
149		->setVariable($name)
150		->setCategory($namespace)
151		->setValue($value)
152		->setCId($this->getCourse()->getId())
153		;
154
155		$this->manager->persist($parameter);
156		}
157		}
158
159		$this->manager->flush();
160
161		return;
162
163		$schema = $this->schemaRegistry->getSchema($namespace);
		0 ignored issues – show Unused Code introduced 2016-12-05 15:22 UTC by Report Bug Copy Issue Report `$schema = $this->schemaR...>getSchema($namespace);` does not seem to be reachable. This check looks for unreachable code. It uses sophisticated control flow analysis techniques to find statements which will never be executed. Unreachable code is most often the result of `return`, `die` or `exit` statements that have been added for debug purposes. function fx() { try { doSomething(); return true; } catch (\Exception $e) { return false; } return false; } In the above example, the last `return false` will never be executed, because a return statement has already been met in every possible execution path. Loading history...
164
165		$settingsBuilder = new SettingsBuilder();
166		$schema->buildSettings($settingsBuilder);
167
168		$parameters = $settingsBuilder->resolve($settings->getParameters());
169
170	View Code Duplication	foreach ($settingsBuilder->getTransformers() as $parameter => $transformer) {
171		if (array_key_exists($parameter, $parameters)) {
172		$parameters[$parameter] = $transformer->transform($parameters[$parameter]);
173		}
174		}
175
176		if (isset($this->resolvedSettings[$namespace])) {
177		$this->resolvedSettings[$namespace]->setParameters($parameters);
178		}
179
180		$persistedParameters = $this->parameterRepository->findBy(
181		array('category' => $namespace, 'cId' => $this->getCourse()->getId())
182		);
183
184		$persistedParametersMap = array();
185
186		foreach ($persistedParameters as $parameter) {
187		$persistedParametersMap[$parameter->getName()] = $parameter;
188		}
189
190		foreach ($parameters as $name => $value) {
191		if (isset($persistedParametersMap[$name])) {
192		$persistedParametersMap[$name]->setValue($value);
193		} else {
194		/** @var CCourseSetting $parameter */
195		//$parameter = $this->parameterFactory->createNew();
196		$parameter = new CCourseSetting();
197		$parameter
198		->setNamespace($namespace)
199		->setName($name)
200		->setValue($value)
201		->setCId($this->getCourse()->getId())
202		;
203
204		/* @var $errors ConstraintViolationListInterface */
205		$errors = $this->validator->validate($parameter);
206		if (0 < $errors->count()) {
207		throw new ValidatorException($errors->get(0)->getMessage());
208		}
209
210		$this->parameterManager->persist($parameter);
211		}
212		}
213
214		$this->parameterManager->flush();
215
216		$this->cache->save($namespace, $parameters);
217		}
218
219		/**
220		* Load parameter from database.
221		*
222		* @param string $namespace
223		*
224		* @return array
225		*/
226	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...
227		{
228		$repo = $this->manager->getRepository('ChamiloCourseBundle:CCourseSetting');
229		$parameters = [];
230		foreach ($repo->findBy(array('category' => $namespace)) as $parameter) {
231		$parameters[$parameter->getName()] = $parameter->getValue();
232		}
233		}
234		}
235

chamilo / chamilo-lms

Push — master ( f7178d...176486 )

SettingsManager::load() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like