SettingsManager::load() - Code Metrics - Inspection of "Fix tool chain assignation + setting SettingManage..." - chamilo/chamilo-lms - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a12db9...82664b )

by Julito

created 2016-11-21 14:40 UTC

SettingsManager::load() B

↳ Parent: SettingsManager

Complexity

Conditions	6
Paths	3

Size

Total Lines	90
Code Lines	26

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	6
eloc	26
nc	3
nop	3
dl	0
loc	90
rs	8.2713
c	0
b	0
f	0

How to fix Long Method

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

namespace Chamilo\SettingsBundle\Manager;

use Chamilo\CoreBundle\Entity\AccessUrl;
use Chamilo\CoreBundle\Entity\Course;
use Chamilo\CoreBundle\Settings\PlatformSettingsSchema;
use Sylius\Bundle\ResourceBundle\Controller\EventDispatcherInterface;
use Sylius\Bundle\SettingsBundle\Event\SettingsEvent;
use Doctrine\Common\Cache\Cache;
use Doctrine\Common\Persistence\ObjectManager;
use Sylius\Bundle\SettingsBundle\Manager\SettingsManagerInterface;
use Sylius\Bundle\SettingsBundle\Model\Settings;
use Sylius\Bundle\SettingsBundle\Model\SettingsInterface;
use Sylius\Bundle\SettingsBundle\Schema\SchemaInterface;
use Sylius\Bundle\SettingsBundle\Schema\SchemaRegistryInterface;
use Sylius\Bundle\SettingsBundle\Schema\SettingsBuilder;
use Sylius\Component\Registry\ServiceRegistryInterface;
use Sylius\Component\Resource\Factory\FactoryInterface;
use Sylius\Component\Resource\Repository\RepositoryInterface;
use Symfony\Component\Validator\ConstraintViolationListInterface;
use Symfony\Component\Validator\Exception\ValidatorException;
use Symfony\Component\Validator\ValidatorInterface;
use Sylius\Bundle\SettingsBundle\Manager\SettingsManager as SyliusSettingsManager;
use Chamilo\CoreBundle\Entity\SettingsCurrent;

/**
 * Class SettingsManager
 * @package Chamilo\SettingsBundle\Manager
 */
class SettingsManager implements SettingsManagerInterface
{
    private $url;

    /**
     * @var ServiceRegistryInterface
     */
    private $schemaRegistry;

    /**
     * @var ObjectManager
     */
    private $manager;

    /**
     * @var FactoryInterface
     */
    private $settingsFactory;

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

    /**
     * Runtime cache for resolved parameters
     *
     * @var Settings[]
     */
    protected $resolvedSettings = array();

    public function __construct(
        ServiceRegistryInterface $schemaRegistry,
        ServiceRegistryInterface $parameterManager,
        ObjectManager $parameterRepository,
        FactoryInterface $cache,
        $eventDispatcher
    ) {
        $this->schemaRegistry = $schemaRegistry;
        $this->parameterManager = $parameterManager;
        $this->parameterRepository = $parameterRepository;
        $this->eventDispatcher = $eventDispatcher;
    }

    /**
     * @return AccessUrl
     */
    public function getUrl()
    {
        return $this->url;
    }

    /**
     * @param AccessUrl $url
     */
    public function setUrl(AccessUrl $url)
    {
        $this->url = $url;
    }

    /**
     * @param AccessUrl $url
     */
    public function installSchemas(AccessUrl $url)
    {
        $this->url = $url;
        $schemas = $this->getSchemas();
        $schemas = array_keys($schemas);

        /**
         * @var string $key
         * @var \Sylius\Bundle\SettingsBundle\Schema\SchemaInterface $schema
         */
        foreach ($schemas as $schema) {

            $settings = $this->load($schema);
            $this->save($schema, $settings);
        }
    }

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

    /**
     * @param $name
     * @return mixed
     * @throws \InvalidArgumentException
     */
    public function getSetting($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->load($this->convertNameSpaceToService($namespace));

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

    public function convertNameSpaceToService($namespace)
    {
        //return 'chamilo_core.settings.'.$namespace;
        return ''.$namespace;
    }

    /**
     * {@inheritdoc}
     */
    public function load($namespace, $namespace2 = null, $ignoreUnknown = true)
    {
        /*$schema = $this->schemaRegistry->get($schemaAlias);
        $resolver = $this->resolverRegistry->get($schemaAlias);

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

dump($settings);

        $parameters = $this->getParameters($namespace);

        $schema = $this->schemaRegistry->get($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);*/

        /*$schema = $this->schemaRegistry->get($schemaAlias);
        $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);
        }*/

        //$schemaAlias = 'chamilo_core.settings.'.$schemaAlias;


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

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

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

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

        $parameters = $this->transformParameters($settingsBuilder, $parameters);
        $parameters = $settingsBuilder->resolve($parameters);

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



        $settings = $this->settingsFactory->createNew();
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
        $settings->setSchemaAlias($schemaAlias);

        $parameters = $this->getParameters($schemaAlias);

        /** @var SchemaInterface $schema */
        $schema = $this->schemaRegistry->get($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}
     * @throws ValidatorException
     */
    //public function save($namespace, $settings)
    public function save(SettingsInterface $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])) {
            $transformedParameters = $this->transformParameters($settingsBuilder, $parameters);
            $this->resolvedSettings[$namespace]->setParameters($transformedParameters);
        }

        $persistedParameters = $this->parameterRepository->findBy(array('category' => $namespace));
        $persistedParametersMap = array();

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

        /** @var SettingsEvent $event */
        $event = $this->eventDispatcher->dispatch(

            SettingsEvent::PRE_SAVE,
            new SettingsEvent($namespace, $settings, $parameters)
        );

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

        foreach ($parameters as $name => $value) {
            if (isset($persistedParametersMap[$name])) {
                $persistedParametersMap[$name]->setValue($value);
            } else {
                $parameter = $this->parameterRepository->createNew();

                $parameter
                    ->setNamespace($namespace)
                    ->setName($name)
                    ->setValue($value)
                    ->setUrl($url)
                    ->setAccessUrlChangeable(1)
                    ->setAccessUrlLocked(1)
                ;

                /* @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->eventDispatcher->dispatch(SettingsEvent::POST_SAVE, new SettingsEvent($namespace, $settings, $parameters));


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



        return;







        ////
        $schemaAlias = $settings->getSchemaAlias();
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
        $schemaAliasChamilo = str_replace('chamilo_core.settings.', '', $schemaAlias);

        $schema = $this->schemaRegistry->get($schemaAlias);

        $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]);
            }
        }

        /** @var \Sylius\Bundle\SettingsBundle\Event\SettingsEvent $event */
        $event = $this->eventDispatcher->dispatch(

            SettingsEvent::PRE_SAVE,
            new SettingsEvent($settings)
        );

        /** @var \Chamilo\CoreBundle\Entity\SettingsCurrent $url */
        $url = $event->getSettings()->getAccessUrl();

        foreach ($parameters as $name => $value) {
            if (isset($persistedParametersMap[$name])) {
                if ($value instanceof Course) {
                    $value = $value->getId();
                }
                $persistedParametersMap[$name]->setValue($value);
            } else {
                /** @var SettingsCurrent $setting */
                $setting = $this->settingsFactory->createNew();
                $setting->setSchemaAlias($schemaAlias);

                $setting
                    ->setNamespace($schemaAliasChamilo)
                    ->setName($name)
                    ->setValue($value)
                    ->setUrl($url)
                    ->setAccessUrlLocked(0)
                    ->setAccessUrlChangeable(1)
                ;


                /* @var $errors ConstraintViolationListInterface */
                /*$errors = $this->->validate($parameter);
                if (0 < $errors->count()) {
                    throw new ValidatorException($errors->get(0)->getMessage());
                }*/
                $this->manager->persist($setting);
                $this->manager->flush();
            }
        }
        /*$parameters = $settingsBuilder->resolve($settings->getParameters());
        $settings->setParameters($parameters);

        $this->eventDispatcher->dispatch(SettingsEvent::PRE_SAVE, new SettingsEvent($settings));

        $this->manager->persist($settings);
        $this->manager->flush();

        $this->eventDispatcher->dispatch(SettingsEvent::POST_SAVE, new SettingsEvent($settings));*/
    }

    /**
     * Load parameter from database.
     *
     * @param string $namespace
     *
     * @return array
     */
    private function getParameters($namespace)
    {
        $repo = $this->parameterRepository;
        //$repo = $this->manager->getRepository('ChamiloCoreBundle:SettingsCurrent');
        $parameters = [];
        foreach ($repo->findBy(array('category' => $namespace)) as $parameter) {
            $parameters[$parameter->getName()] = $parameter->getValue();
        }

        return $parameters;
    }

    public function getParametersFromKeyword($namespace, $keyword = '')
    {
        $criteria = array('category' => $namespace);
        if (!empty($keyword)) {
            $criteria['variable'] = $keyword;
        }

        $parametersFromDb = $this->parameterRepository->findBy($criteria);

        $parameters = array();
        /** @var \Chamilo\CoreBundle\Entity\SettingsCurrent $parameter */
        foreach ($parametersFromDb as $parameter) {
            $parameters[$parameter->getName()] = $parameter->getValue();
        }

        return $parameters;
    }

    private function transformParameters(SettingsBuilder $settingsBuilder, array $parameters)
    {
        $transformedParameters = $parameters;

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

        return $transformedParameters;
    }
}


1		<?php
2		/* For licensing terms, see /license.txt */
3
4		namespace Chamilo\SettingsBundle\Manager;
5
6		use Chamilo\CoreBundle\Entity\AccessUrl;
7		use Chamilo\CoreBundle\Entity\Course;
8		use Chamilo\CoreBundle\Settings\PlatformSettingsSchema;
9		use Sylius\Bundle\ResourceBundle\Controller\EventDispatcherInterface;
10		use Sylius\Bundle\SettingsBundle\Event\SettingsEvent;
11		use Doctrine\Common\Cache\Cache;
12		use Doctrine\Common\Persistence\ObjectManager;
13		use Sylius\Bundle\SettingsBundle\Manager\SettingsManagerInterface;
14		use Sylius\Bundle\SettingsBundle\Model\Settings;
15		use Sylius\Bundle\SettingsBundle\Model\SettingsInterface;
16		use Sylius\Bundle\SettingsBundle\Schema\SchemaInterface;
17		use Sylius\Bundle\SettingsBundle\Schema\SchemaRegistryInterface;
18		use Sylius\Bundle\SettingsBundle\Schema\SettingsBuilder;
19		use Sylius\Component\Registry\ServiceRegistryInterface;
20		use Sylius\Component\Resource\Factory\FactoryInterface;
21		use Sylius\Component\Resource\Repository\RepositoryInterface;
22		use Symfony\Component\Validator\ConstraintViolationListInterface;
23		use Symfony\Component\Validator\Exception\ValidatorException;
24		use Symfony\Component\Validator\ValidatorInterface;
25		use Sylius\Bundle\SettingsBundle\Manager\SettingsManager as SyliusSettingsManager;
26		use Chamilo\CoreBundle\Entity\SettingsCurrent;
27
28		/**
29		* Class SettingsManager
30		* @package Chamilo\SettingsBundle\Manager
31		*/
32		class SettingsManager implements SettingsManagerInterface
33		{
34		private $url;
35
36		/**
37		* @var ServiceRegistryInterface
38		*/
39		private $schemaRegistry;
40
41		/**
42		* @var ObjectManager
43		*/
44		private $manager;
45
46		/**
47		* @var FactoryInterface
48		*/
49		private $settingsFactory;
50
51		/**
52		* @var EventDispatcherInterface
53		*/
54		private $eventDispatcher;
55
56		/**
57		* Runtime cache for resolved parameters
58		*
59		* @var Settings[]
60		*/
61		protected $resolvedSettings = array();
62
63		public function __construct(
64		ServiceRegistryInterface $schemaRegistry,
65		ServiceRegistryInterface $parameterManager,
66		ObjectManager $parameterRepository,
67		FactoryInterface $cache,
68		$eventDispatcher
69		) {
70		$this->schemaRegistry = $schemaRegistry;
71		$this->parameterManager = $parameterManager;
72		$this->parameterRepository = $parameterRepository;
73		$this->eventDispatcher = $eventDispatcher;
74		}
75
76		/**
77		* @return AccessUrl
78		*/
79		public function getUrl()
80		{
81		return $this->url;
82		}
83
84		/**
85		* @param AccessUrl $url
86		*/
87		public function setUrl(AccessUrl $url)
88		{
89		$this->url = $url;
90		}
91
92		/**
93		* @param AccessUrl $url
94		*/
95		public function installSchemas(AccessUrl $url)
96		{
97		$this->url = $url;
98		$schemas = $this->getSchemas();
99		$schemas = array_keys($schemas);
100
101		/**
102		* @var string $key
103		* @var \Sylius\Bundle\SettingsBundle\Schema\SchemaInterface $schema
104		*/
105		foreach ($schemas as $schema) {
106
107		$settings = $this->load($schema);
108		$this->save($schema, $settings);
109		}
110		}
111
112		/**
113		* @return array
114		*/
115		public function getSchemas()
116		{
117		return $this->schemaRegistry->getSchemas();
118		}
119
120		/**
121		* @param $name
122		* @return mixed
123		* @throws \InvalidArgumentException
124		*/
125		public function getSetting($name)
126		{
127		if (false === strpos($name, '.')) {
128		throw new \InvalidArgumentException(sprintf('Parameter must be in format "namespace.name", "%s" given.', $name));
129		}
130
131		list($namespace, $name) = explode('.', $name);
132		$settings = $this->load($this->convertNameSpaceToService($namespace));
133
134		return $settings->get($name);
135		}
136
137		public function convertNameSpaceToService($namespace)
138		{
139		//return 'chamilo_core.settings.'.$namespace;
140		return ''.$namespace;
141		}
142
143		/**
144		* {@inheritdoc}
145		*/
146		public function load($namespace, $namespace2 = null, $ignoreUnknown = true)
147		{
148		/*$schema = $this->schemaRegistry->get($schemaAlias);
149		$resolver = $this->resolverRegistry->get($schemaAlias);
150
151		// try to resolve settings for schema alias and namespace
152		$settings = $resolver->resolve($schemaAlias, $namespace);
153
154		dump($settings);
155
156		$parameters = $this->getParameters($namespace);
157
158		$schema = $this->schemaRegistry->get($namespace);
159
160		$settingsBuilder = new SettingsBuilder();
161		$schema->buildSettings($settingsBuilder);
162
163		foreach ($settingsBuilder->getTransformers() as $parameter => $transformer) {
164		if (array_key_exists($parameter, $parameters)) {
165		$parameters[$parameter] = $transformer->reverseTransform($parameters[$parameter]);
166		}
167		}
168		$parameters = $settingsBuilder->resolve($parameters);
169
170		return $this->resolvedSettings[$namespace] = new Settings($parameters);*/
171
172		/*$schema = $this->schemaRegistry->get($schemaAlias);
173		$resolver = $this->resolverRegistry->get($schemaAlias);
174
175		// try to resolve settings for schema alias and namespace
176		$settings = $resolver->resolve($schemaAlias, $namespace);
177
178		if (!$settings) {
179		$settings = $this->settingsFactory->createNew();
180		$settings->setSchemaAlias($schemaAlias);
181		}*/
182
183		//$schemaAlias = 'chamilo_core.settings.'.$schemaAlias;
184
185
186		if (isset($this->resolvedSettings[$namespace])) {
187		return $this->resolvedSettings[$namespace];
188		}
189
190		if ($this->cache->contains($namespace)) {
191		$parameters = $this->cache->fetch($namespace);
192		} else {
193		$parameters = $this->getParameters($namespace);
194		}
195
196		$schema = $this->schemaRegistry->getSchema($namespace);
197
198		$settingsBuilder = new SettingsBuilder();
199		$schema->buildSettings($settingsBuilder);
200
201		$parameters = $this->transformParameters($settingsBuilder, $parameters);
202		$parameters = $settingsBuilder->resolve($parameters);
203
204		return $this->resolvedSettings[$namespace] = new Settings($parameters);
205
206
207
208		$settings = $this->settingsFactory->createNew();
		0 ignored issues – show Unused Code introduced 2016-08-01 12:40 UTC by Report Bug Copy Issue Report `$settings = $this->settingsFactory->createNew();` 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...
209		$settings->setSchemaAlias($schemaAlias);
210
211		$parameters = $this->getParameters($schemaAlias);
212
213		/** @var SchemaInterface $schema */
214		$schema = $this->schemaRegistry->get($schemaAlias);
215
216		// We need to get a plain parameters array since we use the options resolver on it
217		//$parameters = $settings->getParameters();
218
219		$settingsBuilder = new SettingsBuilder();
220		$schema->buildSettings($settingsBuilder);
221
222		// Remove unknown settings' parameters (e.g. From a previous version of the settings schema)
223		if (true === $ignoreUnknown) {
224		foreach ($parameters as $name => $value) {
225		if (!$settingsBuilder->isDefined($name)) {
226		unset($parameters[$name]);
227		}
228		}
229		}
230
231		$parameters = $settingsBuilder->resolve($parameters);
232		$settings->setParameters($parameters);
233
234		return $settings;
235		}
236
237		/**
238		* {@inheritdoc}
239		* @throws ValidatorException
240		*/
241		//public function save($namespace, $settings)
242		public function save(SettingsInterface $settings)
243		{
244		$schema = $this->schemaRegistry->getSchema($namespace);
		0 ignored issues – show Bug introduced 2016-11-21 16:06 UTC by Report Bug Copy Issue Report The variable `$namespace` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
245
246		$settingsBuilder = new SettingsBuilder();
247		$schema->buildSettings($settingsBuilder);
248
249		$parameters = $settingsBuilder->resolve($settings->getParameters());
250
251	View Code Duplication	foreach ($settingsBuilder->getTransformers() as $parameter => $transformer) {
252		if (array_key_exists($parameter, $parameters)) {
253		$parameters[$parameter] = $transformer->transform($parameters[$parameter]);
254		}
255		}
256
257		if (isset($this->resolvedSettings[$namespace])) {
258		$transformedParameters = $this->transformParameters($settingsBuilder, $parameters);
259		$this->resolvedSettings[$namespace]->setParameters($transformedParameters);
260		}
261
262		$persistedParameters = $this->parameterRepository->findBy(array('category' => $namespace));
263		$persistedParametersMap = array();
264
265		foreach ($persistedParameters as $parameter) {
266		$persistedParametersMap[$parameter->getName()] = $parameter;
267		}
268
269		/** @var SettingsEvent $event */
270		$event = $this->eventDispatcher->dispatch(
		0 ignored issues – show Bug introduced 2016-11-21 16:06 UTC by Report Bug Copy Issue Report The call to `dispatch()` misses a required argument `$resource`. This check looks for function calls that miss required arguments. Loading history...
271		SettingsEvent::PRE_SAVE,
272		new SettingsEvent($namespace, $settings, $parameters)
273		);
274
275		/** @var \Chamilo\CoreBundle\Entity\SettingsCurrent $url */
276		$url = $event->getArgument('url');
277
278		foreach ($parameters as $name => $value) {
279		if (isset($persistedParametersMap[$name])) {
280		$persistedParametersMap[$name]->setValue($value);
281		} else {
282		$parameter = $this->parameterRepository->createNew();
283
284		$parameter
285		->setNamespace($namespace)
286		->setName($name)
287		->setValue($value)
288		->setUrl($url)
289		->setAccessUrlChangeable(1)
290		->setAccessUrlLocked(1)
291		;
292
293		/* @var $errors ConstraintViolationListInterface */
294		$errors = $this->validator->validate($parameter);
295		if (0 < $errors->count()) {
296		throw new ValidatorException($errors->get(0)->getMessage());
297		}
298
299		$this->parameterManager->persist($parameter);
300		}
301		}
302
303		$this->parameterManager->flush();
304
305		$this->eventDispatcher->dispatch(SettingsEvent::POST_SAVE, new SettingsEvent($namespace, $settings, $parameters));
		0 ignored issues – show Bug introduced 2016-11-21 16:06 UTC by Report Bug Copy Issue Report The call to `dispatch()` misses a required argument `$resource`. This check looks for function calls that miss required arguments. Loading history...
306
307		$this->cache->save($namespace, $parameters);
308
309
310
311		return;
312
313
314
315
316
317
318
319		////
320		$schemaAlias = $settings->getSchemaAlias();
		0 ignored issues – show Unused Code introduced 2016-08-01 12:40 UTC by Report Bug Copy Issue Report `//// $schemaAlias = $settings->getSchemaAlias();` 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...
321		$schemaAliasChamilo = str_replace('chamilo_core.settings.', '', $schemaAlias);
322
323		$schema = $this->schemaRegistry->get($schemaAlias);
324
325		$settingsBuilder = new SettingsBuilder();
326		$schema->buildSettings($settingsBuilder);
327
328		$parameters = $settingsBuilder->resolve($settings->getParameters());
329
330	View Code Duplication	foreach ($settingsBuilder->getTransformers() as $parameter => $transformer) {
331		if (array_key_exists($parameter, $parameters)) {
332		$parameters[$parameter] = $transformer->transform($parameters[$parameter]);
333		}
334		}
335
336		/** @var \Sylius\Bundle\SettingsBundle\Event\SettingsEvent $event */
337		$event = $this->eventDispatcher->dispatch(
		0 ignored issues – show Bug introduced 2016-11-21 16:06 UTC by Report Bug Copy Issue Report The call to `dispatch()` misses a required argument `$resource`. This check looks for function calls that miss required arguments. Loading history...
338		SettingsEvent::PRE_SAVE,
339		new SettingsEvent($settings)
340		);
341
342		/** @var \Chamilo\CoreBundle\Entity\SettingsCurrent $url */
343		$url = $event->getSettings()->getAccessUrl();
344
345		foreach ($parameters as $name => $value) {
346		if (isset($persistedParametersMap[$name])) {
347		if ($value instanceof Course) {
348		$value = $value->getId();
349		}
350		$persistedParametersMap[$name]->setValue($value);
351		} else {
352		/** @var SettingsCurrent $setting */
353		$setting = $this->settingsFactory->createNew();
354		$setting->setSchemaAlias($schemaAlias);
355
356		$setting
357		->setNamespace($schemaAliasChamilo)
358		->setName($name)
359		->setValue($value)
360		->setUrl($url)
361		->setAccessUrlLocked(0)
362		->setAccessUrlChangeable(1)
363		;
364
365
366		/* @var $errors ConstraintViolationListInterface */
367		/*$errors = $this->->validate($parameter);
368		if (0 < $errors->count()) {
369		throw new ValidatorException($errors->get(0)->getMessage());
370		}*/
371		$this->manager->persist($setting);
372		$this->manager->flush();
373		}
374		}
375		/*$parameters = $settingsBuilder->resolve($settings->getParameters());
376		$settings->setParameters($parameters);
377
378		$this->eventDispatcher->dispatch(SettingsEvent::PRE_SAVE, new SettingsEvent($settings));
379
380		$this->manager->persist($settings);
381		$this->manager->flush();
382
383		$this->eventDispatcher->dispatch(SettingsEvent::POST_SAVE, new SettingsEvent($settings));*/
384		}
385
386		/**
387		* Load parameter from database.
388		*
389		* @param string $namespace
390		*
391		* @return array
392		*/
393		private function getParameters($namespace)
394		{
395		$repo = $this->parameterRepository;
396		//$repo = $this->manager->getRepository('ChamiloCoreBundle:SettingsCurrent');
397		$parameters = [];
398		foreach ($repo->findBy(array('category' => $namespace)) as $parameter) {
399		$parameters[$parameter->getName()] = $parameter->getValue();
400		}
401
402		return $parameters;
403		}
404
405		public function getParametersFromKeyword($namespace, $keyword = '')
406		{
407		$criteria = array('category' => $namespace);
408		if (!empty($keyword)) {
409		$criteria['variable'] = $keyword;
410		}
411
412		$parametersFromDb = $this->parameterRepository->findBy($criteria);
413
414		$parameters = array();
415		/** @var \Chamilo\CoreBundle\Entity\SettingsCurrent $parameter */
416		foreach ($parametersFromDb as $parameter) {
417		$parameters[$parameter->getName()] = $parameter->getValue();
418		}
419
420		return $parameters;
421		}
422
423		private function transformParameters(SettingsBuilder $settingsBuilder, array $parameters)
424		{
425		$transformedParameters = $parameters;
426
427	View Code Duplication	foreach ($settingsBuilder->getTransformers() as $parameter => $transformer) {
428		if (array_key_exists($parameter, $parameters)) {
429		$transformedParameters[$parameter] = $transformer->reverseTransform($parameters[$parameter]);
430		}
431		}
432
433		return $transformedParameters;
434		}
435		}
436

chamilo / chamilo-lms

Push — master ( a12db9...82664b )

SettingsManager::load() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like