SettingsManager::getCourse() - Code Metrics - Inspection of "Update phpstan config" - chamilo/chamilo-lms - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( b5ff3f...de0fbe )

by Julito

created 2021-02-22 12:43 UTC

SettingsManager::getCourse() A

↳ Parent: SettingsManager

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
rs	10
c	0
b	0
f	0

<?php

/* For licensing terms, see /license.txt */

namespace Chamilo\CourseBundle\Manager;

use Chamilo\CoreBundle\Entity\Course;
use Chamilo\CoreBundle\Entity\SettingsCurrent;
use Chamilo\CoreBundle\Settings\SettingsManager as ChamiloSettingsManager;
use Chamilo\CourseBundle\Entity\CCourseSetting;
use Sylius\Bundle\SettingsBundle\Model\Settings;
use Sylius\Bundle\SettingsBundle\Model\SettingsInterface;
use Sylius\Bundle\SettingsBundle\Schema\SchemaInterface;
use Sylius\Bundle\SettingsBundle\Schema\SettingsBuilder;
use Symfony\Component\Validator\ConstraintViolationListInterface;
use Symfony\Component\Validator\Exception\ValidatorException;

/**
 * Class SettingsManager
 * Course settings manager.
 */
class SettingsManager extends ChamiloSettingsManager
{
    protected $course;

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

    public function setCourse(Course $course)
    {
        $this->course = $course;
    }

    public function load($schemaAlias, $namespace = null, $ignoreUnknown = true)
    {
        $settings = new Settings();
        $schemaAliasNoPrefix = $schemaAlias;
        $schemaAlias = 'chamilo_course.settings.'.$schemaAlias;
        if ($this->schemaRegistry->has($schemaAlias)) {
            /** @var SchemaInterface $schema */
            $schema = $this->schemaRegistry->get($schemaAlias);
        } else {
            return $settings;
        }

        $settings->setSchemaAlias($schemaAlias);

        // We need to get a plain parameters array since we use the options resolver on it
        $parameters = $this->getParameters($schemaAliasNoPrefix);
        $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]);
                }
            }
        }

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

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

        return $settings;
    }

    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());

        // Transform value. Example array to string using transformer. Example:
        // 1. Setting "tool_visible_by_default_at_creation" it's a multiple select
        // 2. Is defined as an array in class DocumentSettingsSchema
        // 3. Add transformer for that variable "ArrayToIdentifierTransformer"
        // 4. Here we recover the transformer and convert the array to string
        foreach ($settingsBuilder->getTransformers() as $parameter => $transformer) {
            if (array_key_exists($parameter, $parameters)) {
                $parameters[$parameter] = $transformer->transform($parameters[$parameter]);
            }
        }

        $repo = $this->manager->getRepository(SettingsCurrent::class);
        /** @var CCourseSetting[] $persistedParameters */
        $persistedParameters = $repo->findBy(['category' => $settings->getSchemaAlias()]);

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

        $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($simpleCategoryName)
                    ->setValue($value)
                    ->setCId($this->getCourse()->getId())
                ;
                $this->manager->persist($parameter);
            }
        }

        $this->manager->flush();

        return true;

        /*$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(
            ['category' => $namespace, 'cId' => $this->getCourse()->getId()]
        );

        $persistedParametersMap = [];

        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 ConstraintViolationListInterface $errors
                $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);*/
    }

    /**
     * @param string $category
     *
     * @return string
     */
    public function convertNameSpaceToService($category)
    {
        return 'chamilo_course.settings.'.$category;
    }

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

        return $parameters;
    }
}


1			<?php
2
3			/* For licensing terms, see /license.txt */
4
5			namespace Chamilo\CourseBundle\Manager;
6
7			use Chamilo\CoreBundle\Entity\Course;
8			use Chamilo\CoreBundle\Entity\SettingsCurrent;
9			use Chamilo\CoreBundle\Settings\SettingsManager as ChamiloSettingsManager;
10			use Chamilo\CourseBundle\Entity\CCourseSetting;
11			use Sylius\Bundle\SettingsBundle\Model\Settings;
12			use Sylius\Bundle\SettingsBundle\Model\SettingsInterface;
13			use Sylius\Bundle\SettingsBundle\Schema\SchemaInterface;
14			use Sylius\Bundle\SettingsBundle\Schema\SettingsBuilder;
15			use Symfony\Component\Validator\ConstraintViolationListInterface;
16			use Symfony\Component\Validator\Exception\ValidatorException;
17
18			/**
19			* Class SettingsManager
20			* Course settings manager.
21			*/
22			class SettingsManager extends ChamiloSettingsManager
23			{
24			protected $course;
25
26			/**
27			* @return Course
28			*/
29			public function getCourse()
30			{
31			return $this->course;
32			}
33
34			public function setCourse(Course $course)
35			{
36			$this->course = $course;
37			}
38
39			public function load($schemaAlias, $namespace = null, $ignoreUnknown = true)
40			{
41			$settings = new Settings();
42			$schemaAliasNoPrefix = $schemaAlias;
43			$schemaAlias = 'chamilo_course.settings.'.$schemaAlias;
44			if ($this->schemaRegistry->has($schemaAlias)) {
45			/** @var SchemaInterface $schema */
46			$schema = $this->schemaRegistry->get($schemaAlias);
47			} else {
48			return $settings;
49			}
50
51			$settings->setSchemaAlias($schemaAlias);
52
53			// We need to get a plain parameters array since we use the options resolver on it
54			$parameters = $this->getParameters($schemaAliasNoPrefix);
55			$settingsBuilder = new SettingsBuilder();
56			$schema->buildSettings($settingsBuilder);
57
58			// Remove unknown settings' parameters (e.g. From a previous version of the settings schema)
59			if (true === $ignoreUnknown) {
60			foreach ($parameters as $name => $value) {
61			if (!$settingsBuilder->isDefined($name)) {
62			unset($parameters[$name]);
63			}
64			}
65			}
66
67			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			$settings->setParameters($parameters);
75
76			return $settings;
77			}
78
79			public function save(SettingsInterface $settings)
80			{
81			$namespace = $settings->getSchemaAlias();
82
83			/** @var SchemaInterface $schema */
84			$schema = $this->schemaRegistry->get($settings->getSchemaAlias());
85
86			$settingsBuilder = new SettingsBuilder();
87			$schema->buildSettings($settingsBuilder);
88			$parameters = $settingsBuilder->resolve($settings->getParameters());
89
90			// Transform value. Example array to string using transformer. Example:
91			// 1. Setting "tool_visible_by_default_at_creation" it's a multiple select
92			// 2. Is defined as an array in class DocumentSettingsSchema
93			// 3. Add transformer for that variable "ArrayToIdentifierTransformer"
94			// 4. Here we recover the transformer and convert the array to string
95			foreach ($settingsBuilder->getTransformers() as $parameter => $transformer) {
96			if (array_key_exists($parameter, $parameters)) {
97			$parameters[$parameter] = $transformer->transform($parameters[$parameter]);
98			}
99			}
100
101			$repo = $this->manager->getRepository(SettingsCurrent::class);
102			/** @var CCourseSetting[] $persistedParameters */
103			$persistedParameters = $repo->findBy(['category' => $settings->getSchemaAlias()]);
104
105			$persistedParametersMap = [];
106			foreach ($persistedParameters as $parameter) {
107			$persistedParametersMap[$parameter->getTitle()] = $parameter;
108			}
109
110			$simpleCategoryName = str_replace('chamilo_course.settings.', '', $namespace);
111			foreach ($parameters as $name => $value) {
112			if (isset($persistedParametersMap[$name])) {
113			$persistedParametersMap[$name]->setValue($value);
114			} else {
115			$parameter = new CCourseSetting();
116			$parameter
117			->setTitle($name)
118			->setVariable($name)
119			->setCategory($simpleCategoryName)
120			->setValue($value)
121			->setCId($this->getCourse()->getId())
122			;
123			$this->manager->persist($parameter);
124			}
125			}
126
127			$this->manager->flush();
128
129			return true;
130
131			/*$schema = $this->schemaRegistry->getSchema($namespace);
132
133			$settingsBuilder = new SettingsBuilder();
134			$schema->buildSettings($settingsBuilder);
135
136			$parameters = $settingsBuilder->resolve($settings->getParameters());
137
138			foreach ($settingsBuilder->getTransformers() as $parameter => $transformer) {
139			if (array_key_exists($parameter, $parameters)) {
140			$parameters[$parameter] = $transformer->transform($parameters[$parameter]);
141			}
142			}
143
144			if (isset($this->resolvedSettings[$namespace])) {
145			$this->resolvedSettings[$namespace]->setParameters($parameters);
146			}
147
148			$persistedParameters = $this->parameterRepository->findBy(
149			['category' => $namespace, 'cId' => $this->getCourse()->getId()]
150			);
151
152			$persistedParametersMap = [];
153
154			foreach ($persistedParameters as $parameter) {
155			$persistedParametersMap[$parameter->getName()] = $parameter;
156			}
157
158			foreach ($parameters as $name => $value) {
159			if (isset($persistedParametersMap[$name])) {
160			$persistedParametersMap[$name]->setValue($value);
161			} else {
162			// @var CCourseSetting $parameter
163			//$parameter = $this->parameterFactory->createNew();
164			$parameter = new CCourseSetting();
165			$parameter
166			->setNamespace($namespace)
167			->setName($name)
168			->setValue($value)
169			->setCId($this->getCourse()->getId())
170			;
171
172			/// @var ConstraintViolationListInterface $errors
173			$errors = $this->validator->validate($parameter);
174			if (0 < $errors->count()) {
175			throw new ValidatorException($errors->get(0)->getMessage());
176			}
177
178			$this->parameterManager->persist($parameter);
179			}
180			}
181
182			$this->parameterManager->flush();
183			$this->cache->save($namespace, $parameters);*/
184			}
185
186			/**
187			* @param string $category
188			*
189			* @return string
190			*/
191			public function convertNameSpaceToService($category)
192			{
193			return 'chamilo_course.settings.'.$category;
194			}
195
196			/**
197			* Load parameter from database.
198			*
199			* @param string $namespace
200			*
201			* @return array
202			*/
203			private function getParameters($namespace)
204			{
205			$repo = $this->manager->getRepository(CCourseSetting::class);
206			$parameters = [];
207			foreach ($repo->findBy(['category' => $namespace]) as $parameter) {
208			$parameters[$parameter->getTitle()] = $parameter->getValue();
209			}
210
211			return $parameters;
212			}
213			}
214

chamilo / chamilo-lms

Push — master ( b5ff3f...de0fbe )

SettingsManager::getCourse() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like