SettingsController::syncSettings() - Code Metrics - Inspection of "Plugin: Bbb: setting to hide conference link in co..." - chamilo/chamilo-lms - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 702f24...55adc1 )

by Yannick

created 2025-07-09 20:26 UTC

SettingsController::syncSettings() A

↳ Parent: SettingsController

Complexity

Conditions	1
Paths	1

Size

Total Lines	10
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

declare(strict_types=1);

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

namespace Chamilo\CoreBundle\Controller\Admin;

use Chamilo\CoreBundle\Controller\BaseController;
use Chamilo\CoreBundle\Entity\SettingsCurrent;
use Chamilo\CoreBundle\Entity\SettingsValueTemplate;
use Chamilo\CoreBundle\Helpers\AccessUrlHelper;
use Chamilo\CoreBundle\Traits\ControllerTrait;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\Form\Extension\Core\Type\SubmitType;
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Form\FormInterface;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;
use Symfony\Component\Security\Http\Attribute\IsGranted;
use Symfony\Component\Validator\Exception\ValidatorException;
use Symfony\Contracts\Translation\TranslatorInterface;

#[Route('/admin')]
class SettingsController extends BaseController
{
    use ControllerTrait;

    public function __construct(
        private readonly EntityManagerInterface $entityManager,
        private readonly TranslatorInterface $translator
    ) {}

    #[Route('/settings', name: 'admin_settings')]
    public function index(): Response
    {
        return $this->redirectToRoute('chamilo_platform_settings', ['namespace' => 'platform']);
    }

    /**
     * Edit configuration with given namespace.
     */
    #[IsGranted('ROLE_ADMIN')]
    #[Route('/settings/search_settings', name: 'chamilo_platform_settings_search')]
    public function searchSetting(Request $request): Response
    {
        $manager = $this->getSettingsManager();
        $formList = [];
        $keyword = $request->query->get('keyword');

        $searchForm = $this->getSearchForm();
        $searchForm->handleRequest($request);
        if ($searchForm->isSubmitted() && $searchForm->isValid()) {
            $values = $searchForm->getData();
            $keyword = $values['keyword'];
        }

        if (empty($keyword)) {
            throw $this->createNotFoundException();
        }

        $settingsFromKeyword = $manager->getParametersFromKeywordOrderedByCategory($keyword);

        $settings = [];
        if (!empty($settingsFromKeyword)) {
            foreach ($settingsFromKeyword as $category => $parameterList) {
                if (empty($category)) {
                    continue;
                }

                $list = [];
                foreach ($parameterList as $parameter) {
                    $list[] = $parameter->getVariable();
                }
                $settings = $manager->load($category, null);
                $schemaAlias = $manager->convertNameSpaceToService($category);
                $form = $this->getSettingsFormFactory()->create($schemaAlias);

                foreach (array_keys($settings->getParameters()) as $name) {
                    if (!\in_array($name, $list, true)) {
                        $form->remove($name);
                        $settings->remove($name);
                    }
                }
                $form->setData($settings);
                $formList[$category] = $form->createView();
            }
        }

        $schemas = $manager->getSchemas();

        return $this->render(
            '@ChamiloCore/Admin/Settings/search.html.twig',
            [
                'keyword' => $keyword,
                'schemas' => $schemas,
                'settings' => $settings,
                'form_list' => $formList,
                'search_form' => $searchForm,
            ]
        );
    }

    /**
     * Edit configuration with given namespace.
     */
    #[IsGranted('ROLE_ADMIN')]
    #[Route('/settings/{namespace}', name: 'chamilo_platform_settings')]
    public function updateSetting(Request $request, AccessUrlHelper $accessUrlHelper, string $namespace): Response
    {
        $manager = $this->getSettingsManager();
        $url = $accessUrlHelper->getCurrent();
        $manager->setUrl($url);
        $schemaAlias = $manager->convertNameSpaceToService($namespace);
        $searchForm = $this->getSearchForm();

        $keyword = '';
        $settingsFromKeyword = null;

        $searchForm->handleRequest($request);
        if ($searchForm->isSubmitted() && $searchForm->isValid()) {
            $values = $searchForm->getData();
            $keyword = $values['keyword'];
            $settingsFromKeyword = $manager->getParametersFromKeyword(
                $schemaAlias,
                $keyword
            );
        }

        $keywordFromGet = $request->query->get('keyword');
        if ($keywordFromGet) {
            $keyword = $keywordFromGet;
            $searchForm->setData([
                'keyword' => $keyword,
            ]);
            $settingsFromKeyword = $manager->getParametersFromKeyword(
                $schemaAlias,
                $keywordFromGet
            );
        }

        $settings = $manager->load($namespace);
        $form = $this->getSettingsFormFactory()->create($schemaAlias);

        if (!empty($keyword)) {
            $params = $settings->getParameters();
            foreach (array_keys($params) as $name) {
                if (!\array_key_exists($name, $settingsFromKeyword)) {
                    $form->remove($name);
                }
            }
        }

        $form->setData($settings);
        $form->handleRequest($request);

        if ($form->isSubmitted() && $form->isValid()) {
            $messageType = 'success';

            try {
                $manager->save($form->getData());
                $message = $this->trans('Settings have been successfully updated');
            } catch (ValidatorException $validatorException) {
                $message = $this->trans($validatorException->getMessage());
                $messageType = 'error';
            }

            $this->addFlash($messageType, $message);

            if (!empty($keyword)) {
                return $this->redirectToRoute('chamilo_platform_settings_search', [
                    'keyword' => $keyword,
                ]);
            }

            return $this->redirectToRoute('chamilo_platform_settings', [
                'namespace' => $namespace,
            ]);
        }

        $schemas = $manager->getSchemas();

        $templateMap = [];
        $settingsRepo = $this->entityManager->getRepository(SettingsCurrent::class);

        $settingsWithTemplate = $settingsRepo->findBy(['url' => $url]);

        foreach ($settingsWithTemplate as $s) {
            if ($s->getValueTemplate()) {
                $templateMap[$s->getVariable()] = $s->getValueTemplate()->getId();
            }
        }

        return $this->render(
            '@ChamiloCore/Admin/Settings/default.html.twig',
            [
                'schemas' => $schemas,
                'settings' => $settings,
                'form' => $form->createView(),
                'keyword' => $keyword,
                'search_form' => $searchForm,
                'template_map' => $templateMap,
            ]
        );
    }

    /**
     * Sync settings from classes with the database.
     */
    #[IsGranted('ROLE_ADMIN')]
    #[Route('/settings_sync', name: 'sync_settings')]
    public function syncSettings(AccessUrlHelper $accessUrlHelper): Response
    {
        $manager = $this->getSettingsManager();
        $url = $accessUrlHelper->getCurrent();
        $manager->setUrl($url);
        $manager->installSchemas($url);

        return new Response('Updated');
    }

    #[IsGranted('ROLE_ADMIN')]
    #[Route('/settings/template/{id}', name: 'chamilo_platform_settings_template')]
    public function getTemplateExample(int $id): JsonResponse
    {
        $repo = $this->entityManager->getRepository(SettingsValueTemplate::class);
        $template = $repo->find($id);

        if (!$template) {
            return $this->json([
                'error' => $this->translator->trans('Template not found.')
            ], Response::HTTP_NOT_FOUND);
        }

        return $this->json([
            'name' => $template->getName(),
            'json_example' => $template->getJsonExample(),
        ]);
    }

    /**
     * @return FormInterface
     */
    private function getSearchForm()
    {
        $builder = $this->container->get('form.factory')->createNamedBuilder('search');
        $builder->add('keyword', TextType::class);
        $builder->add('search', SubmitType::class, ['attr' => ['class' => 'btn btn--primary']]);

        return $builder->getForm();
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/* For licensing terms, see /license.txt */
6
7			namespace Chamilo\CoreBundle\Controller\Admin;
8
9			use Chamilo\CoreBundle\Controller\BaseController;
10			use Chamilo\CoreBundle\Entity\SettingsCurrent;
11			use Chamilo\CoreBundle\Entity\SettingsValueTemplate;
12			use Chamilo\CoreBundle\Helpers\AccessUrlHelper;
13			use Chamilo\CoreBundle\Traits\ControllerTrait;
14			use Doctrine\ORM\EntityManagerInterface;
15			use Symfony\Component\Form\Extension\Core\Type\SubmitType;
16			use Symfony\Component\Form\Extension\Core\Type\TextType;
17			use Symfony\Component\Form\FormInterface;
18			use Symfony\Component\HttpFoundation\JsonResponse;
19			use Symfony\Component\HttpFoundation\Request;
20			use Symfony\Component\HttpFoundation\Response;
21			use Symfony\Component\Routing\Attribute\Route;
22			use Symfony\Component\Security\Http\Attribute\IsGranted;
23			use Symfony\Component\Validator\Exception\ValidatorException;
24			use Symfony\Contracts\Translation\TranslatorInterface;
25
26			#[Route('/admin')]
27			class SettingsController extends BaseController
28			{
29			use ControllerTrait;
30
31			public function __construct(
32			private readonly EntityManagerInterface $entityManager,
33			private readonly TranslatorInterface $translator
34			) {}
35
36			#[Route('/settings', name: 'admin_settings')]
37			public function index(): Response
38			{
39			return $this->redirectToRoute('chamilo_platform_settings', ['namespace' => 'platform']);
40			}
41
42			/**
43			* Edit configuration with given namespace.
44			*/
45			#[IsGranted('ROLE_ADMIN')]
46			#[Route('/settings/search_settings', name: 'chamilo_platform_settings_search')]
47			public function searchSetting(Request $request): Response
48			{
49			$manager = $this->getSettingsManager();
50			$formList = [];
51			$keyword = $request->query->get('keyword');
52
53			$searchForm = $this->getSearchForm();
54			$searchForm->handleRequest($request);
55			if ($searchForm->isSubmitted() && $searchForm->isValid()) {
56			$values = $searchForm->getData();
57			$keyword = $values['keyword'];
58			}
59
60			if (empty($keyword)) {
61			throw $this->createNotFoundException();
62			}
63
64			$settingsFromKeyword = $manager->getParametersFromKeywordOrderedByCategory($keyword);
65
66			$settings = [];
67			if (!empty($settingsFromKeyword)) {
68			foreach ($settingsFromKeyword as $category => $parameterList) {
69			if (empty($category)) {
70			continue;
71			}
72
73			$list = [];
74			foreach ($parameterList as $parameter) {
75			$list[] = $parameter->getVariable();
76			}
77			$settings = $manager->load($category, null);
78			$schemaAlias = $manager->convertNameSpaceToService($category);
79			$form = $this->getSettingsFormFactory()->create($schemaAlias);
80
81			foreach (array_keys($settings->getParameters()) as $name) {
82			if (!\in_array($name, $list, true)) {
83			$form->remove($name);
84			$settings->remove($name);
85			}
86			}
87			$form->setData($settings);
88			$formList[$category] = $form->createView();
89			}
90			}
91
92			$schemas = $manager->getSchemas();
93
94			return $this->render(
95			'@ChamiloCore/Admin/Settings/search.html.twig',
96			[
97			'keyword' => $keyword,
98			'schemas' => $schemas,
99			'settings' => $settings,
100			'form_list' => $formList,
101			'search_form' => $searchForm,
102			]
103			);
104			}
105
106			/**
107			* Edit configuration with given namespace.
108			*/
109			#[IsGranted('ROLE_ADMIN')]
110			#[Route('/settings/{namespace}', name: 'chamilo_platform_settings')]
111			public function updateSetting(Request $request, AccessUrlHelper $accessUrlHelper, string $namespace): Response
112			{
113			$manager = $this->getSettingsManager();
114			$url = $accessUrlHelper->getCurrent();
115			$manager->setUrl($url);
116			$schemaAlias = $manager->convertNameSpaceToService($namespace);
117			$searchForm = $this->getSearchForm();
118
119			$keyword = '';
120			$settingsFromKeyword = null;
121
122			$searchForm->handleRequest($request);
123			if ($searchForm->isSubmitted() && $searchForm->isValid()) {
124			$values = $searchForm->getData();
125			$keyword = $values['keyword'];
126			$settingsFromKeyword = $manager->getParametersFromKeyword(
127			$schemaAlias,
128			$keyword
129			);
130			}
131
132			$keywordFromGet = $request->query->get('keyword');
133			if ($keywordFromGet) {
134			$keyword = $keywordFromGet;
135			$searchForm->setData([
136			'keyword' => $keyword,
137			]);
138			$settingsFromKeyword = $manager->getParametersFromKeyword(
139			$schemaAlias,
140			$keywordFromGet
141			);
142			}
143
144			$settings = $manager->load($namespace);
145			$form = $this->getSettingsFormFactory()->create($schemaAlias);
146
147			if (!empty($keyword)) {
148			$params = $settings->getParameters();
149			foreach (array_keys($params) as $name) {
150			if (!\array_key_exists($name, $settingsFromKeyword)) {
151			$form->remove($name);
152			}
153			}
154			}
155
156			$form->setData($settings);
157			$form->handleRequest($request);
158
159			if ($form->isSubmitted() && $form->isValid()) {
160			$messageType = 'success';
161
162			try {
163			$manager->save($form->getData());
164			$message = $this->trans('Settings have been successfully updated');
165			} catch (ValidatorException $validatorException) {
166			$message = $this->trans($validatorException->getMessage());
167			$messageType = 'error';
168			}
169
170			$this->addFlash($messageType, $message);
171
172			if (!empty($keyword)) {
173			return $this->redirectToRoute('chamilo_platform_settings_search', [
174			'keyword' => $keyword,
175			]);
176			}
177
178			return $this->redirectToRoute('chamilo_platform_settings', [
179			'namespace' => $namespace,
180			]);
181			}
182
183			$schemas = $manager->getSchemas();
184
185			$templateMap = [];
186			$settingsRepo = $this->entityManager->getRepository(SettingsCurrent::class);
187
188			$settingsWithTemplate = $settingsRepo->findBy(['url' => $url]);
189
190			foreach ($settingsWithTemplate as $s) {
191			if ($s->getValueTemplate()) {
192			$templateMap[$s->getVariable()] = $s->getValueTemplate()->getId();
193			}
194			}
195
196			return $this->render(
197			'@ChamiloCore/Admin/Settings/default.html.twig',
198			[
199			'schemas' => $schemas,
200			'settings' => $settings,
201			'form' => $form->createView(),
202			'keyword' => $keyword,
203			'search_form' => $searchForm,
204			'template_map' => $templateMap,
205			]
206			);
207			}
208
209			/**
210			* Sync settings from classes with the database.
211			*/
212			#[IsGranted('ROLE_ADMIN')]
213			#[Route('/settings_sync', name: 'sync_settings')]
214			public function syncSettings(AccessUrlHelper $accessUrlHelper): Response
215			{
216			$manager = $this->getSettingsManager();
217			$url = $accessUrlHelper->getCurrent();
218			$manager->setUrl($url);
219			$manager->installSchemas($url);
220
221			return new Response('Updated');
222			}
223
224			#[IsGranted('ROLE_ADMIN')]
225			#[Route('/settings/template/{id}', name: 'chamilo_platform_settings_template')]
226			public function getTemplateExample(int $id): JsonResponse
227			{
228			$repo = $this->entityManager->getRepository(SettingsValueTemplate::class);
229			$template = $repo->find($id);
230
231			if (!$template) {
232			return $this->json([
233			'error' => $this->translator->trans('Template not found.')
234			], Response::HTTP_NOT_FOUND);
235			}
236
237			return $this->json([
238			'name' => $template->getName(),
239			'json_example' => $template->getJsonExample(),
240			]);
241			}
242
243			/**
244			* @return FormInterface
245			*/
246			private function getSearchForm()
247			{
248			$builder = $this->container->get('form.factory')->createNamedBuilder('search');
249			$builder->add('keyword', TextType::class);
250			$builder->add('search', SubmitType::class, ['attr' => ['class' => 'btn btn--primary']]);
251
252			return $builder->getForm();
253			}
254			}
255

chamilo / chamilo-lms

Push — master ( 702f24...55adc1 )

SettingsController::syncSettings() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like