Standard::customTypesToScalar() - Code Metrics - Inspection of "Travis on bionic to get composer 2" - Ecodev/my-ichtus - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 3ba489...3505e6 )

by Adrien

created 2020-10-30 10:48 UTC

Standard::customTypesToScalar() A

↳ Parent: Standard

Complexity

Conditions	4
Paths	4

Size

Total Lines	11
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	6.9849

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	4
eloc	6
c	1
b	0
f	0
nc	4
nop	1
dl	0
loc	11
rs	10
ccs	3
cts	7
cp	0.4286
crap	6.9849

<?php

declare(strict_types=1);

namespace Application\Api\Field;

use Application\Api\Helper;
use Application\Model\AbstractModel;
use Application\Model\Account;
use Application\Model\TransactionLine;
use Doctrine\ORM\Mapping\ClassMetadata;
use Ecodev\Felix\Api\Input\PaginationInputType;
use GraphQL\Type\Definition\Type;
use Money\Money;
use ReflectionClass;
use ReflectionException;

/**
 * Provide easy way to build standard fields to query and mutate objects
 */
abstract class Standard
{
    /**
     * Returns standard fields to query the object
     */
    public static function buildQuery(string $class): array
    {
        $metadata = _em()->getClassMetadata($class);
        $reflect = $metadata->getReflectionClass();
        $name = lcfirst($reflect->getShortName());
        $shortName = $reflect->getShortName();
        $plural = self::makePlural($name);

        $listArgs = self::getListArguments($metadata);
        $singleArgs = self::getSingleArguments($class);

        return [
            [
                'name' => $plural,
                'type' => Type::nonNull(_types()->get($shortName . 'Pagination')),
                'args' => $listArgs,
                'resolve' => function ($root, array $args) use ($class, $metadata): array {
                    $filters = self::customTypesToScalar($args['filter'] ?? []);

                    // If null or empty list is provided by client, fallback on default sorting
                    $sorting = $args['sorting'] ?? [];
                    if (!$sorting) {
                        $sorting = self::getDefaultSorting($metadata);
                    }

                    // And **always** sort by ID
                    $sorting[] = [
                        'field' => 'id',
                        'order' => 'ASC',
                    ];

                    $qb = _types()->createFilteredQueryBuilder($class, $filters, $sorting);

                    $items = Helper::paginate($args['pagination'], $qb);
                    $exportExcelField = Helper::excelExportField($class, $qb);
                    $aggregatedFields = Helper::aggregatedFields($class, $qb);
                    $result = array_merge($aggregatedFields, $exportExcelField, $items);

                    return $result;
                },
            ],
            [
                'name' => $name,
                'type' => Type::nonNull(_types()->getOutput($class)),
                'args' => $singleArgs,
                'resolve' => function ($root, array $args): ?AbstractModel {
                    $object = $args['id']->getEntity();

                    Helper::throwIfDenied($object, 'read');

                    return $object;
                },
            ],
        ];
    }

    /**
     * Returns standard fields to mutate the object
     */
    public static function buildMutation(string $class): array
    {
        $reflect = new ReflectionClass($class);
        $name = $reflect->getShortName();
        $plural = self::makePlural($name);

        return [
            [
                'name' => 'create' . $name,
                'type' => Type::nonNull(_types()->getOutput($class)),
                'description' => 'Create a new ' . $name,
                'args' => [
                    'input' => Type::nonNull(_types()->getInput($class)),
                ],
                'resolve' => function ($root, array $args) use ($class): AbstractModel {
                    // Do it
                    $object = new $class();
                    $input = $args['input'];
                    Helper::hydrate($object, $input);

                    // Check ACL
                    Helper::throwIfDenied($object, 'create');

                    _em()->persist($object);
                    _em()->flush();

                    return $object;
                },
            ],
            [
                'name' => 'update' . $name,
                'type' => Type::nonNull(_types()->getOutput($class)),
                'description' => 'Update an existing ' . $name,
                'args' => [
                    'id' => Type::nonNull(_types()->getId($class)),
                    'input' => Type::nonNull(_types()->getPartialInput($class)),
                ],
                'resolve' => function ($root, array $args): AbstractModel {
                    $object = $args['id']->getEntity();

                    // Check ACL
                    Helper::throwIfDenied($object, 'update');

                    // Do it
                    $input = $args['input'];
                    Helper::hydrate($object, $input);

                    _em()->flush();

                    return $object;
                },
            ],
            [
                'name' => 'delete' . $plural,
                'type' => Type::nonNull(Type::boolean()),
                'description' => 'Delete one or several existing ' . $name,
                'args' => [
                    'ids' => Type::nonNull(Type::listOf(Type::nonNull(_types()->getId($class)))),
                ],
                'resolve' => function ($root, array $args): bool {
                    foreach ($args['ids'] as $id) {
                        $object = $id->getEntity();

                        // Check ACL
                        Helper::throwIfDenied($object, 'delete');

                        // Do it
                        _em()->remove($object);
                    }

                    _em()->flush();

                    return true;
                },
            ],
        ];
    }

    /**
     * Returns standard mutations to manage many-to-many relations between two given class
     *
     * @param string $ownerClass The class owning the relation
     * @param string $otherClass The other class, not-owning the relation
     * @param null|string $otherName a specific semantic, if needed, to be use as adder. If `$otherName = 'Parent'`, then we will call `addParent()`
     */
    public static function buildRelationMutation(string $ownerClass, string $otherClass, ?string $otherName = null): array
    {
        $ownerReflect = new ReflectionClass($ownerClass);
        $ownerName = $ownerReflect->getShortName();
        $lowerOwnerName = lcfirst($ownerName);

        $otherReflect = new ReflectionClass($otherClass);
        $otherClassName = $otherReflect->getShortName();
        if ($otherName) {
            $semantic = ' as ' . $otherName;
        } else {
            $semantic = '';
            $otherName = $otherClassName;
        }
        $lowerOtherName = lcfirst($otherName);

        if ($lowerOwnerName === $lowerOtherName) {
            $lowerOwnerName .= 1;
            $lowerOtherName .= 2;
        }

        $args = [
            $lowerOwnerName => Type::nonNull(_types()->getId($ownerClass)),
            $lowerOtherName => Type::nonNull(_types()->getId($otherClass)),
        ];

        return [
            [
                'name' => 'link' . $ownerName . $otherName,
                'type' => Type::nonNull(_types()->getOutput($ownerClass)),
                'description' => 'Create a relation between ' . $ownerName . ' and ' . $otherClassName . $semantic . '.' . PHP_EOL . PHP_EOL .
                    'If the relation already exists, it will have no effect.',
                'args' => $args,
                'resolve' => function ($root, array $args) use ($lowerOwnerName, $lowerOtherName, $otherName): AbstractModel {
                    $owner = $args[$lowerOwnerName]->getEntity();
                    $other = $args[$lowerOtherName]->getEntity();

                    // Check ACL
                    Helper::throwIfDenied($owner, 'update');

                    // Do it
                    $method = 'add' . $otherName;
                    $owner->$method($other);
                    _em()->flush();

                    return $owner;
                },
            ],
            [
                'name' => 'unlink' . $ownerName . $otherName,
                'type' => Type::nonNull(_types()->getOutput($ownerClass)),
                'description' => 'Delete a relation between ' . $ownerName . ' and ' . $otherClassName . $semantic . '.' . PHP_EOL . PHP_EOL .
                    'If the relation does not exist, it will have no effect.',
                'args' => $args,
                'resolve' => function ($root, array $args) use ($lowerOwnerName, $lowerOtherName, $otherName): AbstractModel {
                    $owner = $args[$lowerOwnerName]->getEntity();
                    $other = $args[$lowerOtherName]->getEntity();

                    // Check ACL
                    Helper::throwIfDenied($owner, 'update');

                    // Do it
                    if ($other) {
                        $method = 'remove' . $otherName;
                        $owner->$method($other);
                        _em()->flush();
                    }

                    return $owner;
                },
            ],
        ];
    }

    /**
     * Returns the plural form of the given name
     */
    private static function makePlural(string $name): string
    {
        $plural = $name . 's';
        $plural = preg_replace('/ys$/', 'ies', $plural);
        $plural = preg_replace('/ss$/', 'ses', $plural);

        return $plural;
    }

    /**
     * Return arguments used for the list
     */
    private static function getListArguments(ClassMetadata $class): array
    {
        $listArgs = [
            [
                'name' => 'filter',
                'type' => _types()->getFilter($class->getName()),
            ],
            [
                'name' => 'sorting',
                'type' => _types()->getSorting($class->getName()),
                'defaultValue' => self::getDefaultSorting($class),
            ],
        ];

        $listArgs[] = PaginationInputType::build(_types());

        return $listArgs;
    }

    /**
     * Return arguments used for single item
     */
    private static function getSingleArguments(string $class): array
    {
        $args = [
            'id' => Type::nonNull(_types()->getId($class)),
        ];

        return $args;
    }

    /**
     * Get default sorting values with some fallback for some special cases
     */
    private static function getDefaultSorting(ClassMetadata $metadata): array
    {
        $defaultSorting = [];

        $class = $metadata->getName();
        if ($class === Account::class) {
            $defaultSorting[] = [
                'field' => 'code',
                'order' => 'ASC',
            ];
        } elseif ($class === TransactionLine::class) {
            $defaultSorting[] = [
                'field' => 'transactionDate',
                'order' => 'DESC',
            ];
        }

        return $defaultSorting;
    }

    /**
     * Recursively convert custom scalars that don't implement __toString() to their scalar
     * representation to injected back into DQL/SQL
     */
    private static function customTypesToScalar(array $args): array
    {
        foreach ($args as &$p) {
            if (is_array($p)) {
                $p = self::customTypesToScalar($p);
            } elseif ($p instanceof Money) {
                $p = $p->getAmount();
            }
        }

        return $args;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Application\Api\Field;
6
7		use Application\Api\Helper;
8		use Application\Model\AbstractModel;
9		use Application\Model\Account;
10		use Application\Model\TransactionLine;
11		use Doctrine\ORM\Mapping\ClassMetadata;
12		use Ecodev\Felix\Api\Input\PaginationInputType;
13		use GraphQL\Type\Definition\Type;
14		use Money\Money;
15		use ReflectionClass;
16		use ReflectionException;
17
18		/**
19		* Provide easy way to build standard fields to query and mutate objects
20		*/
21		abstract class Standard
22		{
23		/**
24		* Returns standard fields to query the object
25		*/
26	6	public static function buildQuery(string $class): array
27		{
28	1	$metadata = _em()->getClassMetadata($class);
29	1	$reflect = $metadata->getReflectionClass();
30	1	$name = lcfirst($reflect->getShortName());
31	1	$shortName = $reflect->getShortName();
32	1	$plural = self::makePlural($name);
33
34	1	$listArgs = self::getListArguments($metadata);
35	1	$singleArgs = self::getSingleArguments($class);
36
37		return [
38		[
39	1	'name' => $plural,
40	1	'type' => Type::nonNull(_types()->get($shortName . 'Pagination')),
41	1	'args' => $listArgs,
42	6	'resolve' => function ($root, array $args) use ($class, $metadata): array {
43	5	$filters = self::customTypesToScalar($args['filter'] ?? []);
44
45		// If null or empty list is provided by client, fallback on default sorting
46	5	$sorting = $args['sorting'] ?? [];
47	5	if (!$sorting) {
48	4	$sorting = self::getDefaultSorting($metadata);
49		}
50
51		// And always sort by ID
52	5	$sorting[] = [
53		'field' => 'id',
54		'order' => 'ASC',
55		];
56
57	5	$qb = _types()->createFilteredQueryBuilder($class, $filters, $sorting);
58
59	5	$items = Helper::paginate($args['pagination'], $qb);
60	5	$exportExcelField = Helper::excelExportField($class, $qb);
61	5	$aggregatedFields = Helper::aggregatedFields($class, $qb);
62	5	$result = array_merge($aggregatedFields, $exportExcelField, $items);
63
64	5	return $result;
65	1	},
66		],
67		[
68	1	'name' => $name,
69	1	'type' => Type::nonNull(_types()->getOutput($class)),
70	1	'args' => $singleArgs,
71	1	'resolve' => function ($root, array $args): ?AbstractModel {
72	3	$object = $args['id']->getEntity();
73
74	2	Helper::throwIfDenied($object, 'read');
75
76	2	return $object;
77	1	},
78		],
79		];
80		}
81
82		/**
83		* Returns standard fields to mutate the object
84		*/
85	5	public static function buildMutation(string $class): array
86		{
87	1	$reflect = new ReflectionClass($class);
88	1	$name = $reflect->getShortName();
89	1	$plural = self::makePlural($name);
90
91		return [
92		[
93	1	'name' => 'create' . $name,
94	1	'type' => Type::nonNull(_types()->getOutput($class)),
95	1	'description' => 'Create a new ' . $name,
96		'args' => [
97	1	'input' => Type::nonNull(_types()->getInput($class)),
98		],
99	5	'resolve' => function ($root, array $args) use ($class): AbstractModel {
100		// Do it
101	4	$object = new $class();
102	4	$input = $args['input'];
103	4	Helper::hydrate($object, $input);
104
105		// Check ACL
106	4	Helper::throwIfDenied($object, 'create');
107
108	3	_em()->persist($object);
109	3	_em()->flush();
110
111	3	return $object;
112	1	},
113		],
114		[
115	1	'name' => 'update' . $name,
116	1	'type' => Type::nonNull(_types()->getOutput($class)),
117	1	'description' => 'Update an existing ' . $name,
118		'args' => [
119	1	'id' => Type::nonNull(_types()->getId($class)),
120	1	'input' => Type::nonNull(_types()->getPartialInput($class)),
121		],
122	1	'resolve' => function ($root, array $args): AbstractModel {
123	3	$object = $args['id']->getEntity();
124
125		// Check ACL
126	3	Helper::throwIfDenied($object, 'update');
127
128		// Do it
129	2	$input = $args['input'];
130	2	Helper::hydrate($object, $input);
131
132	2	_em()->flush();
133
134	2	return $object;
135	1	},
136		],
137		[
138	1	'name' => 'delete' . $plural,
139	1	'type' => Type::nonNull(Type::boolean()),
140	1	'description' => 'Delete one or several existing ' . $name,
141		'args' => [
142	1	'ids' => Type::nonNull(Type::listOf(Type::nonNull(_types()->getId($class)))),
143		],
144	1	'resolve' => function ($root, array $args): bool {
145	1	foreach ($args['ids'] as $id) {
146	1	$object = $id->getEntity();
147
148		// Check ACL
149	1	Helper::throwIfDenied($object, 'delete');
150
151		// Do it
152		_em()->remove($object);
153		}
154
155		_em()->flush();
156
157		return true;
158	1	},
159		],
160		];
161		}
162
163		/**
164		* Returns standard mutations to manage many-to-many relations between two given class
165		*
166		* @param string $ownerClass The class owning the relation
167		* @param string $otherClass The other class, not-owning the relation
168		* @param null\|string $otherName a specific semantic, if needed, to be use as adder. If `$otherName = 'Parent'`, then we will call `addParent()`
169		*/
170	1	public static function buildRelationMutation(string $ownerClass, string $otherClass, ?string $otherName = null): array
171		{
172	1	$ownerReflect = new ReflectionClass($ownerClass);
173	1	$ownerName = $ownerReflect->getShortName();
174	1	$lowerOwnerName = lcfirst($ownerName);
175
176	1	$otherReflect = new ReflectionClass($otherClass);
177	1	$otherClassName = $otherReflect->getShortName();
178	1	if ($otherName) {
179	1	$semantic = ' as ' . $otherName;
180		} else {
181	1	$semantic = '';
182	1	$otherName = $otherClassName;
183		}
184	1	$lowerOtherName = lcfirst($otherName);
185
186	1	if ($lowerOwnerName === $lowerOtherName) {
187		$lowerOwnerName .= 1;
188		$lowerOtherName .= 2;
189		}
190
191		$args = [
192	1	$lowerOwnerName => Type::nonNull(_types()->getId($ownerClass)),
193	1	$lowerOtherName => Type::nonNull(_types()->getId($otherClass)),
194		];
195
196		return [
197		[
198	1	'name' => 'link' . $ownerName . $otherName,
199	1	'type' => Type::nonNull(_types()->getOutput($ownerClass)),
200	1	'description' => 'Create a relation between ' . $ownerName . ' and ' . $otherClassName . $semantic . '.' . PHP_EOL . PHP_EOL .
201	1	'If the relation already exists, it will have no effect.',
202	1	'args' => $args,
203	1	'resolve' => function ($root, array $args) use ($lowerOwnerName, $lowerOtherName, $otherName): AbstractModel {
204		$owner = $args[$lowerOwnerName]->getEntity();
205		$other = $args[$lowerOtherName]->getEntity();
206
207		// Check ACL
208		Helper::throwIfDenied($owner, 'update');
209
210		// Do it
211		$method = 'add' . $otherName;
212		$owner->$method($other);
213		_em()->flush();
214
215		return $owner;
216	1	},
217		],
218		[
219	1	'name' => 'unlink' . $ownerName . $otherName,
220	1	'type' => Type::nonNull(_types()->getOutput($ownerClass)),
221	1	'description' => 'Delete a relation between ' . $ownerName . ' and ' . $otherClassName . $semantic . '.' . PHP_EOL . PHP_EOL .
222	1	'If the relation does not exist, it will have no effect.',
223	1	'args' => $args,
224	1	'resolve' => function ($root, array $args) use ($lowerOwnerName, $lowerOtherName, $otherName): AbstractModel {
225		$owner = $args[$lowerOwnerName]->getEntity();
226		$other = $args[$lowerOtherName]->getEntity();
227
228		// Check ACL
229		Helper::throwIfDenied($owner, 'update');
230
231		// Do it
232		if ($other) {
233		$method = 'remove' . $otherName;
234		$owner->$method($other);
235		_em()->flush();
236		}
237
238		return $owner;
239	1	},
240		],
241		];
242		}
243
244		/**
245		* Returns the plural form of the given name
246		*/
247	1	private static function makePlural(string $name): string
248		{
249	1	$plural = $name . 's';
250	1	$plural = preg_replace('/ys$/', 'ies', $plural);
251	1	$plural = preg_replace('/ss$/', 'ses', $plural);
252
253	1	return $plural;
254		}
255
256		/**
257		* Return arguments used for the list
258		*/
259	1	private static function getListArguments(ClassMetadata $class): array
260		{
261		$listArgs = [
262		[
263	1	'name' => 'filter',
264	1	'type' => _types()->getFilter($class->getName()),
265		],
266		[
267	1	'name' => 'sorting',
268	1	'type' => _types()->getSorting($class->getName()),
269	1	'defaultValue' => self::getDefaultSorting($class),
270		],
271		];
272
273	1	$listArgs[] = PaginationInputType::build(_types());
274
275	1	return $listArgs;
276		}
277
278		/**
279		* Return arguments used for single item
280		*/
281	1	private static function getSingleArguments(string $class): array
282		{
283		$args = [
284	1	'id' => Type::nonNull(_types()->getId($class)),
285		];
286
287	1	return $args;
288		}
289
290		/**
291		* Get default sorting values with some fallback for some special cases
292		*/
293	5	private static function getDefaultSorting(ClassMetadata $metadata): array
294		{
295	5	$defaultSorting = [];
296
297	5	$class = $metadata->getName();
298	5	if ($class === Account::class) {
299	1	$defaultSorting[] = [
300	1	'field' => 'code',
301		'order' => 'ASC',
302		];
303	5	} elseif ($class === TransactionLine::class) {
304	1	$defaultSorting[] = [
305		'field' => 'transactionDate',
306		'order' => 'DESC',
307		];
308		}
309
310	5	return $defaultSorting;
311		}
312
313		/**
314		* Recursively convert custom scalars that don't implement __toString() to their scalar
315		* representation to injected back into DQL/SQL
316		*/
317	5	private static function customTypesToScalar(array $args): array
318		{
319	5	foreach ($args as &$p) {
320		if (is_array($p)) {
321		$p = self::customTypesToScalar($p);
322		} elseif ($p instanceof Money) {
323		$p = $p->getAmount();
324		}
325		}
326
327	5	return $args;
328		}
329		}
330

Ecodev / my-ichtus

Push — master ( 3ba489...3505e6 )

Standard::customTypesToScalar() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like