Code Coverage
 
Lines
Branches
Paths
Functions and Methods
Classes and Traits
Total
98.99%
98 / 99
96.00%
24 / 25
11.59%
8 / 69
66.67%
2 / 3
 CRAP
0.00%
0 / 1
ParameterController
98.99%
98 / 99
96.00%
24 / 25
11.59%
8 / 69
66.67%
2 / 3
 149.42
0.00%
0 / 1
 buildForm
100.00%
35 / 35
100.00%
7 / 7
100.00%
3 / 3
100.00%
1 / 1
 4
 index
100.00%
10 / 10
100.00%
1 / 1
100.00%
1 / 1
100.00%
1 / 1
 1
 edit
98.15%
53 / 54
94.12%
16 / 17
6.15%
4 / 65
0.00%
0 / 1
 75.95
1<?php
2
3namespace App\Controller\Admin;
4
5use App\Entity\Parameter as ParameterEntity;
6use App\Param;
7use App\Parameter as ParameterClass;
8use App\Security\Action;
9use Doctrine\ORM\EntityManagerInterface;
10use Symfony\Component\Form\Extension\Core\Type\ChoiceType;
11use Symfony\Component\Form\Extension\Core\Type\HiddenType;
12use Symfony\Component\Form\Extension\Core\Type\TextareaType;
13use Symfony\Component\Form\Extension\Core\Type\TextType;
14use Symfony\Component\Form\FormInterface;
15use Symfony\Component\HttpFoundation\Request;
16use Symfony\Component\HttpFoundation\Response;
17use Symfony\Component\Routing\Attribute\Route;
18use Symfony\Component\Validator\Validator\ValidatorInterface;
19
20#[Route('/admin/parameter')]
21class ParameterController extends BaseAdminController
22{
23    /**
24     * @return FormInterface<mixed>
25     */
26    protected function buildForm(Param $annotation, ParameterEntity $dbParameter): FormInterface
27    {
28        // Create the form with the '$dbParameter' object
29        $builder = $this->createFormBuilder($dbParameter)
30            ->add('name', HiddenType::class);
31
32        switch ($annotation->type) {
33            case Param::TEXTAREA:
34                $builder->add('value', TextareaType::class, ['required' => false, 'attr' => ['rows' => '6']])
35                    ->add('defaultValue', TextareaType::class, [
36                        'required' => false,
37                        'attr' => ['rows' => '6'],
38                        'mapped' => false,
39                        'disabled' => true,
40                    ]);
41                break;
42            case Param::RADIO:
43                $builder->add(
44                    'value',
45                    ChoiceType::class,
46                    [
47                        'required' => true,
48                        'choices' => ['0 (Non)' => '0', '1 (Oui)' => 1],
49                        'expanded' => true,
50                        'multiple' => false,
51                    ]
52                )->add('defaultValue', TextType::class, [
53                    'required' => false,
54                    'mapped' => false,
55                    'disabled' => true,
56                ]);
57
58                break;
59            default:
60                $builder->add('value', TextType::class, ['required' => false])
61                    ->add('defaultValue', TextType::class, [
62                        'required' => false,
63                        'mapped' => false,
64                        'disabled' => true,
65                    ]);
66        }
67
68        return $builder->getForm();
69    }
70
71    #[Route('', name: 'admin_parameter', methods: ['GET'])]
72    public function index(ParameterClass $parameterClass): Response
73    {
74        // Refuse l'accès si l'utilisateur n'a pas le droit de lire les paramètres
75        $this->denyAccessUnlessGranted(Action::ADMIN_PARAMETER);
76        $defaultValues = $parameterClass->getDefaultValues();
77        $currentValues = $parameterClass->getCurrentValues();
78
79        return $this->render('admin/parameter/index.html.twig', [
80            'parameters' => $parameterClass,
81            'defaultValues' => $defaultValues,
82            'currentValues' => $currentValues,
83            'annotations' => $parameterClass->getAnnotations(),
84            'modif' => $this->isGranted(Action::ADMIN_PARAMETER_WRITE),
85        ]);
86    }
87
88    #[Route('/{name}/edit', name: 'admin_parameter_edit', methods: ['GET', 'POST'])]
89    public function edit(
90        Request $request,
91        string $name,
92        EntityManagerInterface $entityManager,
93        ParameterClass $parameterClass,
94        ValidatorInterface $validator,
95    ): Response {
96        $this->denyAccessUnlessGranted(Action::ADMIN_PARAMETER_WRITE);
97        $annotation = $parameterClass->getAnnotations()[$name];
98        if ($annotation->readOnly) {
99            return $this->redirectToRoute('admin_parameter', [], Response::HTTP_SEE_OTHER);
100        }
101        $defaultValues = $parameterClass->getDefaultValues();
102        $currentValues = $parameterClass->getCurrentValues();
103        $defaultValue = $defaultValues[$name];
104        $currentValueState = array_key_exists($name, $currentValues);
105        // Select the record from the table that has the value 'name'
106        $query = $entityManager->createQueryBuilder();
107        $query->select('parameter')
108            ->from(ParameterEntity::class, 'parameter')
109            ->where('parameter.name = :name')
110            ->setParameter('name', $name);
111        /** @var ParameterEntity[] $dbParameters */
112        $dbParameters = $query->getQuery()->getResult();
113        if ($dbParameters) {
114            $dbParameter = $dbParameters[0];
115        } else {
116            $dbParameter = new ParameterEntity();
117            $dbParameter->setName($name);
118            $dbParameter->setValue($defaultValue);
119            $entityManager->persist($dbParameter);
120        }
121        $form = $this->buildForm($annotation, $dbParameter);
122        $form->get('defaultValue')->setData($defaultValue);
123        $form->handleRequest($request);
124        $errors = $validator->validatePropertyValue($parameterClass, $name, $dbParameter->getValue());
125        $editOk = false;
126        if (!count($errors) && $form->isSubmitted() && $form->isValid()) {
127            if ('update' == $request->request->get('action')) {
128                $editOk = true;
129                $entityManager->flush();
130                $parameterClass->clearCache();
131
132                $this->logger->info(
133                    'Parameter edited : ["Name" = "' . $dbParameter->getName() . '", "Value" = "'
134                    . $dbParameter->getValue() . '", "Default Value" = "' . $defaultValue . '"]'
135                );
136            } elseif ('delete' == $request->request->get('action')) {
137                $editOk = true;
138                $entityManager->remove($dbParameter);
139                $entityManager->flush();
140                $parameterClass->clearCache();
141
142                $this->logger->info(
143                    'Parameter deleted, assgign to default value : ["Name" = "' . $dbParameter->getName() . '",
144                    "Default Value" = "' . $defaultValue . '"]'
145                );
146            }
147        }
148        if ($editOk) {
149            return $this->redirectToRoute('admin_parameter', [], Response::HTTP_SEE_OTHER);
150        }
151
152        return $this->render('admin/parameter/edit.html.twig', [
153            'name' => $dbParameter->getName(),
154            'parameter' => $parameterClass,
155            'form' => $form,
156            'currentValueState' => $currentValueState,
157            'defaultValue' => $defaultValue,
158            'annotation' => $annotation,
159            'errors' => $errors,
160        ]);
161    }
162}