Standard::makePlural() - Code Metrics - Inspection of "Date facet has a `today` feature #9303" - Ecodev/my-ichtus - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( b734ba...da8304 )

by Adrien

created 2023-01-12 11:39 UTC

Standard::makePlural() A

↳ Parent: Standard

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
eloc	4
nc	1
nop	1
dl	0
loc	7
ccs	5
cts	5
cp	1
crap	1
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace Application\Api\Field;

use Application\Api\Helper;
use Application\Model\AbstractModel;
use Application\Model\Account;
use Application\Model\Bookable;
use Application\Model\ExpenseClaim;
use Application\Model\TransactionLine;
use Application\Model\User;
use Doctrine\ORM\QueryBuilder;
use Ecodev\Felix\Api\Input\PaginationInputType;
use GraphQL\Type\Definition\Type;
use Money\Money;
use ReflectionClass;

/**
 * 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($class);
        $singleArgs = self::getSingleArguments($class);

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

                    $items = Helper::paginate($args['pagination'], $qb);
                    $aggregatedFields = Helper::aggregatedFields($class, $qb);
                    $result = array_merge($aggregatedFields, $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) use ($class): AbstractModel {
                    $object = $args['id']->getEntity();

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

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

                    _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;
                },
            ],
        ];
    }

    private static function filterInput(string $class, array $input): array
    {
        $user = User::getCurrent();
        if ($class === Bookable::class && $user && $user->getRole() === User::ROLE_TRAINER) {
            // whitelist
            $input = array_intersect_key($input, array_flip(['remarks']));
        }

        return $input;
    }

    /**
     * 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.
     */
    public static function getListArguments(string $class, bool $includePagination = true): array
    {
        $listArgs = [
            [
                'name' => 'filter',
                'type' => _types()->getFilter($class),
            ],
            [
                'name' => 'sorting',
                'type' => _types()->getSorting($class),
                'defaultValue' => self::getDefaultSorting($class),
            ],
        ];

        if ($includePagination) {
            $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(string $class): array
    {
        $defaultSorting = [];

        if ($class === Account::class) {
            $defaultSorting[] = [
                'field' => 'code',
                'order' => 'ASC',
            ];
        } elseif ($class === TransactionLine::class) {
            $defaultSorting[] = [
                'field' => 'transactionDate',
                'order' => 'DESC',
            ];
        } elseif ($class === ExpenseClaim::class) {
            $defaultSorting[] = [
                'field' => 'creationDate',
                '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;
    }

    public static function createFilteredQueryBuilder(string $class, array $args): QueryBuilder
    {
        $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($class);
        }

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

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

        return $qb;
    }
}


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

Ecodev / my-ichtus

Push — master ( b734ba...da8304 )

Standard::makePlural() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like