GenericEntityCreateController::__invoke() - Code Metrics - Inspection of "improved tests" - addiks/symfony_generics - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 3624d1...36fc6d )

by Gerrit

created 2019-05-28 19:28 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	21	public function __construct(
103		ControllerHelperInterface $controllerHelper,
104		ArgumentCompilerInterface $argumentBuilder,
105		ContainerInterface $container,
106		array $options
107		) {
108	21	Assert::null($this->controllerHelper);
109	21	Assert::keyExists($options, 'entity-class');
110
111		/** @var int $defaultRedirectStatus */
112	20	$defaultRedirectStatus = 303;
113
114	20	$options = array_merge([
115	20	'calls' => [],
116	20	'success-response' => "object created",
117		'factory' => null,
118		'authorization-attribute' => null,
119		'arguments' => [],
120		'success-redirect' => null,
121		'success-redirect-arguments' => [],
122	20	'success-redirect-status' => $defaultRedirectStatus,
123	20	'entity-id-getter' => 'getId',
124	20	'entity-id-key' => 'entityId',
125	20	], $options);
126
127	20	$this->controllerHelper = $controllerHelper;
128	20	$this->argumentBuilder = $argumentBuilder;
129	20	$this->container = $container;
130	20	$this->entityClass = $options['entity-class'];
131	20	$this->entityIdGetter = $options['entity-id-getter'];
132	20	$this->entityIdKey = $options['entity-id-key'];
133	20	$this->successResponse = $options['success-response'];
134	20	$this->factory = $options['factory'];
135	20	$this->authorizationAttribute = $options['authorization-attribute'];
136	20	$this->constructArguments = $options['arguments'];
137	20	$this->successRedirectRoute = $options['success-redirect'];
138	20	$this->successRedirectArguments = $options['success-redirect-arguments'];
139	20	$this->successRedirectStatus = $options['success-redirect-status'];
140
141	20	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	17	}
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	15	public function createEntity(Request $request): Response
162		{
163		/** @var object\|null $factoryObject */
164	15	$factoryObject = null;
165
166	15	if (!empty($this->authorizationAttribute)) {
167	1	$this->controllerHelper->denyAccessUnlessGranted($this->authorizationAttribute, $request);
168		}
169
170		/** @var ReflectionFunctionAbstract\|null $constructorReflection */
171	15	$constructorReflection = $this->findConstructorReflection($factoryObject);
172
173		/** @var array<int, mixed> $constructArguments */
174	11	$constructArguments = array();
175
176	11	if ($constructorReflection instanceof ReflectionFunctionAbstract) {
177	10	$constructArguments = $this->argumentBuilder->buildCallArguments(
178	10	$constructorReflection,
179	10	$this->constructArguments,
180	10	$request
181		);
182
183		/** @var object $entity */
184	10	$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	10	$this->performPostCreationCalls($entity, $request);
194
195	10	if (!empty($this->authorizationAttribute)) {
196	1	$this->controllerHelper->denyAccessUnlessGranted($this->authorizationAttribute, $entity);
197		}
198
199	9	$this->controllerHelper->persistEntity($entity);
200
201	9	$this->controllerHelper->dispatchEvent("symfony_generics.entity_interaction", new EntityInteractionEvent(
202	9	$this->entityClass,
203	9	null, # TODO: get id via reflection
204	9	$entity,
205	9	"__construct",
206	9	$constructArguments
207		));
208
209	9	$this->controllerHelper->flushORM();
210
211	9	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	8	return new Response($this->successResponse, 200);
231		}
232
233		/**
234		* @param object $factoryObject
235		*/
236	15	private function findConstructorReflection(&$factoryObject = null): ?ReflectionFunctionAbstract
237		{
238		/** @var ReflectionFunctionAbstract\|null $constructorReflection */
239	15	$constructorReflection = null;
240
241	15	if (!empty($this->factory)) {
242	9	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	2	} 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		} elseif (function_exists($this->factory)) {
277		# Create by factory function
278
279	5	$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	11	return $constructorReflection;
289		}
290
291		/**
292		* @param object\|null $factoryObject
293		*
294		* @return object
295		*/
296	10	private function createEntityByConstructor(
297		ReflectionFunctionAbstract $constructorReflection,
298		array $constructArguments,
299		$factoryObject
300		) {
301		/** @var object\|null $entity */
302	10	$entity = null;
303
304	10	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		} elseif ($constructorReflection instanceof ReflectionFunction) {
316		$entity = $constructorReflection->invokeArgs($constructArguments);
317		}
318
319	10	Assert::isInstanceOf($entity, $this->entityClass);
320
321	9	return $entity;
322		}
323
324		/**
325		* @param object $entity
326		*/
327	10	private function performPostCreationCalls($entity, Request $request): void
328		{
329	10	$classReflection = new ReflectionClass($this->entityClass);
330
331	10	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	10	}
346
347		}
348

addiks / symfony_generics

Push — master ( 3624d1...36fc6d )

GenericEntityCreateController::__invoke() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like