Service::configureDefinition() - Code Metrics - philiplb/CRUDlex - Measure and Improve Code Quality continuously with Scrutinizer

Service::configureDefinition() A
last analyzed 2020-08-31 21:30 UTC

↳ Parent: Service

Complexity

Conditions	3
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	3

Importance

Changes

Metric	Value
dl	0
loc	21
ccs	7
cts	7
cp	1
rs	9.584
c	0
b	0
f	0
cc	3
nc	3
nop	2
crap	3

<?php

/*
 * This file is part of the CRUDlex package.
 *
 * (c) Philip Lehmann-Böhm <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace CRUDlex;

use League\Flysystem\FilesystemInterface;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
use Symfony\Component\Translation\TranslatorInterface;

/**
 * The Service setups and initializes the whole CRUD system and is initialized via the framework
 * specific implementation, the Silex one for example.
 * It offers access to AbstractData instances, one for each defined entity off the CRUD YAML file
 * and various other helper functions.
 */
class Service
{

    /**
     * Holds the data instances.
     * @var array
     */
    protected $datas;

    /**
     * Holds the map for overriding templates.
     * @var array
     */
    protected $templates;

    /**
     * Holds whether CRUDlex manages i18n.
     * @var bool
     */
    protected $manageI18n = true;

    /**
     * Holds the URL generator.
     * @var \Symfony\Component\Routing\Generator\UrlGeneratorInterface
     */
    protected $urlGenerator;

    /**
     * Gets the available locales.
     *
     * @return array
     * the available locales
     */
    public static function getLocales()
    {
        $localeDir     = __DIR__.'/../locales';
        $languageFiles = scandir($localeDir);
        $locales       = [];
        foreach ($languageFiles as $languageFile) {
            if (in_array($languageFile, ['.', '..'])) {
                continue;
            }
            $extensionPos = strpos($languageFile, '.yml');
            if ($extensionPos !== false) {
                $locale    = substr($languageFile, 0, $extensionPos);
                $locales[] = $locale;
            }
        }
        sort($locales);
        return $locales;
    }

    /**
     * Initializes the children of the data entries.
     */
    protected function initChildren()
    {
        foreach ($this->datas as $name => $data) {
            $fields = $data->getDefinition()->getFieldNames();
            foreach ($fields as $field) {
                if ($data->getDefinition()->getType($field) == 'reference') {
                    $this->datas[$data->getDefinition()->getSubTypeField($field, 'reference', 'entity')]->getDefinition()->addChild($data->getDefinition()->getTable(), $field, $name);
                }
            }
        }
    }

    /**
     * Gets a map with localized entity labels from the CRUD YML.
     *
     * @param array $crud
     * the CRUD entity map
     *
     * @return array
     * the map with localized entity labels
     */
    protected function getLocaleLabels(array $crud)
    {
        $locales      = $this->getLocales();
        $localeLabels = [];
        foreach ($locales as $locale) {
            if (array_key_exists('label_'.$locale, $crud)) {
                $localeLabels[$locale] = $crud['label_'.$locale];
            }
        }
        return $localeLabels;
    }

    /**
     * Configures the EntityDefinition according to the given
     * CRUD entity map.
     *
     * @param EntityDefinition $definition
     * the definition to configure
     * @param array $crud
     * the CRUD entity map
     */
    protected function configureDefinition(EntityDefinition $definition, array $crud)
    {
        $toConfigure = [
            'deleteCascade',
            'listFields',
            'filter',
            'childrenLabelFields',
            'pageSize',
            'initialSortField',
            'initialSortAscending',
            'navBarGroup',
            'optimisticLocking',
            'hardDeletion',
        ];
        foreach ($toConfigure as $field) {
            if (array_key_exists($field, $crud)) {
                $function = 'set'.ucfirst($field);
                $definition->$function($crud[$field]);
            }
        }
    }

    /**
     * Creates and setups an EntityDefinition instance.
     *
     * @param TranslatorInterface $translator
     * the Translator to use for some standard field labels
     * @param EntityDefinitionFactoryInterface $entityDefinitionFactory
     * the EntityDefinitionFactory to use
     * @param array $crud
     * the parsed YAML of a CRUD entity
     * @param string $name
     * the name of the entity
     *
     * @return EntityDefinition
     * the EntityDefinition good to go
     */
    protected function createDefinition(TranslatorInterface $translator, EntityDefinitionFactoryInterface $entityDefinitionFactory, array $crud, $name)
    {
        $label               = array_key_exists('label', $crud) ? $crud['label'] : $name;
        $localeLabels        = $this->getLocaleLabels($crud);
        $standardFieldLabels = [
            'id' => $translator->trans('crudlex.label.id'),
            'created_at' => $translator->trans('crudlex.label.created_at'),
            'updated_at' => $translator->trans('crudlex.label.updated_at')
        ];

        $definition = $entityDefinitionFactory->createEntityDefinition(
            $crud['table'],
            $crud['fields'],
            $label,
            $localeLabels,
            $standardFieldLabels,
            $this
        );
        $this->configureDefinition($definition, $crud);
        return $definition;
    }

    /**
     * Initializes the instance.
     *
     * @param string $crudFile
     * the CRUD YAML file
     * @param string|null $crudFileCachingDirectory
     * the writable directory to store the CRUD YAML file cache
     * @param UrlGeneratorInterface $urlGenerator
     * the URL generator to use
     * @param TranslatorInterface $translator
     * the translator to use
     * @param DataFactoryInterface $dataFactory
     * the data factory to use
     * @param EntityDefinitionFactoryInterface $entityDefinitionFactory
     * the EntityDefinitionFactory to use
     * @param FilesystemInterface $filesystem
     * the filesystem to use
     * @param EntityDefinitionValidatorInterface|null $validator
     * the validator to use, null if no validation required
     */
    public function __construct($crudFile, $crudFileCachingDirectory, UrlGeneratorInterface $urlGenerator, TranslatorInterface $translator, DataFactoryInterface $dataFactory, EntityDefinitionFactoryInterface $entityDefinitionFactory, FilesystemInterface $filesystem, ?EntityDefinitionValidatorInterface $validator)
    {

        $this->urlGenerator = $urlGenerator;

        $this->templates = [];
        $this->setTemplate('layout', '@crud/layout.twig');

        $reader     = new YamlReader($crudFileCachingDirectory);
        $parsedYaml = $reader->read($crudFile);

        if ($validator !== null) {
            $validator->validate($parsedYaml);
        }

        $this->datas = [];
        foreach ($parsedYaml as $name => $crud) {
            $definition         = $this->createDefinition($translator, $entityDefinitionFactory, $crud, $name);
            $this->datas[$name] = $dataFactory->createData($definition, $filesystem);
        }

        $this->initChildren();

    }

    /**
     * Getter for the AbstractData instances.
     *
     * @param string $name
     * the entity name of the desired Data instance
     *
     * @return AbstractData
     * the AbstractData instance or null on invalid name
     */
    public function getData($name)
    {
        if (!array_key_exists($name, $this->datas)) {
            return null;
        }
        return $this->datas[$name];
    }

    /**
     * Getter for all available entity names.
     *
     * @return string[]
     * a list of all available entity names
     */
    public function getEntities()
    {
        return array_keys($this->datas);
    }

    /**
     * Getter for the entities for the navigation bar.
     *
     * @return string[]
     * a list of all available entity names with their group
     */
    public function getEntitiesNavBar()
    {
        $result = [];
        foreach ($this->datas as $entity => $data) {
            $navBarGroup = $data->getDefinition()->getNavBarGroup();
            if ($navBarGroup !== 'main') {
                $result[$navBarGroup][] = $entity;
            } else {
                $result[$entity] = 'main';
            }
        }
        return $result;
    }

    /**
     * Sets a template to use instead of the build in ones.
     *
     * @param string $key
     * the template key to use in this format:
     * $section.$action.$entity
     * $section.$action
     * $section
     * @param string $template
     * the template to use for this key
     */
    public function setTemplate($key, $template)
    {
        $this->templates[$key] = $template;
    }

    /**
     * Determines the Twig template to use for the given parameters depending on
     * the existance of certain template keys set in this order:
     *
     * $section.$action.$entity
     * $section.$action
     * $section
     *
     * If nothing exists, this string is returned: "@crud/<action>.twig"
     *
     * @param string $section
     * the section of the template, either "layout" or "template"
     * @param string $action
     * the current calling action like "create" or "show"
     * @param string $entity
     * the current calling entity
     *
     * @return string
     * the best fitting template
     */
    public function getTemplate($section, $action, $entity)
    {
        $sectionAction = $section.'.'.$action;

        $offsets = [
            $sectionAction.'.'.$entity,
            $section.'.'.$entity,
            $sectionAction,
            $section
        ];
        foreach ($offsets as $offset) {
            if (array_key_exists($offset, $this->templates)) {
                return $this->templates[$offset];
            }
        }

        return '@crud/'.$action.'.twig';
    }

    /**
     * Sets the locale to be used.
     *
     * @param string $locale
     * the locale to be used.
     */
    public function setLocale($locale)
    {
        foreach ($this->datas as $data) {
            $data->getDefinition()->setLocale($locale);
        }
    }

    /**
     * Gets whether CRUDlex manages the i18n.
     * @return bool
     * true if so
     */
    public function isManageI18n()
    {
        return $this->manageI18n;
    }

    /**
     * Sets whether CRUDlex manages the i18n.
     * @param bool $manageI18n
     * true if so
     */
    public function setManageI18n($manageI18n)
    {
        $this->manageI18n = $manageI18n;
    }

    /**
     * Generates an URL.
     * @param string $name
     * the name of the route
     * @param mixed $parameters
     * an array of parameters
     * @return null|string
     * the generated URL
     */
    public function generateURL($name, $parameters)
    {
        return $this->urlGenerator->generate($name, $parameters);
    }

}


1		<?php
2
3		/*
4		* This file is part of the CRUDlex package.
5		*
6		* (c) Philip Lehmann-Böhm <[email protected]>
7		*
8		* For the full copyright and license information, please view the LICENSE
9		* file that was distributed with this source code.
10		*/
11
12		namespace CRUDlex;
13
14		use League\Flysystem\FilesystemInterface;
15		use Symfony\Component\Routing\Generator\UrlGeneratorInterface;
16		use Symfony\Component\Translation\TranslatorInterface;
17
18		/**
19		* The Service setups and initializes the whole CRUD system and is initialized via the framework
20		* specific implementation, the Silex one for example.
21		* It offers access to AbstractData instances, one for each defined entity off the CRUD YAML file
22		* and various other helper functions.
23		*/
24		class Service
25		{
26
27		/**
28		* Holds the data instances.
29		* @var array
30		*/
31		protected $datas;
32
33		/**
34		* Holds the map for overriding templates.
35		* @var array
36		*/
37		protected $templates;
38
39		/**
40		* Holds whether CRUDlex manages i18n.
41		* @var bool
42		*/
43		protected $manageI18n = true;
44
45		/**
46		* Holds the URL generator.
47		* @var \Symfony\Component\Routing\Generator\UrlGeneratorInterface
48		*/
49		protected $urlGenerator;
50
51		/**
52		* Gets the available locales.
53		*
54		* @return array
55		* the available locales
56		*/
57	80	public static function getLocales()
58		{
59	80	$localeDir = __DIR__.'/../locales';
60	80	$languageFiles = scandir($localeDir);
61	80	$locales = [];
62	80	foreach ($languageFiles as $languageFile) {
63	80	if (in_array($languageFile, ['.', '..'])) {
64	80	continue;
65		}
66	80	$extensionPos = strpos($languageFile, '.yml');
67	80	if ($extensionPos !== false) {
68	80	$locale = substr($languageFile, 0, $extensionPos);
69	80	$locales[] = $locale;
70		}
71		}
72	80	sort($locales);
73	80	return $locales;
74		}
75
76		/**
77		* Initializes the children of the data entries.
78		*/
79	79	protected function initChildren()
80		{
81	79	foreach ($this->datas as $name => $data) {
82	79	$fields = $data->getDefinition()->getFieldNames();
83	79	foreach ($fields as $field) {
84	79	if ($data->getDefinition()->getType($field) == 'reference') {
85	79	$this->datas[$data->getDefinition()->getSubTypeField($field, 'reference', 'entity')]->getDefinition()->addChild($data->getDefinition()->getTable(), $field, $name);
86		}
87		}
88		}
89	79	}
90
91		/**
92		* Gets a map with localized entity labels from the CRUD YML.
93		*
94		* @param array $crud
95		* the CRUD entity map
96		*
97		* @return array
98		* the map with localized entity labels
99		*/
100	79	protected function getLocaleLabels(array $crud)
101		{
102	79	$locales = $this->getLocales();
103	79	$localeLabels = [];
104	79	foreach ($locales as $locale) {
105	79	if (array_key_exists('label_'.$locale, $crud)) {
106	79	$localeLabels[$locale] = $crud['label_'.$locale];
107		}
108		}
109	79	return $localeLabels;
110		}
111
112		/**
113		* Configures the EntityDefinition according to the given
114		* CRUD entity map.
115		*
116		* @param EntityDefinition $definition
117		* the definition to configure
118		* @param array $crud
119		* the CRUD entity map
120		*/
121	79	protected function configureDefinition(EntityDefinition $definition, array $crud)
122		{
123		$toConfigure = [
124	79	'deleteCascade',
125		'listFields',
126		'filter',
127		'childrenLabelFields',
128		'pageSize',
129		'initialSortField',
130		'initialSortAscending',
131		'navBarGroup',
132		'optimisticLocking',
133		'hardDeletion',
134		];
135	79	foreach ($toConfigure as $field) {
136	79	if (array_key_exists($field, $crud)) {
137	79	$function = 'set'.ucfirst($field);
138	79	$definition->$function($crud[$field]);
139		}
140		}
141	79	}
142
143		/**
144		* Creates and setups an EntityDefinition instance.
145		*
146		* @param TranslatorInterface $translator
147		* the Translator to use for some standard field labels
148		* @param EntityDefinitionFactoryInterface $entityDefinitionFactory
149		* the EntityDefinitionFactory to use
150		* @param array $crud
151		* the parsed YAML of a CRUD entity
152		* @param string $name
153		* the name of the entity
154		*
155		* @return EntityDefinition
156		* the EntityDefinition good to go
157		*/
158	79	protected function createDefinition(TranslatorInterface $translator, EntityDefinitionFactoryInterface $entityDefinitionFactory, array $crud, $name)
159		{
160	79	$label = array_key_exists('label', $crud) ? $crud['label'] : $name;
161	79	$localeLabels = $this->getLocaleLabels($crud);
162		$standardFieldLabels = [
163	79	'id' => $translator->trans('crudlex.label.id'),
164	79	'created_at' => $translator->trans('crudlex.label.created_at'),
165	79	'updated_at' => $translator->trans('crudlex.label.updated_at')
166		];
167
168	79	$definition = $entityDefinitionFactory->createEntityDefinition(
169	79	$crud['table'],
170	79	$crud['fields'],
171	79	$label,
172	79	$localeLabels,
173	79	$standardFieldLabels,
174	79	$this
175		);
176	79	$this->configureDefinition($definition, $crud);
177	79	return $definition;
178		}
179
180		/**
181		* Initializes the instance.
182		*
183		* @param string $crudFile
184		* the CRUD YAML file
185		* @param string\|null $crudFileCachingDirectory
186		* the writable directory to store the CRUD YAML file cache
187		* @param UrlGeneratorInterface $urlGenerator
188		* the URL generator to use
189		* @param TranslatorInterface $translator
190		* the translator to use
191		* @param DataFactoryInterface $dataFactory
192		* the data factory to use
193		* @param EntityDefinitionFactoryInterface $entityDefinitionFactory
194		* the EntityDefinitionFactory to use
195		* @param FilesystemInterface $filesystem
196		* the filesystem to use
197		* @param EntityDefinitionValidatorInterface\|null $validator
198		* the validator to use, null if no validation required
199		*/
200	80	public function __construct($crudFile, $crudFileCachingDirectory, UrlGeneratorInterface $urlGenerator, TranslatorInterface $translator, DataFactoryInterface $dataFactory, EntityDefinitionFactoryInterface $entityDefinitionFactory, FilesystemInterface $filesystem, ?EntityDefinitionValidatorInterface $validator)
201		{
202
203	80	$this->urlGenerator = $urlGenerator;
204
205	80	$this->templates = [];
206	80	$this->setTemplate('layout', '@crud/layout.twig');
207
208	80	$reader = new YamlReader($crudFileCachingDirectory);
209	80	$parsedYaml = $reader->read($crudFile);
210
211	79	if ($validator !== null) {
212	79	$validator->validate($parsedYaml);
213		}
214
215	79	$this->datas = [];
216	79	foreach ($parsedYaml as $name => $crud) {
217	79	$definition = $this->createDefinition($translator, $entityDefinitionFactory, $crud, $name);
218	79	$this->datas[$name] = $dataFactory->createData($definition, $filesystem);
219		}
220
221	79	$this->initChildren();
222
223	79	}
224
225		/**
226		* Getter for the AbstractData instances.
227		*
228		* @param string $name
229		* the entity name of the desired Data instance
230		*
231		* @return AbstractData
232		* the AbstractData instance or null on invalid name
233		*/
234	72	public function getData($name)
235		{
236	72	if (!array_key_exists($name, $this->datas)) {
237	10	return null;
238		}
239	72	return $this->datas[$name];
240		}
241
242		/**
243		* Getter for all available entity names.
244		*
245		* @return string[]
246		* a list of all available entity names
247		*/
248	6	public function getEntities()
249		{
250	6	return array_keys($this->datas);
251		}
252
253		/**
254		* Getter for the entities for the navigation bar.
255		*
256		* @return string[]
257		* a list of all available entity names with their group
258		*/
259	11	public function getEntitiesNavBar()
260		{
261	11	$result = [];
262	11	foreach ($this->datas as $entity => $data) {
263	11	$navBarGroup = $data->getDefinition()->getNavBarGroup();
264	11	if ($navBarGroup !== 'main') {
265	11	$result[$navBarGroup][] = $entity;
266		} else {
267		$result[$entity] = 'main';
268		}
269		}
270	11	return $result;
271		}
272
273		/**
274		* Sets a template to use instead of the build in ones.
275		*
276		* @param string $key
277		* the template key to use in this format:
278		* $section.$action.$entity
279		* $section.$action
280		* $section
281		* @param string $template
282		* the template to use for this key
283		*/
284	80	public function setTemplate($key, $template)
285		{
286	80	$this->templates[$key] = $template;
287	80	}
288
289		/**
290		* Determines the Twig template to use for the given parameters depending on
291		* the existance of certain template keys set in this order:
292		*
293		* $section.$action.$entity
294		* $section.$action
295		* $section
296		*
297		* If nothing exists, this string is returned: "@crud/<action>.twig"
298		*
299		* @param string $section
300		* the section of the template, either "layout" or "template"
301		* @param string $action
302		* the current calling action like "create" or "show"
303		* @param string $entity
304		* the current calling entity
305		*
306		* @return string
307		* the best fitting template
308		*/
309	11	public function getTemplate($section, $action, $entity)
310		{
311	11	$sectionAction = $section.'.'.$action;
312
313		$offsets = [
314	11	$sectionAction.'.'.$entity,
315	11	$section.'.'.$entity,
316	11	$sectionAction,
317	11	$section
318		];
319	11	foreach ($offsets as $offset) {
320	11	if (array_key_exists($offset, $this->templates)) {
321	11	return $this->templates[$offset];
322		}
323		}
324
325	11	return '@crud/'.$action.'.twig';
326		}
327
328		/**
329		* Sets the locale to be used.
330		*
331		* @param string $locale
332		* the locale to be used.
333		*/
334	3	public function setLocale($locale)
335		{
336	3	foreach ($this->datas as $data) {
337	3	$data->getDefinition()->setLocale($locale);
338		}
339	3	}
340
341		/**
342		* Gets whether CRUDlex manages the i18n.
343		* @return bool
344		* true if so
345		*/
346	11	public function isManageI18n()
347		{
348	11	return $this->manageI18n;
349		}
350
351		/**
352		* Sets whether CRUDlex manages the i18n.
353		* @param bool $manageI18n
354		* true if so
355		*/
356	1	public function setManageI18n($manageI18n)
357		{
358	1	$this->manageI18n = $manageI18n;
359	1	}
360
361		/**
362		* Generates an URL.
363		* @param string $name
364		* the name of the route
365		* @param mixed $parameters
366		* an array of parameters
367		* @return null\|string
368		* the generated URL
369		*/
370	11	public function generateURL($name, $parameters)
371		{
372	11	return $this->urlGenerator->generate($name, $parameters);
373		}
374
375		}
376

philiplb / CRUDlex

Service::configureDefinition() A last analyzed 2020-08-31 21:30 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Service::configureDefinition() A
last analyzed 2020-08-31 21:30 UTC