AbstractGrid - Code Metrics - Inspection of "CS Fixes" - cwd/cwdFancyGridBundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — develop (bac6db)

by Ludwig

created 2017-11-18 15:05 UTC

AbstractGrid B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	368
Duplicated Lines	5.43 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes

Metric	Value
wmc	42
lcom	1
cbo	9
dl	20
loc	368
rs	8.295
c	0
b	0
f	0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	setTwig()	0	4	1
A	setObjectManager()	0	6	1
A	getId()	0	10	1
A	getOptions()	0	4	1
A	buildGrid()	0	3	1
B	getData()	0	24	4
C	addSearch()	12	39	7
B	parseData()	0	23	4
A	getPager()	0	14	2
A	getPrimaryValue()	0	13	3
A	findPrimary()	0	10	3
A	configureOptions()	0	18	1
A	getColumnDefinition()	0	11	2
A	hasOption()	0	4	1
A	getOption()	0	4	2
A	get()	8	8	2
A	remove()	0	6	1
A	has()	0	4	1
A	all()	0	4	1
A	setChildren()	0	6	1
A	getIterator()	0	4	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like AbstractGrid often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use AbstractGrid, and based on these observations, apply Extract Interface, too.

<?php
/*
 * This file is part of cwdFancyGridBundle
 *
 * (c)2017 cwd.at GmbH <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
declare(strict_types=1);
namespace Cwd\FancyGridBundle\Grid;

use Cwd\FancyGridBundle\Column\AbstractColumn;
use Cwd\FancyGridBundle\Column\ColumnInterface;
use Doctrine\Common\Persistence\ObjectManager;
use Doctrine\ORM\QueryBuilder;
use JMS\Serializer\Serializer;
use JMS\Serializer\SerializerBuilder;
use Pagerfanta\Adapter\DoctrineORMAdapter;
use Pagerfanta\Pagerfanta;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Symfony\Component\PropertyAccess\PropertyAccess;
use Symfony\Component\Translation\TranslatorInterface;

/**
 * Class AbstractGrid
 * @package Cwd\FancyGridBundle\Grid
 * @author Ludwig Ruderstaler <[email protected]>
 */
abstract class AbstractGrid implements GridInterface, \IteratorAggregate
{
    /**
     * @var array
     */
    protected $options;

    /**
     * @var array
     */
    protected $children = [];

    /**
     * @var ObjectManager
     */
    protected $objectManager;

    /**
     * @var TranslatorInterface
     */
    protected $translator;

    /**
     * @var \Symfony\Component\PropertyAccess\PropertyAccessor
     */
    protected $accessor;

    /**
     * @var null|string
     */
    protected $primary = null;

    /**
     * @var \Twig_Environment
     */
    protected $twig;

    /**
     * AbstractGrid constructor.
     * @param array $options
     */
    public function __construct(TranslatorInterface $translator, array $options = array())
    {
        $resolver = new OptionsResolver();
        $this->configureOptions($resolver);

        $this->options = $resolver->resolve($options);
        $this->translator = $translator;
        $this->accessor = PropertyAccess::createPropertyAccessor();
    }

    /**
     * @param \Twig_Environment $twig
     */
    public function setTwig(\Twig_Environment $twig)
    {
        $this->twig = $twig;
    }

    /**
     * @param ObjectManager $objectManager
     * @return $this
     */
    public function setObjectManager($objectManager)
    {
        $this->objectManager = $objectManager;

        return $this;
    }

    /**
     * generate gridid
     * @return string
     */
    public function getId()
    {
        $data = [
            $this->getOption('data_route'),
            $this->getOption('data_route_options'),
            $this->getOption('template'),
        ];

        return md5(serialize($data));
    }

    /**
     * @return array
     */
    public function getOptions() : array
    {
        return $this->options;
    }

    /**
     * {@inheritdoc}
     */
    public function buildGrid(GridBuilderInterface $builder, array $options)
    {
    }

    /**
     * @return array
     */
    public function getData() : array
    {
        $queryBuilder = $this->getQueryBuilder($this->objectManager, $this->getOptions());

        if ($this->getOption('sortField') !== null) {
            $field = $this->getOption('sortField');
            if ($this->has($field)) {
                $column = $this->get($field);
                $queryBuilder->orderBy($column->getField(), $this->getOption('sortDir'));
            }
        }

        if ($this->getOption('filter', false)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $this->addSearch($queryBuilder, $this->all());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }

        $pager = $this->getPager($queryBuilder);

        return [
            'totalCount' => $pager->getNbResults(),
            'data'  => $this->parseData($pager->getCurrentPageResults()),
            'success' => true,
        ];
    }

    /**
     * @param \Doctrine\DBAL\Query\QueryBuilder      $queryBuilder
     * @param ColumnInterface[] $columns
     */
    protected function addSearch($queryBuilder, $columns)

    {
        $filter = json_decode($this->getOption('filter'));
        $where = $queryBuilder->expr()->andX();
        $i = 0;

        foreach ($filter as $filterSearch) {
            if (!$this->has($filterSearch->property)) {
                continue;
            }

            $property = sprintf(':%s%s', $filterSearch->property, $i);

            $column = $this->get($filterSearch->property);

            switch ($filterSearch->operator) {
                case 'like':

                    $where->add($queryBuilder->expr()->like($column->getField(), $property));
                    $queryBuilder->setParameter($property, sprintf('%%%s%%',$filterSearch->value));
                    break;
                case 'gteq':

                    $where->add($queryBuilder->expr()->gte($column->getField(), $property));
                    $queryBuilder->setParameter($property, $filterSearch->value);
                    break;
                case 'lteq':

                    $where->add($queryBuilder->expr()->lte($column->getField(), $property));
                    $queryBuilder->setParameter($property, $filterSearch->value);
                    break;

            }


            $i++;
        }

        if (count($where->getParts()) > 0) {
            $queryBuilder->having($where);
        }
    }

    /**
     * @param array|\Traversable $rows
     * @return array
     */
    protected function parseData($rows)
    {
        $data = [];
        foreach ($rows as $row) {
            $rowData = [];

            foreach ($this->all() as $column) {
                /** @var ColumnInterface $column */
                $value = $column->getValue($row, $column->getName(), $this->findPrimary(), $this->accessor);
                $value = $column->render($value, $row, $this->getPrimaryValue($row), $this->twig);

                if ($column->getOption('translatable', false)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                    $value = $this->translator->trans($value, [], $column->getOption('translation_domain'));
                }

                $rowData[$column->getName()] = $value;
            }

            $data[] = $rowData;
        }

        return $data;
    }

    /**
     * @param QueryBuilder $queryBuilder
     * @return Pagerfanta
     */
    public function getPager(QueryBuilder $queryBuilder)
    {
        $adapter = new DoctrineORMAdapter($queryBuilder, false);
        $pager = new Pagerfanta($adapter);
        $page = $this->getOption('page', 1);
        if ($page < 1) {
            $page = 1;
        }

        $pager->setCurrentPage($page)
              ->setMaxPerPage($this->getOption('limit', 10));

        return $pager;
    }

    /**
     * Get value of primary column
     *
     * @param mixed $object
     *
     * @return mixed
     */
    public function getPrimaryValue($object)
    {
        if ($this->primary === null) {
            $this->primary = $this->findPrimary();
        }

        /** special case when counting */
        if (is_array($object)) {
            $object = $object[0];
        }

        return $this->accessor->getValue($object, $this->primary);
    }

    /**
     * @return null|string
     */
    public function findPrimary()
    {
        foreach ($this->all() as $column) {
            if (true === $column->getOption('identifier')) {
                return $column->getName();
            }
        }

        return null;
    }

    /**
     * @param OptionsResolver $resolver
     */
    public function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setDefaults([
            'template' => 'CwdFancyGridBundle:Grid:template.html.twig',
            'current' => 1,
            'filter' => null,
            'sortField' => null,
            'sortDir' => null,
            'data_route_options' => [],
            'page' => 1,
            'limit' => 20,
        ]);

        $resolver->setRequired([
            'template',
            'data_route',
        ]);
    }

    public function getColumnDefinition()
    {
        $columns = [];
        /** @var AbstractColumn $column */
        foreach ($this->children as $column) {
            $column->setTranslator($this->translator);
            $columns[] = $column->buildColumnOptions();
        }

        return $columns;
    }

    /**
     * @param string $name
     * @return bool
     */
    public function hasOption(string $name)
    {
        return array_key_exists($name, $this->options);
    }

    /**
     * @param string      $name
     * @param string|null $default
     * @return misc
     */
    public function getOption(string $name, $default = null)
    {
        return array_key_exists($name, $this->options) ? $this->options[$name] : $default;
    }

    /**
     * @param string $name
     * @return ColumnInterface
     */
    public function get(string $name) : ColumnInterface

    {
        if (isset($this->children[$name])) {
            return $this->children[$name];
        }

        throw new InvalidArgumentException(sprintf('The child with the name "%s" does not exist.', $name));
    }

    /**
     * @param string $name
     * @return $this
     */
    public function remove(string $name)
    {
        unset($this->children[$name]);

        return $this;
    }

    /**
     * @param string $name
     * @return bool
     */
    public function has(string $name)
    {
        return isset($this->children[$name]);
    }

    /**
     * @return \Cwd\FancyGridBundle\Column\ColumnInterface[]
     */
    public function all()
    {
        return $this->children;
    }

    /**
     * @param array<ColumnInterface> $children
     * @return $this
     */
    public function setChildren($children)
    {
        $this->children = $children;

        return $this;
    }

    /**
     *
     * @return \ArrayIterator
     */
    public function getIterator()
    {
        return new \ArrayIterator($this->all());
    }
}


1		<?php
2		/*
3		* This file is part of cwdFancyGridBundle
4		*
5		* (c)2017 cwd.at GmbH <[email protected]>
6		*
7		* For the full copyright and license information, please view the LICENSE
8		* file that was distributed with this source code.
9		*/
10		declare(strict_types=1);
11		namespace Cwd\FancyGridBundle\Grid;
12
13		use Cwd\FancyGridBundle\Column\AbstractColumn;
14		use Cwd\FancyGridBundle\Column\ColumnInterface;
15		use Doctrine\Common\Persistence\ObjectManager;
16		use Doctrine\ORM\QueryBuilder;
17		use JMS\Serializer\Serializer;
18		use JMS\Serializer\SerializerBuilder;
19		use Pagerfanta\Adapter\DoctrineORMAdapter;
20		use Pagerfanta\Pagerfanta;
21		use Symfony\Component\OptionsResolver\OptionsResolver;
22		use Symfony\Component\PropertyAccess\PropertyAccess;
23		use Symfony\Component\Translation\TranslatorInterface;
24
25		/**
26		* Class AbstractGrid
27		* @package Cwd\FancyGridBundle\Grid
28		* @author Ludwig Ruderstaler <[email protected]>
29		*/
30		abstract class AbstractGrid implements GridInterface, \IteratorAggregate
31		{
32		/**
33		* @var array
34		*/
35		protected $options;
36
37		/**
38		* @var array
39		*/
40		protected $children = [];
41
42		/**
43		* @var ObjectManager
44		*/
45		protected $objectManager;
46
47		/**
48		* @var TranslatorInterface
49		*/
50		protected $translator;
51
52		/**
53		* @var \Symfony\Component\PropertyAccess\PropertyAccessor
54		*/
55		protected $accessor;
56
57		/**
58		* @var null\|string
59		*/
60		protected $primary = null;
61
62		/**
63		* @var \Twig_Environment
64		*/
65		protected $twig;
66
67		/**
68		* AbstractGrid constructor.
69		* @param array $options
70		*/
71		public function __construct(TranslatorInterface $translator, array $options = array())
72		{
73		$resolver = new OptionsResolver();
74		$this->configureOptions($resolver);
75
76		$this->options = $resolver->resolve($options);
77		$this->translator = $translator;
78		$this->accessor = PropertyAccess::createPropertyAccessor();
79		}
80
81		/**
82		* @param \Twig_Environment $twig
83		*/
84		public function setTwig(\Twig_Environment $twig)
85		{
86		$this->twig = $twig;
87		}
88
89		/**
90		* @param ObjectManager $objectManager
91		* @return $this
92		*/
93		public function setObjectManager($objectManager)
94		{
95		$this->objectManager = $objectManager;
96
97		return $this;
98		}
99
100		/**
101		* generate gridid
102		* @return string
103		*/
104		public function getId()
105		{
106		$data = [
107		$this->getOption('data_route'),
108		$this->getOption('data_route_options'),
109		$this->getOption('template'),
110		];
111
112		return md5(serialize($data));
113		}
114
115		/**
116		* @return array
117		*/
118		public function getOptions() : array
119		{
120		return $this->options;
121		}
122
123		/**
124		* {@inheritdoc}
125		*/
126		public function buildGrid(GridBuilderInterface $builder, array $options)
127		{
128		}
129
130		/**
131		* @return array
132		*/
133		public function getData() : array
134		{
135		$queryBuilder = $this->getQueryBuilder($this->objectManager, $this->getOptions());
136
137		if ($this->getOption('sortField') !== null) {
138		$field = $this->getOption('sortField');
139		if ($this->has($field)) {
140		$column = $this->get($field);
141		$queryBuilder->orderBy($column->getField(), $this->getOption('sortDir'));
142		}
143		}
144
145		if ($this->getOption('filter', false)) {
		0 ignored issues – show Documentation introduced 2017-11-18 11:44 UTC by Report Bug Copy Issue Report `false` is of type `boolean`, but the function expects a `string\|null`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
146		$this->addSearch($queryBuilder, $this->all());
		0 ignored issues – show Documentation introduced 2017-11-18 11:44 UTC by Report Bug Copy Issue Report `$queryBuilder` is of type `object<Doctrine\ORM\QueryBuilder>`, but the function expects a `object<Doctrine\DBAL\Query\QueryBuilder>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
147		}
148
149		$pager = $this->getPager($queryBuilder);
150
151		return [
152		'totalCount' => $pager->getNbResults(),
153		'data' => $this->parseData($pager->getCurrentPageResults()),
154		'success' => true,
155		];
156		}
157
158		/**
159		* @param \Doctrine\DBAL\Query\QueryBuilder $queryBuilder
160		* @param ColumnInterface[] $columns
161		*/
162		protected function addSearch($queryBuilder, $columns)
		0 ignored issues – show Unused Code introduced 2017-11-18 11:44 UTC by Report Bug Copy Issue Report The parameter `$columns` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
163		{
164		$filter = json_decode($this->getOption('filter'));
165		$where = $queryBuilder->expr()->andX();
166		$i = 0;
167
168		foreach ($filter as $filterSearch) {
169		if (!$this->has($filterSearch->property)) {
170		continue;
171		}
172
173		$property = sprintf(':%s%s', $filterSearch->property, $i);
174
175		$column = $this->get($filterSearch->property);
176
177		switch ($filterSearch->operator) {
178	View Code Duplication	case 'like':
		1 ignored issue – show Duplication introduced 2017-11-18 15:09 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
179		$where->add($queryBuilder->expr()->like($column->getField(), $property));
180		$queryBuilder->setParameter($property, sprintf('%%%s%%',$filterSearch->value));
181		break;
182	View Code Duplication	case 'gteq':
		1 ignored issue – show Duplication introduced 2017-11-18 15:09 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
183		$where->add($queryBuilder->expr()->gte($column->getField(), $property));
184		$queryBuilder->setParameter($property, $filterSearch->value);
185		break;
186	View Code Duplication	case 'lteq':
		1 ignored issue – show Duplication introduced 2017-11-18 15:09 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
187		$where->add($queryBuilder->expr()->lte($column->getField(), $property));
188		$queryBuilder->setParameter($property, $filterSearch->value);
189		break;
190
191		}
192
193
194		$i++;
195		}
196
197		if (count($where->getParts()) > 0) {
198		$queryBuilder->having($where);
199		}
200		}
201
202		/**
203		* @param array\|\Traversable $rows
204		* @return array
205		*/
206		protected function parseData($rows)
207		{
208		$data = [];
209		foreach ($rows as $row) {
210		$rowData = [];
211
212		foreach ($this->all() as $column) {
213		/** @var ColumnInterface $column */
214		$value = $column->getValue($row, $column->getName(), $this->findPrimary(), $this->accessor);
215		$value = $column->render($value, $row, $this->getPrimaryValue($row), $this->twig);
216
217		if ($column->getOption('translatable', false)) {
		0 ignored issues – show Documentation introduced 2017-11-18 11:44 UTC by Report Bug Copy Issue Report `false` is of type `boolean`, but the function expects a `string\|null`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
218		$value = $this->translator->trans($value, [], $column->getOption('translation_domain'));
219		}
220
221		$rowData[$column->getName()] = $value;
222		}
223
224		$data[] = $rowData;
225		}
226
227		return $data;
228		}
229
230		/**
231		* @param QueryBuilder $queryBuilder
232		* @return Pagerfanta
233		*/
234		public function getPager(QueryBuilder $queryBuilder)
235		{
236		$adapter = new DoctrineORMAdapter($queryBuilder, false);
237		$pager = new Pagerfanta($adapter);
238		$page = $this->getOption('page', 1);
239		if ($page < 1) {
240		$page = 1;
241		}
242
243		$pager->setCurrentPage($page)
244		->setMaxPerPage($this->getOption('limit', 10));
245
246		return $pager;
247		}
248
249		/**
250		* Get value of primary column
251		*
252		* @param mixed $object
253		*
254		* @return mixed
255		*/
256		public function getPrimaryValue($object)
257		{
258		if ($this->primary === null) {
259		$this->primary = $this->findPrimary();
260		}
261
262		/** special case when counting */
263		if (is_array($object)) {
264		$object = $object[0];
265		}
266
267		return $this->accessor->getValue($object, $this->primary);
268		}
269
270		/**
271		* @return null\|string
272		*/
273		public function findPrimary()
274		{
275		foreach ($this->all() as $column) {
276		if (true === $column->getOption('identifier')) {
277		return $column->getName();
278		}
279		}
280
281		return null;
282		}
283
284		/**
285		* @param OptionsResolver $resolver
286		*/
287		public function configureOptions(OptionsResolver $resolver)
288		{
289		$resolver->setDefaults([
290		'template' => 'CwdFancyGridBundle:Grid:template.html.twig',
291		'current' => 1,
292		'filter' => null,
293		'sortField' => null,
294		'sortDir' => null,
295		'data_route_options' => [],
296		'page' => 1,
297		'limit' => 20,
298		]);
299
300		$resolver->setRequired([
301		'template',
302		'data_route',
303		]);
304		}
305
306		public function getColumnDefinition()
307		{
308		$columns = [];
309		/** @var AbstractColumn $column */
310		foreach ($this->children as $column) {
311		$column->setTranslator($this->translator);
312		$columns[] = $column->buildColumnOptions();
313		}
314
315		return $columns;
316		}
317
318		/**
319		* @param string $name
320		* @return bool
321		*/
322		public function hasOption(string $name)
323		{
324		return array_key_exists($name, $this->options);
325		}
326
327		/**
328		* @param string $name
329		* @param string\|null $default
330		* @return misc
331		*/
332		public function getOption(string $name, $default = null)
333		{
334		return array_key_exists($name, $this->options) ? $this->options[$name] : $default;
335		}
336
337		/**
338		* @param string $name
339		* @return ColumnInterface
340		*/
341	View Code Duplication	public function get(string $name) : ColumnInterface
		1 ignored issue – show Duplication introduced 2017-11-18 15:09 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
342		{
343		if (isset($this->children[$name])) {
344		return $this->children[$name];
345		}
346
347		throw new InvalidArgumentException(sprintf('The child with the name "%s" does not exist.', $name));
348		}
349
350		/**
351		* @param string $name
352		* @return $this
353		*/
354		public function remove(string $name)
355		{
356		unset($this->children[$name]);
357
358		return $this;
359		}
360
361		/**
362		* @param string $name
363		* @return bool
364		*/
365		public function has(string $name)
366		{
367		return isset($this->children[$name]);
368		}
369
370		/**
371		* @return \Cwd\FancyGridBundle\Column\ColumnInterface[]
372		*/
373		public function all()
374		{
375		return $this->children;
376		}
377
378		/**
379		* @param array<ColumnInterface> $children
380		* @return $this
381		*/
382		public function setChildren($children)
383		{
384		$this->children = $children;
385
386		return $this;
387		}
388
389		/**
390		*
391		* @return \ArrayIterator
392		*/
393		public function getIterator()
394		{
395		return new \ArrayIterator($this->all());
396		}
397		}
398

cwd / cwdFancyGridBundle