ConfigManager::getUsername() - Code Metrics - Inspection of "feat: Add method to get user merged config values" - xiidea/EasyConfigBundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — main (#9)

unknown

created 2024-05-16 10:22 UTC

ConfigManager::getUsername() A

↳ Parent: ConfigManager

Complexity

Conditions	2
Paths	2

Size

Total Lines	7
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	1	Features	0

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

<?php

namespace Xiidea\EasyConfigBundle\Services\Manager;

use Doctrine\DBAL\Types\Types;
use Symfony\Component\Form\FormFactoryInterface;
use Symfony\Component\Form\FormInterface;
use Symfony\Component\Form\FormView;
use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
use Xiidea\EasyConfigBundle\Model\BaseConfig;
use Xiidea\EasyConfigBundle\Services\FormGroup\ConfigGroupInterface;
use Xiidea\EasyConfigBundle\Services\Repository\ConfigRepositoryInterface;

class ConfigManager
{
    private array $groups = [];

    public function __construct(
        private ConfigRepositoryInterface     $repository,
        private FormFactoryInterface          $formFactory,
        private TokenStorageInterface         $tokenStorage,
        private AuthorizationCheckerInterface $checker,
                                              $configurationGroups = [])
    {
        foreach ($configurationGroups as $group) {
            $this->groups[$group->getNameSpace()] = $group;
        }
    }

    public function addConfigGroup(ConfigGroupInterface $group)
    {
        $this->groups[$group->getNameSpace()] = $group;
    }

    /**
     * @return ConfigGroupInterface[]
     */
    public function getConfigurationGroups(): array
    {
        $username = $this->getUsername();
        $groups = [];

        foreach ($this->groups as $key => $group) {
            $groups[str_replace($username . '.', '', $key)] = $group;
        }

        return $groups;
    }

    public function getConfigurationGroupForms(): array
    {
        $return = [];

        foreach ($this->groups as $groupKey => $policyGroup) {
            $return[] = [
                'key' => $groupKey,
                'label' => $policyGroup->getLabel(),
                'form' => $this->createFormView($policyGroup, $groupKey),
                'isEditable' => $this->checker->isGranted($policyGroup->getAuthorSecurityLevels()),
            ];
        }

        return $return;
    }

    public function getConfigurationsByGroup(string $groupKey): array
    {
        $username = $this->getUsername();
        $configurations = $this->repository->getConfigurationByUsernameAndGroup(
            $username,
            $groupKey
        );
        $results = [];

        /**
         * @var BaseConfig $configuration
         */
        foreach ($configurations as $configuration) {
            $key = str_replace($username . '.', '', $configuration->getId());
            $key = str_replace($groupKey . '.', '', $key);

            if (str_contains($configuration->getId(), $username)) {
                $results[$key] = $configuration->getValue();
            } elseif (!array_key_exists($key, $results)) {
                $results[$key] = $configuration->getValue();
            }
        }

        return $results;
    }

    public function getConfigurationValueByKey(string $key): string
    {
        $username = $this->getUsername();
        $configurations = $this->repository->getConfigurationByUsernameAndKey($username, $key);
        $value = '';

        /**
         * @var BaseConfig $configuration
         */
        foreach ($configurations as $configuration) {
            $value = $configuration->getValue();

            if (str_contains($configuration->getId(), $username . $key)) {
                break;
            }
        }

        return $value;
    }

    /**
     * @param $policyGroup
     * @param $groupKey
     */
    protected function createFormView(ConfigGroupInterface $policyGroup, $groupKey): FormView
    {
        return $policyGroup
            ->getForm($this->formFactory, $this->getConfigurationsByGroupKey($groupKey))
            ->createView();
    }

    public function getConfigurationsByGroupKey($group): array
    {
        return $this->repository->getValuesByGroupKey($group);
    }

    public function getConfigurationGroup($key): ConfigGroupInterface
    {
        return $this->groups[$key];
    }

    private function guessType(FormInterface $item): ?string
    {
        $getNormData = $item->getNormData();

        if (is_string($getNormData)) {
            return null;
        }

        if ($getNormData instanceof \DateTime) {
            return Types::DATE_MUTABLE;
        }

        if (is_array($getNormData)) {
            return 'json';
        }

        if (is_int($getNormData)) {
            return Types::INTEGER;
        }

        return null;
    }

    public function saveGroupData($key, FormInterface $form)
    {
        $types = [];

        foreach ($form->all() as $item) {
            $types[$item->getName()] = $this->guessType($item);
        }

        $this->repository->saveMultiple($key, $form->getData(), $types);
    }

    public function saveUserGroupData($key, FormInterface $form)
    {
        $types = [];

        foreach ($form->all() as $item) {
            $types[$item->getName()] = $this->guessType($item);
        }

        $formData = $form->getData();

        foreach ($formData as $k => $val) {
            $checkBoxKey = $k . 'Preference';

            if (array_key_exists($checkBoxKey, $formData)) {
                if ($formData[$checkBoxKey]) {
                    unset($formData[$k]);
                    $this->repository->removeByKey($key . '.' . $k);
                }

                unset($types[$checkBoxKey]);
                unset($formData[$checkBoxKey]);
            }
        }

        $this->repository->saveMultiple($key, $formData, $types);
    }

    public function getConfigurationGroupForm($group, $data = null): FormInterface
    {
        if (null === $data) {
            $data = $this->getConfigurationsByGroupKey($group);
        }

        return $this->groups[$group]->getForm($this->formFactory, $data);
    }

    public function getConfigurationGroupLabel($group): string
    {
        return $this->groups[$group]->getLabel();
    }

    public function getUserConfigurationValuesByGroupKey($groupKey): array
    {
        $username = $this->getUsername();
        $configurations = $this->repository->getConfigurationByUsernameAndGroup(
            $username,
            $groupKey
        );
        $values = [];

        foreach ($configurations as $configuration) {
            $key = str_replace("{$username}.", '', $configuration->getId());
            $key = str_replace("{$groupKey}.", '', $key);

            if (str_contains($configuration->getId(), $username)) {
                $values[$key] = $configuration->getValue();
                $values[$key . 'Preference'] = false;
            } elseif (!array_key_exists($key, $values)) {
                $values[$key] = $configuration->getValue();
                $values[$key . 'Preference'] = true;
            }
        }

        return $values;
    }

    public function concatUsernameWithKey($key): string
    {
        $username = $this->getUsername();

        if (!str_starts_with($key, $username)) {
            $key = "{$username}.{$key}";
        }

        return $key;
    }

    public function getValueByKey(int $isGlobal, string $key): string
    {
        $username = $this->getUsername();
        $key = str_replace("{$username}.", '', $key);

        if (!$isGlobal) {
            $key = $username . '.' . $key;
        }

        $result = $this->repository->getConfigurationValue($key);

        if ($result === null) {
            $result = '';
        }

        return $result;
    }

    private function getUsername(): ?string
    {
        if (null == $this->tokenStorage->getToken()) {
            return '';
        }

        return $this->tokenStorage->getToken()->getUser()->getUserIdentifier();
    }

    protected function typeCast($value, $type)
    {
        if (empty($value)) {
            return null;
        }

        switch ($type) {
            case Types::DATE_MUTABLE:
            case Types::DATETIME_MUTABLE:
                return new \DateTime($value);
            case Types::BOOLEAN:
                return (bool)$value;
            case Types::INTEGER:
                return (int)$value;
            case Types::JSON:
                return json_decode($value);
            default:
                return $value;
        }
    }

    public function getConfigurationValue($id, $type = null)
    {
        $key = $this->concatUsernameWithKey($id);
        $value = $this->repository->getConfigurationValue($key);
        if (null === $value) {
            $value = $this->repository->getConfigurationValue($id);
        }

        if (null === $type) {
            return $value;
        }

        return $this->typeCast($value, $type);
    }

    public function getFrontendConfigValuesByGroup($group): array
    {
        $items = $this->repository->loadAllByGroup($group, true, true);
        $userItems = $this->repository->loadAllByGroup(
            $this->concatUsernameWithKey($group),
            true,
            true
        );
        foreach ($userItems as $key => $item) {
            if ('DEFAULT' === $item) {
                continue;
            }
            $items[$key] = $item;
        }

        return $items;
    }

    public function getConfigurationByUsernameAndKey(string $key): ?array
    {
        return $this->repository->getConfigurationByUsernameAndKey($this->getUsername(), $key);
    }
}


1			<?php
2
3			namespace Xiidea\EasyConfigBundle\Services\Manager;
4
5			use Doctrine\DBAL\Types\Types;
6			use Symfony\Component\Form\FormFactoryInterface;
7			use Symfony\Component\Form\FormInterface;
8			use Symfony\Component\Form\FormView;
9			use Symfony\Component\Security\Core\Authentication\Token\Storage\TokenStorageInterface;
10			use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
11			use Xiidea\EasyConfigBundle\Model\BaseConfig;
12			use Xiidea\EasyConfigBundle\Services\FormGroup\ConfigGroupInterface;
13			use Xiidea\EasyConfigBundle\Services\Repository\ConfigRepositoryInterface;
14
15			class ConfigManager
16			{
17			private array $groups = [];
18
19			public function __construct(
20			private ConfigRepositoryInterface $repository,
21			private FormFactoryInterface $formFactory,
22			private TokenStorageInterface $tokenStorage,
23			private AuthorizationCheckerInterface $checker,
24			$configurationGroups = [])
25			{
26			foreach ($configurationGroups as $group) {
27			$this->groups[$group->getNameSpace()] = $group;
28			}
29			}
30
31			public function addConfigGroup(ConfigGroupInterface $group)
32			{
33			$this->groups[$group->getNameSpace()] = $group;
34			}
35
36			/**
37			* @return ConfigGroupInterface[]
38			*/
39			public function getConfigurationGroups(): array
40			{
41			$username = $this->getUsername();
42			$groups = [];
43
44			foreach ($this->groups as $key => $group) {
45			$groups[str_replace($username . '.', '', $key)] = $group;
46			}
47
48			return $groups;
49			}
50
51			public function getConfigurationGroupForms(): array
52			{
53			$return = [];
54
55			foreach ($this->groups as $groupKey => $policyGroup) {
56			$return[] = [
57			'key' => $groupKey,
58			'label' => $policyGroup->getLabel(),
59			'form' => $this->createFormView($policyGroup, $groupKey),
60			'isEditable' => $this->checker->isGranted($policyGroup->getAuthorSecurityLevels()),
61			];
62			}
63
64			return $return;
65			}
66
67			public function getConfigurationsByGroup(string $groupKey): array
68			{
69			$username = $this->getUsername();
70			$configurations = $this->repository->getConfigurationByUsernameAndGroup(
71			$username,
72			$groupKey
73			);
74			$results = [];
75
76			/**
77			* @var BaseConfig $configuration
78			*/
79			foreach ($configurations as $configuration) {
80			$key = str_replace($username . '.', '', $configuration->getId());
81			$key = str_replace($groupKey . '.', '', $key);
82
83			if (str_contains($configuration->getId(), $username)) {
84			$results[$key] = $configuration->getValue();
85			} elseif (!array_key_exists($key, $results)) {
86			$results[$key] = $configuration->getValue();
87			}
88			}
89
90			return $results;
91			}
92
93			public function getConfigurationValueByKey(string $key): string
94			{
95			$username = $this->getUsername();
96			$configurations = $this->repository->getConfigurationByUsernameAndKey($username, $key);
97			$value = '';
98
99			/**
100			* @var BaseConfig $configuration
101			*/
102			foreach ($configurations as $configuration) {
103			$value = $configuration->getValue();
104
105			if (str_contains($configuration->getId(), $username . $key)) {
106			break;
107			}
108			}
109
110			return $value;
111			}
112
113			/**
114			* @param $policyGroup
115			* @param $groupKey
116			*/
117			protected function createFormView(ConfigGroupInterface $policyGroup, $groupKey): FormView
118			{
119			return $policyGroup
120			->getForm($this->formFactory, $this->getConfigurationsByGroupKey($groupKey))
121			->createView();
122			}
123
124			public function getConfigurationsByGroupKey($group): array
125			{
126			return $this->repository->getValuesByGroupKey($group);
127			}
128
129			public function getConfigurationGroup($key): ConfigGroupInterface
130			{
131			return $this->groups[$key];
132			}
133
134			private function guessType(FormInterface $item): ?string
135			{
136			$getNormData = $item->getNormData();
137
138			if (is_string($getNormData)) {
139			return null;
140			}
141
142			if ($getNormData instanceof \DateTime) {
143			return Types::DATE_MUTABLE;
144			}
145
146			if (is_array($getNormData)) {
147			return 'json';
148			}
149
150			if (is_int($getNormData)) {
151			return Types::INTEGER;
152			}
153
154			return null;
155			}
156
157			public function saveGroupData($key, FormInterface $form)
158			{
159			$types = [];
160
161			foreach ($form->all() as $item) {
162			$types[$item->getName()] = $this->guessType($item);
163			}
164
165			$this->repository->saveMultiple($key, $form->getData(), $types);
166			}
167
168			public function saveUserGroupData($key, FormInterface $form)
169			{
170			$types = [];
171
172			foreach ($form->all() as $item) {
173			$types[$item->getName()] = $this->guessType($item);
174			}
175
176			$formData = $form->getData();
177
178			foreach ($formData as $k => $val) {
179			$checkBoxKey = $k . 'Preference';
180
181			if (array_key_exists($checkBoxKey, $formData)) {
182			if ($formData[$checkBoxKey]) {
183			unset($formData[$k]);
184			$this->repository->removeByKey($key . '.' . $k);
185			}
186
187			unset($types[$checkBoxKey]);
188			unset($formData[$checkBoxKey]);
189			}
190			}
191
192			$this->repository->saveMultiple($key, $formData, $types);
193			}
194
195			public function getConfigurationGroupForm($group, $data = null): FormInterface
196			{
197			if (null === $data) {
198			$data = $this->getConfigurationsByGroupKey($group);
199			}
200
201			return $this->groups[$group]->getForm($this->formFactory, $data);
202			}
203
204			public function getConfigurationGroupLabel($group): string
205			{
206			return $this->groups[$group]->getLabel();
207			}
208
209			public function getUserConfigurationValuesByGroupKey($groupKey): array
210			{
211			$username = $this->getUsername();
212			$configurations = $this->repository->getConfigurationByUsernameAndGroup(
213			$username,
214			$groupKey
215			);
216			$values = [];
217
218			foreach ($configurations as $configuration) {
219			$key = str_replace("{$username}.", '', $configuration->getId());
220			$key = str_replace("{$groupKey}.", '', $key);
221
222			if (str_contains($configuration->getId(), $username)) {
223			$values[$key] = $configuration->getValue();
224			$values[$key . 'Preference'] = false;
225			} elseif (!array_key_exists($key, $values)) {
226			$values[$key] = $configuration->getValue();
227			$values[$key . 'Preference'] = true;
228			}
229			}
230
231			return $values;
232			}
233
234			public function concatUsernameWithKey($key): string
235			{
236			$username = $this->getUsername();
237
238			if (!str_starts_with($key, $username)) {
239			$key = "{$username}.{$key}";
240			}
241
242			return $key;
243			}
244
245			public function getValueByKey(int $isGlobal, string $key): string
246			{
247			$username = $this->getUsername();
248			$key = str_replace("{$username}.", '', $key);
249
250			if (!$isGlobal) {
251			$key = $username . '.' . $key;
252			}
253
254			$result = $this->repository->getConfigurationValue($key);
255
256			if ($result === null) {
257			$result = '';
258			}
259
260			return $result;
261			}
262
263			private function getUsername(): ?string
264			{
265			if (null == $this->tokenStorage->getToken()) {
266			return '';
267			}
268
269			return $this->tokenStorage->getToken()->getUser()->getUserIdentifier();
270			}
271
272			protected function typeCast($value, $type)
273			{
274			if (empty($value)) {
275			return null;
276			}
277
278			switch ($type) {
279			case Types::DATE_MUTABLE:
280			case Types::DATETIME_MUTABLE:
281			return new \DateTime($value);
282			case Types::BOOLEAN:
283			return (bool)$value;
284			case Types::INTEGER:
285			return (int)$value;
286			case Types::JSON:
287			return json_decode($value);
288			default:
289			return $value;
290			}
291			}
292
293			public function getConfigurationValue($id, $type = null)
294			{
295			$key = $this->concatUsernameWithKey($id);
296			$value = $this->repository->getConfigurationValue($key);
297			if (null === $value) {
298			$value = $this->repository->getConfigurationValue($id);
299			}
300
301			if (null === $type) {
302			return $value;
303			}
304
305			return $this->typeCast($value, $type);
306			}
307
308			public function getFrontendConfigValuesByGroup($group): array
309			{
310			$items = $this->repository->loadAllByGroup($group, true, true);
311			$userItems = $this->repository->loadAllByGroup(
312			$this->concatUsernameWithKey($group),
313			true,
314			true
315			);
316			foreach ($userItems as $key => $item) {
317			if ('DEFAULT' === $item) {
318			continue;
319			}
320			$items[$key] = $item;
321			}
322
323			return $items;
324			}
325
326			public function getConfigurationByUsernameAndKey(string $key): ?array
327			{
328			return $this->repository->getConfigurationByUsernameAndKey($this->getUsername(), $key);
329			}
330			}
331

xiidea / EasyConfigBundle

Pull Request — main (#9)

ConfigManager::getUsername() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like