GenericEntityCreateController::__invoke() - Code Metrics - Inspection of "return of the test improver" - addiks/symfony_generics - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 50ffe0...5d273a )

by Gerrit

created 2019-05-29 18:27 UTC

GenericEntityCreateController::__invoke() A

↳ Parent: GenericEntityCreateController

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	9
ccs	4
cts	4
cp	1
rs	9.9666
c	0
b	0
f	0
cc	1
nc	1
nop	0
crap	1

<?php
/**
 * Copyright (C) 2018 Gerrit Addiks.
 * This package (including this file) was released under the terms of the GPL-3.0.
 * You should have received a copy of the GNU General Public License along with this program.
 * If not, see <http://www.gnu.org/licenses/> or send me a mail so i can send you a copy.
 *
 * @license GPL-3.0
 *
 * @author Gerrit Addiks <[email protected]>
 */

namespace Addiks\SymfonyGenerics\Controllers\API;

use Addiks\SymfonyGenerics\Controllers\ControllerHelperInterface;
use Addiks\SymfonyGenerics\Services\ArgumentCompilerInterface;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpFoundation\Request;
use Webmozart\Assert\Assert;
use ReflectionClass;
use ReflectionMethod;
use Psr\Container\ContainerInterface;
use ErrorException;
use ReflectionFunction;
use ReflectionFunctionAbstract;
use ReflectionObject;
use Addiks\SymfonyGenerics\Events\EntityInteractionEvent;

final class GenericEntityCreateController
{

    /**
     * @var ControllerHelperInterface
     */
    private $controllerHelper;

    /**
     * @var ContainerInterface
     */
    private $container;

    /**
     * @var string
     */
    private $entityClass;

    /**
     * @var array<string, array<string, mixed>>
     */
    private $calls = array();

    /**
     * @var string|null
     */
    private $factory = null;

    /**
     * @var array<string, mixed>
     */
    private $constructArguments = array();

    /**
     * @var ArgumentCompilerInterface
     */
    private $argumentBuilder;

    /**
     * @var string
     */
    private $successResponse;

    /**
     * @var string|null
     */
    private $authorizationAttribute;

    /**
     * @var string|null
     */
    private $successRedirectRoute;

    /**
     * @var array
     */
    private $successRedirectArguments;

    /**
     * @var int
     */
    private $successRedirectStatus;

    /**
     * @var string
     */
    private $entityIdKey;

    /**
     * @var string
     */
    private $entityIdGetter;

    public function __construct(
        ControllerHelperInterface $controllerHelper,
        ArgumentCompilerInterface $argumentBuilder,
        ContainerInterface $container,
        array $options
    ) {
        Assert::null($this->controllerHelper);
        Assert::keyExists($options, 'entity-class');

        /** @var int $defaultRedirectStatus */
        $defaultRedirectStatus = 303;

        $options = array_merge([
            'calls' => [],
            'success-response' => "object created",
            'factory' => null,
            'authorization-attribute' => null,
            'arguments' => [],
            'success-redirect' => null,
            'success-redirect-arguments' => [],
            'success-redirect-status' => $defaultRedirectStatus,
            'entity-id-getter' => 'getId',
            'entity-id-key' => 'entityId',
        ], $options);

        $this->controllerHelper = $controllerHelper;
        $this->argumentBuilder = $argumentBuilder;
        $this->container = $container;
        $this->entityClass = $options['entity-class'];
        $this->entityIdGetter = $options['entity-id-getter'];
        $this->entityIdKey = $options['entity-id-key'];
        $this->successResponse = $options['success-response'];
        $this->factory = $options['factory'];
        $this->authorizationAttribute = $options['authorization-attribute'];
        $this->constructArguments = $options['arguments'];
        $this->successRedirectRoute = $options['success-redirect'];
        $this->successRedirectArguments = $options['success-redirect-arguments'];
        $this->successRedirectStatus = $options['success-redirect-status'];

        foreach ($options['calls'] as $methodName => $arguments) {
            /** @var array $arguments */

            Assert::isArray($arguments);
            Assert::true(method_exists($this->entityClass, $methodName));

            $this->calls[$methodName] = $arguments;
        }
    }

    public function __invoke(): Response
    {
        /** @var Request $request */
        $request = $this->controllerHelper->getCurrentRequest();

        Assert::isInstanceOf($request, Request::class, "Cannot use controller outside of request-scope!");

        return $this->createEntity($request);
    }

    public function createEntity(Request $request): Response
    {
        /** @var object|null $factoryObject */
        $factoryObject = null;

        if (!empty($this->authorizationAttribute)) {
            $this->controllerHelper->denyAccessUnlessGranted($this->authorizationAttribute, $request);
        }

        /** @var ReflectionFunctionAbstract|null $constructorReflection */
        $constructorReflection = $this->findConstructorReflection($factoryObject);

        /** @var array<int, mixed> $constructArguments */
        $constructArguments = array();

        if ($constructorReflection instanceof ReflectionFunctionAbstract) {
            $constructArguments = $this->argumentBuilder->buildCallArguments(
                $constructorReflection,
                $this->constructArguments,
                $request
            );

            /** @var object $entity */
            $entity = $this->createEntityByConstructor($constructorReflection, $constructArguments, $factoryObject);

        } else {
            /** @var string $entityClass */
            $entityClass = $this->entityClass;

            $entity = new $entityClass();
        }

        $this->performPostCreationCalls($entity, $request);

        if (!empty($this->authorizationAttribute)) {
            $this->controllerHelper->denyAccessUnlessGranted($this->authorizationAttribute, $entity);
        }

        $this->controllerHelper->persistEntity($entity);

        $this->controllerHelper->dispatchEvent("symfony_generics.entity_interaction", new EntityInteractionEvent(
            $this->entityClass,
            null, # TODO: get id via reflection
            $entity,
            "__construct",
            $constructArguments
        ));

        $this->controllerHelper->flushORM();

        if (!empty($this->successRedirectRoute)) {
            /** @var array $redirectArguments */
            $redirectArguments = $this->argumentBuilder->buildArguments(
                $this->successRedirectArguments,
                $request
            );

            /** @var callable $idGetterCallback */
            $idGetterCallback = [$entity, $this->entityIdGetter];

            $redirectArguments[$this->entityIdKey] = call_user_func($idGetterCallback);

            return $this->controllerHelper->redirectToRoute(
                $this->successRedirectRoute,
                $redirectArguments,
                $this->successRedirectStatus
            );
        }

        return new Response($this->successResponse, 200);
    }

    /**
     * @param object $factoryObject
     */
    private function findConstructorReflection(&$factoryObject = null): ?ReflectionFunctionAbstract
    {
        /** @var ReflectionFunctionAbstract|null $constructorReflection */
        $constructorReflection = null;

        if (!empty($this->factory)) {
            if (is_int(strpos($this->factory, '::'))) {
                [$factoryClass, $factoryMethod] = explode('::', $this->factory, 2);


                if (!empty($factoryClass)) {
                    if ($factoryClass[0] == '@') {
                        # Create by factory-service-object

                        $factoryObject = $this->container->get(substr($factoryClass, 1));

                        Assert::object($factoryObject, sprintf(
                            "Did not find service '%s'!",
                            substr($factoryClass, 1)
                        ));

                        $constructorReflection = (new ReflectionObject($factoryObject))->getMethod($factoryMethod);

                    } else {
                        # Create by static factory-method of other class

                        $constructorReflection = (new ReflectionClass($factoryClass))->getMethod($factoryMethod);
                    }

                } else {
                    throw new ErrorException(sprintf(
                        "Invalid constructor definition: '%s'!",
                        $this->factory
                    ));
                }

            } elseif (method_exists($this->entityClass, $this->factory)) {
                # Create by static factory method on entity class

                $constructorReflection = (new ReflectionClass($this->entityClass))->getMethod($this->factory);

            } elseif (function_exists($this->factory)) {
                # Create by factory function

                $constructorReflection = new ReflectionFunction($this->factory);
            }

        } else {
            # Create by calling the constructor directly

            $constructorReflection = (new ReflectionClass($this->entityClass))->getConstructor();
        }

        return $constructorReflection;
    }

    /**
     * @param object|null $factoryObject
     *
     * @return object
     */
    private function createEntityByConstructor(
        ReflectionFunctionAbstract $constructorReflection,
        array $constructArguments,
        $factoryObject
    ) {
        /** @var object|null $entity */
        $entity = null;

        if ($constructorReflection instanceof ReflectionMethod) {
            if ($constructorReflection->isConstructor()) {
                $entity = $constructorReflection->getDeclaringClass()->newInstanceArgs($constructArguments);

            } elseif ($constructorReflection->isStatic()) {
                $entity = $constructorReflection->invokeArgs(null, $constructArguments);

            } else {
                $entity = $constructorReflection->invokeArgs($factoryObject, $constructArguments);
            }

        } elseif ($constructorReflection instanceof ReflectionFunction) {
            $entity = $constructorReflection->invokeArgs($constructArguments);
        }

        Assert::isInstanceOf($entity, $this->entityClass);

        return $entity;
    }

    /**
     * @param object $entity
     */
    private function performPostCreationCalls($entity, Request $request): void
    {
        $classReflection = new ReflectionClass($this->entityClass);

        foreach ($this->calls as $methodName => $callArgumentConfiguration) {
            /** @var array $callArgumentConfiguration */

            /** @var ReflectionMethod $methodReflection */
            $methodReflection = $classReflection->getMethod($methodName);

            $callArguments = $this->argumentBuilder->buildCallArguments(
                $methodReflection,
                $callArgumentConfiguration,
                $request
            );

            $methodReflection->invokeArgs($entity, $callArguments);
        }
    }

}


1		<?php
2		/**
3		* Copyright (C) 2018 Gerrit Addiks.
4		* This package (including this file) was released under the terms of the GPL-3.0.
5		* You should have received a copy of the GNU General Public License along with this program.
6		* If not, see <http://www.gnu.org/licenses/> or send me a mail so i can send you a copy.
7		*
8		* @license GPL-3.0
9		*
10		* @author Gerrit Addiks <[email protected]>
11		*/
12
13		namespace Addiks\SymfonyGenerics\Controllers\API;
14
15		use Addiks\SymfonyGenerics\Controllers\ControllerHelperInterface;
16		use Addiks\SymfonyGenerics\Services\ArgumentCompilerInterface;
17		use Symfony\Component\HttpFoundation\Response;
18		use Symfony\Component\HttpFoundation\Request;
19		use Webmozart\Assert\Assert;
20		use ReflectionClass;
21		use ReflectionMethod;
22		use Psr\Container\ContainerInterface;
23		use ErrorException;
24		use ReflectionFunction;
25		use ReflectionFunctionAbstract;
26		use ReflectionObject;
27		use Addiks\SymfonyGenerics\Events\EntityInteractionEvent;
28
29		final class GenericEntityCreateController
30		{
31
32		/**
33		* @var ControllerHelperInterface
34		*/
35		private $controllerHelper;
36
37		/**
38		* @var ContainerInterface
39		*/
40		private $container;
41
42		/**
43		* @var string
44		*/
45		private $entityClass;
46
47		/**
48		* @var array<string, array<string, mixed>>
49		*/
50		private $calls = array();
51
52		/**
53		* @var string\|null
54		*/
55		private $factory = null;
56
57		/**
58		* @var array<string, mixed>
59		*/
60		private $constructArguments = array();
61
62		/**
63		* @var ArgumentCompilerInterface
64		*/
65		private $argumentBuilder;
66
67		/**
68		* @var string
69		*/
70		private $successResponse;
71
72		/**
73		* @var string\|null
74		*/
75		private $authorizationAttribute;
76
77		/**
78		* @var string\|null
79		*/
80		private $successRedirectRoute;
81
82		/**
83		* @var array
84		*/
85		private $successRedirectArguments;
86
87		/**
88		* @var int
89		*/
90		private $successRedirectStatus;
91
92		/**
93		* @var string
94		*/
95		private $entityIdKey;
96
97		/**
98		* @var string
99		*/
100		private $entityIdGetter;
101
102	22	public function __construct(
103		ControllerHelperInterface $controllerHelper,
104		ArgumentCompilerInterface $argumentBuilder,
105		ContainerInterface $container,
106		array $options
107		) {
108	22	Assert::null($this->controllerHelper);
109	22	Assert::keyExists($options, 'entity-class');
110
111		/** @var int $defaultRedirectStatus */
112	21	$defaultRedirectStatus = 303;
113
114	21	$options = array_merge([
115	21	'calls' => [],
116	21	'success-response' => "object created",
117		'factory' => null,
118		'authorization-attribute' => null,
119		'arguments' => [],
120		'success-redirect' => null,
121		'success-redirect-arguments' => [],
122	21	'success-redirect-status' => $defaultRedirectStatus,
123	21	'entity-id-getter' => 'getId',
124	21	'entity-id-key' => 'entityId',
125	21	], $options);
126
127	21	$this->controllerHelper = $controllerHelper;
128	21	$this->argumentBuilder = $argumentBuilder;
129	21	$this->container = $container;
130	21	$this->entityClass = $options['entity-class'];
131	21	$this->entityIdGetter = $options['entity-id-getter'];
132	21	$this->entityIdKey = $options['entity-id-key'];
133	21	$this->successResponse = $options['success-response'];
134	21	$this->factory = $options['factory'];
135	21	$this->authorizationAttribute = $options['authorization-attribute'];
136	21	$this->constructArguments = $options['arguments'];
137	21	$this->successRedirectRoute = $options['success-redirect'];
138	21	$this->successRedirectArguments = $options['success-redirect-arguments'];
139	21	$this->successRedirectStatus = $options['success-redirect-status'];
140
141	21	foreach ($options['calls'] as $methodName => $arguments) {
142		/** @var array $arguments */
143
144	4	Assert::isArray($arguments);
145	3	Assert::true(method_exists($this->entityClass, $methodName));
146
147	1	$this->calls[$methodName] = $arguments;
148		}
149	18	}
150
151	2	public function __invoke(): Response
152		{
153		/** @var Request $request */
154	2	$request = $this->controllerHelper->getCurrentRequest();
155
156	2	Assert::isInstanceOf($request, Request::class, "Cannot use controller outside of request-scope!");
157
158	1	return $this->createEntity($request);
159		}
160
161	16	public function createEntity(Request $request): Response
162		{
163		/** @var object\|null $factoryObject */
164	16	$factoryObject = null;
165
166	16	if (!empty($this->authorizationAttribute)) {
167	1	$this->controllerHelper->denyAccessUnlessGranted($this->authorizationAttribute, $request);
168		}
169
170		/** @var ReflectionFunctionAbstract\|null $constructorReflection */
171	16	$constructorReflection = $this->findConstructorReflection($factoryObject);
172
173		/** @var array<int, mixed> $constructArguments */
174	12	$constructArguments = array();
175
176	12	if ($constructorReflection instanceof ReflectionFunctionAbstract) {
177	11	$constructArguments = $this->argumentBuilder->buildCallArguments(
178	11	$constructorReflection,
179	11	$this->constructArguments,
180	11	$request
181		);
182
183		/** @var object $entity */
184	11	$entity = $this->createEntityByConstructor($constructorReflection, $constructArguments, $factoryObject);
185
186		} else {
187		/** @var string $entityClass */
188	1	$entityClass = $this->entityClass;
189
190	1	$entity = new $entityClass();
191		}
192
193	11	$this->performPostCreationCalls($entity, $request);
194
195	11	if (!empty($this->authorizationAttribute)) {
196	1	$this->controllerHelper->denyAccessUnlessGranted($this->authorizationAttribute, $entity);
197		}
198
199	10	$this->controllerHelper->persistEntity($entity);
200
201	10	$this->controllerHelper->dispatchEvent("symfony_generics.entity_interaction", new EntityInteractionEvent(
202	10	$this->entityClass,
203	10	null, # TODO: get id via reflection
204	10	$entity,
205	10	"__construct",
206	10	$constructArguments
207		));
208
209	10	$this->controllerHelper->flushORM();
210
211	10	if (!empty($this->successRedirectRoute)) {
212		/** @var array $redirectArguments */
213	1	$redirectArguments = $this->argumentBuilder->buildArguments(
214	1	$this->successRedirectArguments,
215	1	$request
216		);
217
218		/** @var callable $idGetterCallback */
219	1	$idGetterCallback = [$entity, $this->entityIdGetter];
220
221	1	$redirectArguments[$this->entityIdKey] = call_user_func($idGetterCallback);
222
223	1	return $this->controllerHelper->redirectToRoute(
224	1	$this->successRedirectRoute,
225	1	$redirectArguments,
226	1	$this->successRedirectStatus
227		);
228		}
229
230	9	return new Response($this->successResponse, 200);
231		}
232
233		/**
234		* @param object $factoryObject
235		*/
236	16	private function findConstructorReflection(&$factoryObject = null): ?ReflectionFunctionAbstract
237		{
238		/** @var ReflectionFunctionAbstract\|null $constructorReflection */
239	16	$constructorReflection = null;
240
241	16	if (!empty($this->factory)) {
242	10	if (is_int(strpos($this->factory, '::'))) {
243	7	[$factoryClass, $factoryMethod] = explode('::', $this->factory, 2);
		0 ignored issues – show Bug introduced 2018-11-04 13:51 UTC by Report Bug Copy Issue Report The variable `$factoryClass` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history... Bug introduced 2018-11-04 13:51 UTC by Report Bug Copy Issue Report The variable `$factoryMethod` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
244
245	7	if (!empty($factoryClass)) {
246	6	if ($factoryClass[0] == '@') {
247		# Create by factory-service-object
248
249	6	$factoryObject = $this->container->get(substr($factoryClass, 1));
250
251	6	Assert::object($factoryObject, sprintf(
252	6	"Did not find service '%s'!",
253	6	substr($factoryClass, 1)
254		));
255
256	5	$constructorReflection = (new ReflectionObject($factoryObject))->getMethod($factoryMethod);
257
258		} else {
259		# Create by static factory-method of other class
260
261	3	$constructorReflection = (new ReflectionClass($factoryClass))->getMethod($factoryMethod);
262		}
263
264		} else {
265	1	throw new ErrorException(sprintf(
266	1	"Invalid constructor definition: '%s'!",
267	4	$this->factory
268		));
269		}
270
271	3	} elseif (method_exists($this->entityClass, $this->factory)) {
272		# Create by static factory method on entity class
273
274	2	$constructorReflection = (new ReflectionClass($this->entityClass))->getMethod($this->factory);
275
276	1	} elseif (function_exists($this->factory)) {
277		# Create by factory function
278
279	6	$constructorReflection = new ReflectionFunction($this->factory);
280		}
281
282		} else {
283		# Create by calling the constructor directly
284
285	6	$constructorReflection = (new ReflectionClass($this->entityClass))->getConstructor();
286		}
287
288	12	return $constructorReflection;
289		}
290
291		/**
292		* @param object\|null $factoryObject
293		*
294		* @return object
295		*/
296	11	private function createEntityByConstructor(
297		ReflectionFunctionAbstract $constructorReflection,
298		array $constructArguments,
299		$factoryObject
300		) {
301		/** @var object\|null $entity */
302	11	$entity = null;
303
304	11	if ($constructorReflection instanceof ReflectionMethod) {
305	10	if ($constructorReflection->isConstructor()) {
306	5	$entity = $constructorReflection->getDeclaringClass()->newInstanceArgs($constructArguments);
307
308	5	} elseif ($constructorReflection->isStatic()) {
309	2	$entity = $constructorReflection->invokeArgs(null, $constructArguments);
310
311		} else {
312	10	$entity = $constructorReflection->invokeArgs($factoryObject, $constructArguments);
313		}
314
315	1	} elseif ($constructorReflection instanceof ReflectionFunction) {
316	1	$entity = $constructorReflection->invokeArgs($constructArguments);
317		}
318
319	11	Assert::isInstanceOf($entity, $this->entityClass);
320
321	10	return $entity;
322		}
323
324		/**
325		* @param object $entity
326		*/
327	11	private function performPostCreationCalls($entity, Request $request): void
328		{
329	11	$classReflection = new ReflectionClass($this->entityClass);
330
331	11	foreach ($this->calls as $methodName => $callArgumentConfiguration) {
332		/** @var array $callArgumentConfiguration */
333
334		/** @var ReflectionMethod $methodReflection */
335	1	$methodReflection = $classReflection->getMethod($methodName);
336
337	1	$callArguments = $this->argumentBuilder->buildCallArguments(
338	1	$methodReflection,
339	1	$callArgumentConfiguration,
340	1	$request
341		);
342
343	1	$methodReflection->invokeArgs($entity, $callArguments);
344		}
345	11	}
346
347		}
348

addiks / symfony_generics

Push — master ( 50ffe0...5d273a )

GenericEntityCreateController::__invoke() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like