AbstractRestResourceController - Code Metrics - Inspection of "Refactoring Controllers" - dontdrinkandroot/rest-bundle.php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 56c59d...5628a9 )

by Philip

created 2017-12-30 12:53 UTC

AbstractRestResourceController D

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	538
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	19

Test Coverage

Coverage

92.18%

Importance

Changes

Metric	Value
wmc	49
lcom	1
cbo	19
dl	0
loc	538
ccs	165
cts	179
cp	0.9218
rs	4.6787
c	0
b	0
f	0

42 Methods

Rating	Name	Size	Complexity
A	__construct()	15	1
B	listAction()	25	2
A	postAction()	18	2
A	getAction()	9	1
A	putAction()	18	2
A	deleteAction()	8	1
B	listSubresourceAction()	26	2
A	postSubresourceAction()	22	2
A	putSubresourceAction()	8	1
A	deleteSubresourceAction()	8	1
A	postProcessPostedEntity()	4	1
A	postProcessPuttedEntity()	4	1
A	postProcessSubResourcePostedEntity()	4	1
A	getEntityClass()	4	1
A	getSubResourceEntityClass()	7	1
A	getCurrentRequest()	4	1
A	assertMethodGranted()	7	3
A	assertSubResourceMethodGranted()	10	2
A	getClassMetadata()	8	1
A	resolveSubject()	9	2
A	assertRightGranted()	10	3
A	parseIncludes()	16	3
A	denyAccessUnlessGranted()	11	3
A	parseConstraintViolations()	14	2
A	addPaginationHeaders()	11	1
A	getNormalizer()	4	1
A	getValidator()	4	1
A	getRequestParser()	4	1
A	getRequestStack()	4	1
A	getMetadataFactory()	4	1
A	getPropertyAccessor()	4	1
A	getAuthorizationChecker()	4	1
A	setAuthorizationChecker()	4	1
	listEntities()	1	?
	fetchEntity()	1	?
	createEntity()	1	?
	updateEntity()	1	?
	removeEntity()	1	?
	listSubresource()	1	?
	createAssociation()	1	?
	addAssociation()	1	?
	removeAssociation()	1	?

How to fix Complexity

<?php

namespace Dontdrinkandroot\RestBundle\Controller;

use Doctrine\ORM\Tools\Pagination\Paginator;
use Dontdrinkandroot\RestBundle\Metadata\Annotation\Method;
use Dontdrinkandroot\RestBundle\Metadata\Annotation\Right;
use Dontdrinkandroot\RestBundle\Metadata\ClassMetadata;
use Dontdrinkandroot\RestBundle\Metadata\PropertyMetadata;
use Dontdrinkandroot\RestBundle\Service\Normalizer;
use Dontdrinkandroot\RestBundle\Service\RestRequestParserInterface;
use Metadata\MetadataFactoryInterface;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\RequestStack;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
use Symfony\Component\Security\Core\Exception\AccessDeniedException;
use Symfony\Component\Validator\ConstraintViolationInterface;
use Symfony\Component\Validator\ConstraintViolationListInterface;
use Symfony\Component\Validator\Validator\ValidatorInterface;

/**
 * @author Philip Washington Sorst <[email protected]>
 */
abstract class AbstractRestResourceController implements RestResourceControllerInterface
{
    /**
     * @var Normalizer
     */
    private $normalizer;

    /**
     * @var ValidatorInterface
     */
    private $validator;

    /**
     * @var RestRequestParserInterface
     */
    private $requestParser;

    /**
     * @var RequestStack
     */
    private $requestStack;

    /**
     * @var MetadataFactoryInterface
     */
    private $metadataFactory;

    /**
     * @var PropertyAccessorInterface
     */
    private $propertyAccessor;

    /**
     * @var AuthorizationCheckerInterface
     */
    private $authorizationChecker;

    public function __construct(
        RestRequestParserInterface $requestParser,
        Normalizer $normalizer,
        ValidatorInterface $validator,
        RequestStack $requestStack,
        MetadataFactoryInterface $metadataFactory,
        PropertyAccessorInterface $propertyAccessor
    ) {
        $this->requestParser = $requestParser;
        $this->normalizer = $normalizer;
        $this->validator = $validator;
        $this->requestStack = $requestStack;
        $this->metadataFactory = $metadataFactory;
        $this->propertyAccessor = $propertyAccessor;
    }

    /**
     * {@inheritdoc}
     */
    public function listAction(Request $request)
    {
        $page = $request->query->get('page', 1);
        $perPage = $request->query->get('perPage', 50);

        $this->assertMethodGranted(Method::LIST);

        $listResult = $this->listEntities($page, $perPage);

        $response = new JsonResponse();

        if ($listResult instanceof Paginator) {
            $entities = iterator_to_array($listResult->getIterator());
            $total = $listResult->count();
            $this->addPaginationHeaders($response, $page, $perPage, $total);
        } else {
            $entities = $listResult;
        }

        $content = $this->getNormalizer()->normalize($entities, $this->parseIncludes($request));

        $response->setData($content);

        return $response;
    }

    /**
     * {@inheritdoc}
     */
    public function postAction(Request $request)
    {
        $this->assertMethodGranted(Method::POST);

        $entity = $this->getRequestParser()->parseEntity($request, $this->getEntityClass());
        $entity = $this->postProcessPostedEntity($entity);

        $errors = $this->getValidator()->validate($entity);
        if ($errors->count() > 0) {
            return new JsonResponse($this->parseConstraintViolations($errors), Response::HTTP_BAD_REQUEST);
        }

        $entity = $this->createEntity($entity);

        $content = $this->getNormalizer()->normalize($entity, $this->parseIncludes($request));

        return new JsonResponse($content, Response::HTTP_CREATED);
    }

    /**
     * {@inheritdoc}
     */
    public function getAction(Request $request, $id)
    {
        $entity = $this->fetchEntity($id);
        $this->assertMethodGranted(Method::GET, $entity);

        $content = $this->getNormalizer()->normalize($entity, $this->parseIncludes($request));

        return new JsonResponse($content);
    }

    /**
     * {@inheritdoc}
     */
    public function putAction(Request $request, $id)
    {
        $entity = $this->fetchEntity($id);
        $this->assertMethodGranted(Method::PUT, $entity);
        $entity = $this->getRequestParser()->parseEntity($request, $this->getEntityClass(), $entity);
        $entity = $this->postProcessPuttedEntity($entity);

        $errors = $this->getValidator()->validate($entity);
        if ($errors->count() > 0) {
            return new JsonResponse($this->parseConstraintViolations($errors), Response::HTTP_BAD_REQUEST);
        }

        $entity = $this->updateEntity($entity);

        $content = $this->getNormalizer()->normalize($entity, $this->parseIncludes($request));

        return new JsonResponse($content);
    }

    /**
     * {@inheritdoc}
     */
    public function deleteAction(Request $request, $id)
    {
        $entity = $this->fetchEntity($id);
        $this->assertMethodGranted(Method::DELETE, $entity);
        $this->removeEntity($entity);

        return new JsonResponse(null, Response::HTTP_NO_CONTENT);
    }

    /**
     * {@inheritdoc}
     */
    public function listSubresourceAction(Request $request, $id, string $subresource)
    {
        $page = $request->query->get('page', 1);
        $perPage = $request->query->get('perPage', 50);

        $entity = $this->fetchEntity($id);
        $this->assertSubResourceMethodGranted(Method::LIST, $entity, $subresource);

        $listResult = $this->listSubresource($entity, $subresource, $page, $perPage);

        $response = new JsonResponse();

        if ($listResult instanceof Paginator) {
            $entities = iterator_to_array($listResult->getIterator());
            $total = $listResult->count();
            $this->addPaginationHeaders($response, $page, $perPage, $total);
        } else {
            $entities = $listResult;
        }

        $content = $this->getNormalizer()->normalize($entities, $this->parseIncludes($request));

        $response->setData($content);

        return $response;
    }

    /**
     * {@inheritdoc}
     */
    public function postSubresourceAction(Request $request, $id, string $subresource)
    {
        $parent = $this->fetchEntity($id);
        $this->assertSubResourceMethodGranted(Method::POST, $parent, $subresource);

        $restRequestParser = $this->getRequestParser();
        $entity = $restRequestParser->parseEntity($request, $this->getSubResourceEntityClass($subresource));

        $entity = $this->postProcessSubResourcePostedEntity($parent, $subresource, $entity);

        $errors = $this->getValidator()->validate($entity);

        if ($errors->count() > 0) {
            return new JsonResponse($this->parseConstraintViolations($errors), Response::HTTP_BAD_REQUEST);
        }

        $entity = $this->createAssociation($parent, $subresource, $entity);

        $content = $this->getNormalizer()->normalize($entity, $this->parseIncludes($request));

        return new JsonResponse($content, Response::HTTP_CREATED);
    }

    /**
     * {@inheritdoc}
     */
    public function putSubresourceAction(Request $request, $id, string $subresource, $subId)
    {
        $parent = $this->fetchEntity($id);
        $this->assertSubResourceMethodGranted(Method::PUT, $parent, $subresource);
        $this->addAssociation($parent, $subresource, $subId);

        return new JsonResponse(null, Response::HTTP_NO_CONTENT);
    }

    /**
     * {@inheritdoc}
     */
    public function deleteSubresourceAction(Request $request, $id, string $subresource, $subId = null)
    {
        $parent = $this->fetchEntity($id);
        $this->assertSubResourceMethodGranted(Method::DELETE, $parent, $subresource);
        $this->removeAssociation($parent, $subresource, $subId);

        return new JsonResponse(null, Response::HTTP_NO_CONTENT);
    }

    /**
     * @param object $entity
     *
     * @return object
     */
    protected function postProcessPostedEntity($entity)
    {
        return $entity;
    }

    /**
     * @param object $entity
     *
     * @return object
     */
    protected function postProcessPuttedEntity($entity)
    {
        return $entity;
    }

    /**
     * @param object $parent
     * @param string $subresource
     * @param object $entity
     *
     * @return object
     */
    protected function postProcessSubResourcePostedEntity($parent, $subresource, $entity)

    {
        return $entity;
    }

    protected function getEntityClass()
    {
        return $this->getCurrentRequest()->attributes->get('_entityClass');
    }

    protected function getSubResourceEntityClass($subresource)
    {
        /** @var PropertyMetadata $propertyMetadata */
        $propertyMetadata = $this->getClassMetadata()->propertyMetadata[$subresource];

        return $propertyMetadata->getType();
    }

    protected function getCurrentRequest()
    {
        return $this->getRequestStack()->getCurrentRequest();
    }

    protected function assertMethodGranted(string $methodName, $entity = null)
    {
        $method = $this->getClassMetadata()->getMethod($methodName);
        if ($method !== null && null !== $right = $method->right) {
            $this->assertRightGranted($right, $entity);
        }
    }

    /**
     * @param string $methodName
     * @param object $entity
     * @param string $subresource
     */
    protected function assertSubResourceMethodGranted($methodName, $entity, string $subresource): void
    {
        $classMetadata = $this->getClassMetadata();
        /** @var PropertyMetadata $propertyMetadata */
        $propertyMetadata = $classMetadata->propertyMetadata[$subresource];
        $method = $propertyMetadata->getMethod($methodName);
        if (null !== $right = $method->right) {
            $this->assertRightGranted($right, $entity);
        }
    }

    /**
     * @return ClassMetadata
     */
    protected function getClassMetadata()
    {
        $metaDataFactory = $this->getMetadataFactory();
        /** @var ClassMetadata $classMetaData */
        $classMetaData = $metaDataFactory->getMetadataForClass($this->getEntityClass());

        return $classMetaData;
    }

    protected function resolveSubject($entity, $propertyPath)
    {
        if ('this' === $propertyPath) {
            return $entity;
        }
        $propertyAccessor = $this->getPropertyAccessor();

        return $propertyAccessor->getValue($entity, $propertyPath);
    }

    /**
     * @param Right  $right
     * @param object $entity
     */
    protected function assertRightGranted(Right $right, $entity = null)
    {
        $propertyPath = $right->propertyPath;
        if (null === $propertyPath || null == $entity) {
            $this->denyAccessUnlessGranted($right->attributes);
        } else {
            $subject = $this->resolveSubject($entity, $propertyPath);
            $this->denyAccessUnlessGranted($right->attributes, $subject);
        }
    }

    protected function parseIncludes(Request $request)
    {
        $defaultIncludes = $request->attributes->get('_defaultincludes');
        if (null == $defaultIncludes) {
            $defaultIncludes = [];
        }

        $includeString = $request->query->get('include');
        if (empty($includeString)) {
            $includes = [];
        } else {
            $includes = explode(',', $includeString);
        }

        return array_merge($defaultIncludes, $includes);
    }

    protected function denyAccessUnlessGranted($attributes, $object = null, $message = 'Access Denied.')
    {
        $authorizationChecker = $this->getAuthorizationChecker();
        if (null === $authorizationChecker) {
            throw new AccessDeniedException('No authorization checker configured');
        }

        if (!$authorizationChecker->isGranted($attributes, $object)) {
            throw new AccessDeniedException($message);
        }
    }

    protected function parseConstraintViolations(ConstraintViolationListInterface $errors)
    {
        $data = [];
        /** @var ConstraintViolationInterface $error */
        foreach ($errors as $error) {
            $data[] = [
                'propertyPath' => $error->getPropertyPath(),
                'message'      => $error->getMessage(),
                'value'        => $error->getInvalidValue()
            ];
        }

        return $data;
    }

    protected function addPaginationHeaders(Response $response, int $page, int $perPage, int $total)
    {
        $response->headers->add(
            [
                'x-pagination-current-page' => $page,
                'x-pagination-per-page'     => $perPage,
                'x-pagination-total'        => $total,
                'x-pagination-total-pages'  => (int)(($total - 1) / $perPage + 1)
            ]
        );
    }

    /**
     * {@inheritdoc}
     */
    protected function getNormalizer()
    {
        return $this->normalizer;
    }

    /**
     * {@inheritdoc}
     */
    protected function getValidator()
    {
        return $this->validator;
    }

    /**
     * {@inheritdoc}
     */
    protected function getRequestParser()
    {
        return $this->requestParser;
    }

    /**
     * {@inheritdoc}
     */
    protected function getRequestStack()
    {
        return $this->requestStack;
    }

    /**
     * {@inheritdoc}
     */
    protected function getMetadataFactory()
    {
        return $this->metadataFactory;
    }

    /**
     * {@inheritdoc}
     */
    protected function getPropertyAccessor()
    {
        return $this->propertyAccessor;
    }

    /**
     * {@inheritdoc}
     */
    protected function getAuthorizationChecker(): ?AuthorizationCheckerInterface
    {
        return $this->authorizationChecker;
    }

    /**
     * @param AuthorizationCheckerInterface $authorizationChecker
     */
    public function setAuthorizationChecker(AuthorizationCheckerInterface $authorizationChecker): void
    {
        $this->authorizationChecker = $authorizationChecker;
    }

    /**
     * @param int $page
     * @param int $perPage
     *
     * @return Paginator|array
     */
    abstract protected function listEntities(int $page = 1, int $perPage = 50);

    /**
     * @param int|string $id
     *
     * @return object
     *
     * @throws NotFoundHttpException Thrown if entity with the given id could not be found.
     */
    abstract protected function fetchEntity($id);

    /**
     * @param object $entity
     *
     * @return object
     */
    abstract protected function createEntity($entity);

    /**
     * @param object $entity
     *
     * @return object
     *
     * @throws NotFoundHttpException Thrown if entity with the given id could not be found.
     */
    abstract protected function updateEntity($entity);

    /**
     * @param $entity
     *
     * @throws NotFoundHttpException Thrown if entity with the given id could not be found.
     */
    abstract protected function removeEntity($entity);

    /**
     * @param object $entity
     * @param string $subresource
     * @param int    $page
     * @param int    $perPage
     *
     * @return Paginator|array
     */
    abstract protected function listSubresource($entity, string $subresource, int $page = 1, int $perPage = 50);

    /**
     * @param object $parent
     * @param string $subresource
     *
     * @return object
     */
    abstract protected function createAssociation($parent, string $subresource, $entity);

    /**
     * @param object     $parent
     * @param string     $subresource
     * @param int|string $subId
     *
     * @return object
     */
    abstract protected function addAssociation($parent, string $subresource, $subId);

    /**
     * @param object          $parent
     * @param string          $subresource
     * @param int|string|null $subId
     *
     * @return mixed
     */
    abstract protected function removeAssociation($parent, string $subresource, $subId = null);
}


1		<?php
2
3		namespace Dontdrinkandroot\RestBundle\Controller;
4
5		use Doctrine\ORM\Tools\Pagination\Paginator;
6		use Dontdrinkandroot\RestBundle\Metadata\Annotation\Method;
7		use Dontdrinkandroot\RestBundle\Metadata\Annotation\Right;
8		use Dontdrinkandroot\RestBundle\Metadata\ClassMetadata;
9		use Dontdrinkandroot\RestBundle\Metadata\PropertyMetadata;
10		use Dontdrinkandroot\RestBundle\Service\Normalizer;
11		use Dontdrinkandroot\RestBundle\Service\RestRequestParserInterface;
12		use Metadata\MetadataFactoryInterface;
13		use Symfony\Component\HttpFoundation\JsonResponse;
14		use Symfony\Component\HttpFoundation\Request;
15		use Symfony\Component\HttpFoundation\RequestStack;
16		use Symfony\Component\HttpFoundation\Response;
17		use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
18		use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
19		use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
20		use Symfony\Component\Security\Core\Exception\AccessDeniedException;
21		use Symfony\Component\Validator\ConstraintViolationInterface;
22		use Symfony\Component\Validator\ConstraintViolationListInterface;
23		use Symfony\Component\Validator\Validator\ValidatorInterface;
24
25		/**
26		* @author Philip Washington Sorst <[email protected]>
27		*/
28		abstract class AbstractRestResourceController implements RestResourceControllerInterface
29		{
30		/**
31		* @var Normalizer
32		*/
33		private $normalizer;
34
35		/**
36		* @var ValidatorInterface
37		*/
38		private $validator;
39
40		/**
41		* @var RestRequestParserInterface
42		*/
43		private $requestParser;
44
45		/**
46		* @var RequestStack
47		*/
48		private $requestStack;
49
50		/**
51		* @var MetadataFactoryInterface
52		*/
53		private $metadataFactory;
54
55		/**
56		* @var PropertyAccessorInterface
57		*/
58		private $propertyAccessor;
59
60		/**
61		* @var AuthorizationCheckerInterface
62		*/
63		private $authorizationChecker;
64
65	80	public function __construct(
66		RestRequestParserInterface $requestParser,
67		Normalizer $normalizer,
68		ValidatorInterface $validator,
69		RequestStack $requestStack,
70		MetadataFactoryInterface $metadataFactory,
71		PropertyAccessorInterface $propertyAccessor
72		) {
73	80	$this->requestParser = $requestParser;
74	80	$this->normalizer = $normalizer;
75	80	$this->validator = $validator;
76	80	$this->requestStack = $requestStack;
77	80	$this->metadataFactory = $metadataFactory;
78	80	$this->propertyAccessor = $propertyAccessor;
79	80	}
80
81		/**
82		* {@inheritdoc}
83		*/
84	10	public function listAction(Request $request)
85		{
86	10	$page = $request->query->get('page', 1);
87	10	$perPage = $request->query->get('perPage', 50);
88
89	10	$this->assertMethodGranted(Method::LIST);
90
91	6	$listResult = $this->listEntities($page, $perPage);
92
93	6	$response = new JsonResponse();
94
95	6	if ($listResult instanceof Paginator) {
96	6	$entities = iterator_to_array($listResult->getIterator());
97	6	$total = $listResult->count();
98	6	$this->addPaginationHeaders($response, $page, $perPage, $total);
99		} else {
100		$entities = $listResult;
101		}
102
103	6	$content = $this->getNormalizer()->normalize($entities, $this->parseIncludes($request));
104
105	6	$response->setData($content);
106
107	6	return $response;
108		}
109
110		/**
111		* {@inheritdoc}
112		*/
113	14	public function postAction(Request $request)
114		{
115	14	$this->assertMethodGranted(Method::POST);
116
117	12	$entity = $this->getRequestParser()->parseEntity($request, $this->getEntityClass());
118	12	$entity = $this->postProcessPostedEntity($entity);
119
120	12	$errors = $this->getValidator()->validate($entity);
121	12	if ($errors->count() > 0) {
122	2	return new JsonResponse($this->parseConstraintViolations($errors), Response::HTTP_BAD_REQUEST);
123		}
124
125	10	$entity = $this->createEntity($entity);
126
127	10	$content = $this->getNormalizer()->normalize($entity, $this->parseIncludes($request));
128
129	10	return new JsonResponse($content, Response::HTTP_CREATED);
130		}
131
132		/**
133		* {@inheritdoc}
134		*/
135	32	public function getAction(Request $request, $id)
136		{
137	32	$entity = $this->fetchEntity($id);
138	30	$this->assertMethodGranted(Method::GET, $entity);
139
140	28	$content = $this->getNormalizer()->normalize($entity, $this->parseIncludes($request));
141
142	28	return new JsonResponse($content);
143		}
144
145		/**
146		* {@inheritdoc}
147		*/
148	12	public function putAction(Request $request, $id)
149		{
150	12	$entity = $this->fetchEntity($id);
151	12	$this->assertMethodGranted(Method::PUT, $entity);
152	10	$entity = $this->getRequestParser()->parseEntity($request, $this->getEntityClass(), $entity);
153	10	$entity = $this->postProcessPuttedEntity($entity);
154
155	10	$errors = $this->getValidator()->validate($entity);
156	10	if ($errors->count() > 0) {
157		return new JsonResponse($this->parseConstraintViolations($errors), Response::HTTP_BAD_REQUEST);
158		}
159
160	10	$entity = $this->updateEntity($entity);
161
162	10	$content = $this->getNormalizer()->normalize($entity, $this->parseIncludes($request));
163
164	10	return new JsonResponse($content);
165		}
166
167		/**
168		* {@inheritdoc}
169		*/
170	4	public function deleteAction(Request $request, $id)
171		{
172	4	$entity = $this->fetchEntity($id);
173	4	$this->assertMethodGranted(Method::DELETE, $entity);
174	2	$this->removeEntity($entity);
175
176	2	return new JsonResponse(null, Response::HTTP_NO_CONTENT);
177		}
178
179		/**
180		* {@inheritdoc}
181		*/
182	6	public function listSubresourceAction(Request $request, $id, string $subresource)
183		{
184	6	$page = $request->query->get('page', 1);
185	6	$perPage = $request->query->get('perPage', 50);
186
187	6	$entity = $this->fetchEntity($id);
188	6	$this->assertSubResourceMethodGranted(Method::LIST, $entity, $subresource);
189
190	6	$listResult = $this->listSubresource($entity, $subresource, $page, $perPage);
191
192	6	$response = new JsonResponse();
193
194	6	if ($listResult instanceof Paginator) {
195	6	$entities = iterator_to_array($listResult->getIterator());
196	6	$total = $listResult->count();
197	6	$this->addPaginationHeaders($response, $page, $perPage, $total);
198		} else {
199		$entities = $listResult;
200		}
201
202	6	$content = $this->getNormalizer()->normalize($entities, $this->parseIncludes($request));
203
204	6	$response->setData($content);
205
206	6	return $response;
207		}
208
209		/**
210		* {@inheritdoc}
211		*/
212	4	public function postSubresourceAction(Request $request, $id, string $subresource)
213		{
214	4	$parent = $this->fetchEntity($id);
215	4	$this->assertSubResourceMethodGranted(Method::POST, $parent, $subresource);
216
217	2	$restRequestParser = $this->getRequestParser();
218	2	$entity = $restRequestParser->parseEntity($request, $this->getSubResourceEntityClass($subresource));
219
220	2	$entity = $this->postProcessSubResourcePostedEntity($parent, $subresource, $entity);
221
222	2	$errors = $this->getValidator()->validate($entity);
223
224	2	if ($errors->count() > 0) {
225		return new JsonResponse($this->parseConstraintViolations($errors), Response::HTTP_BAD_REQUEST);
226		}
227
228	2	$entity = $this->createAssociation($parent, $subresource, $entity);
229
230	2	$content = $this->getNormalizer()->normalize($entity, $this->parseIncludes($request));
231
232	2	return new JsonResponse($content, Response::HTTP_CREATED);
233		}
234
235		/**
236		* {@inheritdoc}
237		*/
238	12	public function putSubresourceAction(Request $request, $id, string $subresource, $subId)
239		{
240	12	$parent = $this->fetchEntity($id);
241	12	$this->assertSubResourceMethodGranted(Method::PUT, $parent, $subresource);
242	12	$this->addAssociation($parent, $subresource, $subId);
243
244	12	return new JsonResponse(null, Response::HTTP_NO_CONTENT);
245		}
246
247		/**
248		* {@inheritdoc}
249		*/
250	12	public function deleteSubresourceAction(Request $request, $id, string $subresource, $subId = null)
251		{
252	12	$parent = $this->fetchEntity($id);
253	12	$this->assertSubResourceMethodGranted(Method::DELETE, $parent, $subresource);
254	12	$this->removeAssociation($parent, $subresource, $subId);
255
256	12	return new JsonResponse(null, Response::HTTP_NO_CONTENT);
257		}
258
259		/**
260		* @param object $entity
261		*
262		* @return object
263		*/
264	12	protected function postProcessPostedEntity($entity)
265		{
266	12	return $entity;
267		}
268
269		/**
270		* @param object $entity
271		*
272		* @return object
273		*/
274	10	protected function postProcessPuttedEntity($entity)
275		{
276	10	return $entity;
277		}
278
279		/**
280		* @param object $parent
281		* @param string $subresource
282		* @param object $entity
283		*
284		* @return object
285		*/
286	2	protected function postProcessSubResourcePostedEntity($parent, $subresource, $entity)
		0 ignored issues – show Unused Code introduced 2017-10-12 13:28 UTC by Report Bug Copy Issue Report The parameter `$parent` 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... Unused Code introduced 2017-10-12 13:28 UTC by Report Bug Copy Issue Report The parameter `$subresource` 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...
287		{
288	2	return $entity;
289		}
290
291	80	protected function getEntityClass()
292		{
293	80	return $this->getCurrentRequest()->attributes->get('_entityClass');
294		}
295
296	2	protected function getSubResourceEntityClass($subresource)
297		{
298		/** @var PropertyMetadata $propertyMetadata */
299	2	$propertyMetadata = $this->getClassMetadata()->propertyMetadata[$subresource];
300
301	2	return $propertyMetadata->getType();
302		}
303
304	80	protected function getCurrentRequest()
305		{
306	80	return $this->getRequestStack()->getCurrentRequest();
307		}
308
309	70	protected function assertMethodGranted(string $methodName, $entity = null)
310		{
311	70	$method = $this->getClassMetadata()->getMethod($methodName);
312	70	if ($method !== null && null !== $right = $method->right) {
313	36	$this->assertRightGranted($right, $entity);
314		}
315	58	}
316
317		/**
318		* @param string $methodName
319		* @param object $entity
320		* @param string $subresource
321		*/
322	30	protected function assertSubResourceMethodGranted($methodName, $entity, string $subresource): void
323		{
324	30	$classMetadata = $this->getClassMetadata();
325		/** @var PropertyMetadata $propertyMetadata */
326	30	$propertyMetadata = $classMetadata->propertyMetadata[$subresource];
327	30	$method = $propertyMetadata->getMethod($methodName);
328	30	if (null !== $right = $method->right) {
329	14	$this->assertRightGranted($right, $entity);
330		}
331	28	}
332
333		/**
334		* @return ClassMetadata
335		*/
336	80	protected function getClassMetadata()
337		{
338	80	$metaDataFactory = $this->getMetadataFactory();
339		/** @var ClassMetadata $classMetaData */
340	80	$classMetaData = $metaDataFactory->getMetadataForClass($this->getEntityClass());
341
342	80	return $classMetaData;
343		}
344
345		protected function resolveSubject($entity, $propertyPath)
346		{
347		if ('this' === $propertyPath) {
348		return $entity;
349		}
350		$propertyAccessor = $this->getPropertyAccessor();
351
352		return $propertyAccessor->getValue($entity, $propertyPath);
353		}
354
355		/**
356		* @param Right $right
357		* @param object $entity
358		*/
359	46	protected function assertRightGranted(Right $right, $entity = null)
360		{
361	46	$propertyPath = $right->propertyPath;
362	46	if (null === $propertyPath \|\| null == $entity) {
363	46	$this->denyAccessUnlessGranted($right->attributes);
364		} else {
365		$subject = $this->resolveSubject($entity, $propertyPath);
366		$this->denyAccessUnlessGranted($right->attributes, $subject);
367		}
368	32	}
369
370	62	protected function parseIncludes(Request $request)
371		{
372	62	$defaultIncludes = $request->attributes->get('_defaultincludes');
373	62	if (null == $defaultIncludes) {
374	30	$defaultIncludes = [];
375		}
376
377	62	$includeString = $request->query->get('include');
378	62	if (empty($includeString)) {
379	48	$includes = [];
380		} else {
381	16	$includes = explode(',', $includeString);
382		}
383
384	62	return array_merge($defaultIncludes, $includes);
385		}
386
387	46	protected function denyAccessUnlessGranted($attributes, $object = null, $message = 'Access Denied.')
388		{
389	46	$authorizationChecker = $this->getAuthorizationChecker();
390	46	if (null === $authorizationChecker) {
391		throw new AccessDeniedException('No authorization checker configured');
392		}
393
394	46	if (!$authorizationChecker->isGranted($attributes, $object)) {
395	14	throw new AccessDeniedException($message);
396		}
397	32	}
398
399	2	protected function parseConstraintViolations(ConstraintViolationListInterface $errors)
400		{
401	2	$data = [];
402		/** @var ConstraintViolationInterface $error */
403	2	foreach ($errors as $error) {
404	2	$data[] = [
405	2	'propertyPath' => $error->getPropertyPath(),
406	2	'message' => $error->getMessage(),
407	2	'value' => $error->getInvalidValue()
408		];
409		}
410
411	2	return $data;
412		}
413
414	12	protected function addPaginationHeaders(Response $response, int $page, int $perPage, int $total)
415		{
416	12	$response->headers->add(
417		[
418	12	'x-pagination-current-page' => $page,
419	12	'x-pagination-per-page' => $perPage,
420	12	'x-pagination-total' => $total,
421	12	'x-pagination-total-pages' => (int)(($total - 1) / $perPage + 1)
422		]
423		);
424	12	}
425
426		/**
427		* {@inheritdoc}
428		*/
429	62	protected function getNormalizer()
430		{
431	62	return $this->normalizer;
432		}
433
434		/**
435		* {@inheritdoc}
436		*/
437	24	protected function getValidator()
438		{
439	24	return $this->validator;
440		}
441
442		/**
443		* {@inheritdoc}
444		*/
445	24	protected function getRequestParser()
446		{
447	24	return $this->requestParser;
448		}
449
450		/**
451		* {@inheritdoc}
452		*/
453	80	protected function getRequestStack()
454		{
455	80	return $this->requestStack;
456		}
457
458		/**
459		* {@inheritdoc}
460		*/
461	80	protected function getMetadataFactory()
462		{
463	80	return $this->metadataFactory;
464		}
465
466		/**
467		* {@inheritdoc}
468		*/
469		protected function getPropertyAccessor()
470		{
471		return $this->propertyAccessor;
472		}
473
474		/**
475		* {@inheritdoc}
476		*/
477	46	protected function getAuthorizationChecker(): ?AuthorizationCheckerInterface
478		{
479	46	return $this->authorizationChecker;
480		}
481
482		/**
483		* @param AuthorizationCheckerInterface $authorizationChecker
484		*/
485	76	public function setAuthorizationChecker(AuthorizationCheckerInterface $authorizationChecker): void
486		{
487	76	$this->authorizationChecker = $authorizationChecker;
488	76	}
489
490		/**
491		* @param int $page
492		* @param int $perPage
493		*
494		* @return Paginator\|array
495		*/
496		abstract protected function listEntities(int $page = 1, int $perPage = 50);
497
498		/**
499		* @param int\|string $id
500		*
501		* @return object
502		*
503		* @throws NotFoundHttpException Thrown if entity with the given id could not be found.
504		*/
505		abstract protected function fetchEntity($id);
506
507		/**
508		* @param object $entity
509		*
510		* @return object
511		*/
512		abstract protected function createEntity($entity);
513
514		/**
515		* @param object $entity
516		*
517		* @return object
518		*
519		* @throws NotFoundHttpException Thrown if entity with the given id could not be found.
520		*/
521		abstract protected function updateEntity($entity);
522
523		/**
524		* @param $entity
525		*
526		* @throws NotFoundHttpException Thrown if entity with the given id could not be found.
527		*/
528		abstract protected function removeEntity($entity);
529
530		/**
531		* @param object $entity
532		* @param string $subresource
533		* @param int $page
534		* @param int $perPage
535		*
536		* @return Paginator\|array
537		*/
538		abstract protected function listSubresource($entity, string $subresource, int $page = 1, int $perPage = 50);
539
540		/**
541		* @param object $parent
542		* @param string $subresource
543		*
544		* @return object
545		*/
546		abstract protected function createAssociation($parent, string $subresource, $entity);
547
548		/**
549		* @param object $parent
550		* @param string $subresource
551		* @param int\|string $subId
552		*
553		* @return object
554		*/
555		abstract protected function addAssociation($parent, string $subresource, $subId);
556
557		/**
558		* @param object $parent
559		* @param string $subresource
560		* @param int\|string\|null $subId
561		*
562		* @return mixed
563		*/
564		abstract protected function removeAssociation($parent, string $subresource, $subId = null);
565		}
566

dontdrinkandroot / rest-bundle.php

Push — master ( 56c59d...5628a9 )

AbstractRestResourceController D

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

42 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like