AbstractRestResourceController::postSubresourceAction() - Code Metrics - Inspection of "Updating Deps, dropping service definition, fixes" - dontdrinkandroot/rest-bundle.php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( faed70...56c59d )

by Philip

created 2017-12-29 12:52 UTC

postSubresourceAction() A

↳ Parent: AbstractRestResourceController

Complexity

Conditions	2
Paths	2

Size

Total Lines	22
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	11
CRAP Score	2.0023

Importance

Changes

Metric	Value
dl	0
loc	22
ccs	11
cts	12
cp	0.9167
rs	9.2
c	0
b	0
f	0
cc	2
eloc	12
nc	2
nop	3
crap	2.0023

<?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\RestRequestParser;
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
{
    /**
     * {@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)
            ]
        );
    }

    /**
     * @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);

    /**
     * @return Normalizer
     */
    abstract protected function getNormalizer();

    /**
     * @return ValidatorInterface
     */
    abstract protected function getValidator();

    /**
     * @return RestRequestParser
     */
    abstract protected function getRequestParser();

    /**
     * @return RequestStack
     */
    abstract protected function getRequestStack();

    /**
     * @return MetadataFactoryInterface
     */
    abstract protected function getMetadataFactory();

    /**
     * @return PropertyAccessorInterface
     */
    abstract protected function getPropertyAccessor();

    /**
     * @return AuthorizationCheckerInterface
     */
    abstract protected function getAuthorizationChecker();
}


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

dontdrinkandroot / rest-bundle.php

Push — master ( faed70...56c59d )

postSubresourceAction() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like