SettingsCourseManager::save() - Code Metrics - Inspection of "Tests: Add phpunit tests" - chamilo/chamilo-lms - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 3d3d69...b10d98 )

by Julito

created 2021-09-09 09:14 UTC

SettingsCourseManager::save() B

↳ Parent: SettingsCourseManager

Complexity

Conditions	6
Paths	18

Size

Total Lines	51
Code Lines	28

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	6
eloc	28
nc	18
nop	1
dl	0
loc	51
rs	8.8497
c	0
b	0
f	0

How to fix Long Method

<?php

declare(strict_types=1);

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

namespace Chamilo\CourseBundle\Settings;

use Chamilo\CoreBundle\Entity\Course;
use Chamilo\CoreBundle\Entity\SettingsCurrent;
use Chamilo\CoreBundle\Settings\SettingsManager;
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;

class SettingsCourseManager extends SettingsManager
{
    protected Course $course;

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

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

    public function load(string $schemaAlias, string $namespace = null, bool $ignoreUnknown = true): SettingsInterface
    {
        $settings = new Settings();
        $schemaAliasNoPrefix = $schemaAlias;
        $schemaAlias = 'chamilo_course.settings.'.$schemaAlias;
        if (!$this->schemaRegistry->has($schemaAlias)) {
            return $settings;
        }

        /** @var SchemaInterface $schema */
        $schema = $this->schemaRegistry->get($schemaAlias);
        $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 ($ignoreUnknown) {
            foreach (array_keys($parameters) as $name) {
                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): void
    {
        $namespace = $settings->getSchemaAlias();

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

        $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' => $namespace,
        ]);

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

    public function convertNameSpaceToService(string $category): string
    {
        return 'chamilo_course.settings.'.$category;
    }

    public function convertServiceToNameSpace(string $category): string
    {
        return str_replace('chamilo_course.settings.', '', $category);
    }

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

        return $list;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/* For licensing terms, see /license.txt */
6
7			namespace Chamilo\CourseBundle\Settings;
8
9			use Chamilo\CoreBundle\Entity\Course;
10			use Chamilo\CoreBundle\Entity\SettingsCurrent;
11			use Chamilo\CoreBundle\Settings\SettingsManager;
12			use Chamilo\CourseBundle\Entity\CCourseSetting;
13			use Sylius\Bundle\SettingsBundle\Model\Settings;
14			use Sylius\Bundle\SettingsBundle\Model\SettingsInterface;
15			use Sylius\Bundle\SettingsBundle\Schema\SchemaInterface;
16			use Sylius\Bundle\SettingsBundle\Schema\SettingsBuilder;
17
18			class SettingsCourseManager extends SettingsManager
19			{
20			protected Course $course;
21
22			/**
23			* @return Course
24			*/
25			public function getCourse()
26			{
27			return $this->course;
28			}
29
30			public function setCourse(Course $course): void
31			{
32			$this->course = $course;
33			}
34
35			public function load(string $schemaAlias, string $namespace = null, bool $ignoreUnknown = true): SettingsInterface
36			{
37			$settings = new Settings();
38			$schemaAliasNoPrefix = $schemaAlias;
39			$schemaAlias = 'chamilo_course.settings.'.$schemaAlias;
40			if (!$this->schemaRegistry->has($schemaAlias)) {
41			return $settings;
42			}
43
44			/** @var SchemaInterface $schema */
45			$schema = $this->schemaRegistry->get($schemaAlias);
46			$settings->setSchemaAlias($schemaAlias);
47
48			// We need to get a plain parameters array since we use the options resolver on it
49			$parameters = $this->getParameters($schemaAliasNoPrefix);
50			$settingsBuilder = new SettingsBuilder();
51			$schema->buildSettings($settingsBuilder);
52
53			// Remove unknown settings' parameters (e.g. From a previous version of the settings schema)
54			if ($ignoreUnknown) {
55			foreach (array_keys($parameters) as $name) {
56			if (!$settingsBuilder->isDefined($name)) {
57			unset($parameters[$name]);
58			}
59			}
60			}
61
62			foreach ($settingsBuilder->getTransformers() as $parameter => $transformer) {
63			if (\array_key_exists($parameter, $parameters)) {
64			$parameters[$parameter] = $transformer->reverseTransform($parameters[$parameter]);
65			}
66			}
67
68			$parameters = $settingsBuilder->resolve($parameters);
69			$settings->setParameters($parameters);
70
71			return $settings;
72			}
73
74			public function save(SettingsInterface $settings): void
75			{
76			$namespace = $settings->getSchemaAlias();
77
78			/** @var SchemaInterface $schema */
79			$schema = $this->schemaRegistry->get($namespace);
80
81			$settingsBuilder = new SettingsBuilder();
82			$schema->buildSettings($settingsBuilder);
83			$parameters = $settingsBuilder->resolve($settings->getParameters());
84
85			// Transform value. Example array to string using transformer. Example:
86			// 1. Setting "tool_visible_by_default_at_creation" it's a multiple select
87			// 2. Is defined as an array in class DocumentSettingsSchema
88			// 3. Add transformer for that variable "ArrayToIdentifierTransformer"
89			// 4. Here we recover the transformer and convert the array to string
90			foreach ($settingsBuilder->getTransformers() as $parameter => $transformer) {
91			if (\array_key_exists($parameter, $parameters)) {
92			$parameters[$parameter] = $transformer->transform($parameters[$parameter]);
93			}
94			}
95
96			$repo = $this->manager->getRepository(SettingsCurrent::class);
97			/** @var CCourseSetting[] $persistedParameters */
98			$persistedParameters = $repo->findBy([
99			'category' => $namespace,
100			]);
101
102			$persistedParametersMap = [];
103			foreach ($persistedParameters as $parameter) {
104			$persistedParametersMap[$parameter->getTitle()] = $parameter;
105			}
106
107			$simpleCategoryName = str_replace('chamilo_course.settings.', '', $namespace);
108			foreach ($parameters as $name => $value) {
109			if (isset($persistedParametersMap[$name])) {
110			$persistedParametersMap[$name]->setValue($value);
111			} else {
112			$parameter = new CCourseSetting();
113			$parameter
114			->setTitle($name)
115			->setVariable($name)
116			->setCategory($simpleCategoryName)
117			->setValue($value)
118			->setCId($this->getCourse()->getId())
119			;
120			$this->manager->persist($parameter);
121			}
122			}
123
124			$this->manager->flush();
125			}
126
127			public function convertNameSpaceToService(string $category): string
128			{
129			return 'chamilo_course.settings.'.$category;
130			}
131
132			public function convertServiceToNameSpace(string $category): string
133			{
134			return str_replace('chamilo_course.settings.', '', $category);
135			}
136
137			/**
138			* Load parameter from database.
139			*/
140			private function getParameters(string $namespace): array
141			{
142			$repo = $this->manager->getRepository(CCourseSetting::class);
143			$list = [];
144			$parameters = $repo->findBy([
145			'category' => $namespace,
146			]);
147			foreach ($parameters as $parameter) {
148			$list[$parameter->getTitle()] = $parameter->getValue();
149			}
150
151			return $list;
152			}
153			}
154

chamilo / chamilo-lms

Push — master ( 3d3d69...b10d98 )

SettingsCourseManager::save() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like