Silverback\ApiComponentBundle\Controller\FileUploadAction

Complexity

Total Complexity

13

Size/Duplication

Total Lines	115
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

2 Methods

Rating	Name	Duplication	Size	Complexity
C	__invoke()	0	74	12
A	__construct()	0	16	1

<?php

namespace Silverback\ApiComponentBundle\Controller;

use ApiPlatform\Core\DataProvider\ItemDataProviderInterface;
use ApiPlatform\Core\Metadata\Resource\Factory\ResourceMetadataFactoryInterface;
use InvalidArgumentException;
use RuntimeException;
use Silverback\ApiComponentBundle\Entity\Component\FileInterface;

The type Silverback\ApiComponentBundle\Entity\Component\FileInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use Silverback\ApiComponentBundle\File\Uploader\FileUploader;

The type Silverback\ApiComponentBundle\File\Uploader\FileUploader was not found. Maybe you did not declare it correctly or list all dependencies?

use Silverback\ApiComponentBundle\Security\RestrictedResourceVoter;

The type Silverback\ApiComponentBundle\Security\RestrictedResourceVoter was not found. Maybe you did not declare it correctly or list all dependencies?

use Silverback\ApiComponentBundle\Serializer\ApiContextBuilder;

The type Silverback\ApiComponentBundle\Serializer\ApiContextBuilder was not found. Maybe you did not declare it correctly or list all dependencies?

use Symfony\Component\HttpFoundation\BinaryFileResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\PropertyAccess\PropertyAccess;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\Routing\Matcher\UrlMatcherInterface;
use Symfony\Component\Routing\RequestContext;
use Symfony\Component\Security\Core\Exception\AccessDeniedException;
use Symfony\Component\Serializer\SerializerInterface;

class FileUploadAction
{
    private $urlMatcher;
    private $itemDataProvider;
    private $uploader;
    private $serializer;
    private $resourceMetadataFactory;
    private $apiContextBuilder;
    private $restrictedResourceVoter;

    public function __construct(
        UrlMatcherInterface $urlMatcher,
        ItemDataProviderInterface $itemDataProvider,
        FileUploader $uploader,
        SerializerInterface $serializer,
        ResourceMetadataFactoryInterface $resourceMetadataFactory,
        ApiContextBuilder $apiContextBuilder,
        RestrictedResourceVoter $restrictedResourceVoter
    ) {
        $this->urlMatcher = $urlMatcher;
        $this->itemDataProvider = $itemDataProvider;
        $this->uploader = $uploader;
        $this->serializer = $serializer;
        $this->resourceMetadataFactory = $resourceMetadataFactory;
        $this->apiContextBuilder = $apiContextBuilder;
        $this->restrictedResourceVoter = $restrictedResourceVoter;
    }

    /**
     * @param Request $request
     * @param string $field
     * @param string $id
     * @Route(
     *     name="files_upload",
     *     path="/files/{field}/{id}.{_format}",
     *     requirements={"field"="\w+", "id"=".+"},
     *     defaults={"_format"="jsonld"},
     *     methods={"POST", "PUT", "GET"}
     * )
     * @return Response
     */
    public function __invoke(Request $request, string $field, string $id)
    {
        $contentType = $request->headers->get('CONTENT_TYPE');
        $_format = $request->attributes->get('_format') ?: $request->getFormat($contentType);

        /**
         * MATCH THE ID TO A ROUTE TO FIND RESOURCE CLASS AND ID
         * @var array|null $route
         */
        $ctx = new RequestContext();
        $ctx->fromRequest($request);
        $ctx->setMethod('GET');
        $this->urlMatcher->setContext($ctx);
        $route = $this->urlMatcher->match($id);
        if (empty($route) || !isset($route['_api_resource_class'])) {
            return new Response(sprintf('No route/resource found for id %s', $id), Response::HTTP_BAD_REQUEST);
        }

        /**
         * GET THE ENTITY
         */
        $entity = $this->itemDataProvider->getItem($route['_api_resource_class'], $route['id']);
        if (!$entity) {
            return new Response(sprintf('Entity not found from provider %s (ID: %s)', $route['_api_resource_class'], $route['id']), Response::HTTP_BAD_REQUEST);
        }
        if (!($entity instanceof FileInterface)) {
            return new Response(sprintf('Provider %s does not implement %s', $route['_api_resource_class'], FileInterface::class), Response::HTTP_BAD_REQUEST);
        }
        $method = strtolower($request->getMethod());

        if ($method === 'get') {
            $propertyAccessor = PropertyAccess::createPropertyAccessor();
            if (!$this->restrictedResourceVoter->vote($entity)) {
                throw new AccessDeniedException('You are not permitted to download this file');
            }
            $filePath = $propertyAccessor->getValue($entity, $field);
            return new BinaryFileResponse($filePath);
        }

        /**
         * CHECK WE HAVE A FILE - WASTE OF TIME DOING ANYTHING ELSE OTHERWISE
         */
        if (!$request->files->count()) {
            return new Response('No files have been submitted', Response::HTTP_BAD_REQUEST);
        }

        /**
         * UPLOAD THE FILE
         */
        $files = $request->files->all();
        try {
            $entity = $this->uploader->upload($entity, $field, reset($files), $method);
        } catch (InvalidArgumentException $exception) {
            return new Response($exception->getMessage(), Response::HTTP_BAD_REQUEST);
        } catch (RuntimeException $exception) {
            return new Response($exception->getMessage(), Response::HTTP_INTERNAL_SERVER_ERROR);
        }

        /**
         * Return the entity back in the format requested
         */
        $resourceMetadata = $this->resourceMetadataFactory->create($route['_api_resource_class']);
        $serializerGroups = $resourceMetadata->getOperationAttribute(
            ['item_operation_name' => $method],
            'serializer_groups',
            [],
            true
        );
        $customGroups = $this->apiContextBuilder->getGroups($route['_api_resource_class'], true);
        if (\count($customGroups)) {
            $serializerGroups = array_merge($serializerGroups ?? [], ...$customGroups);
        }
        $serializedData = $this->serializer->serialize($entity, $_format, ['groups' => $serializerGroups]);

It seems like $_format can also be of type null; however, parameter $format of Symfony\Component\Serializer\SerializerInterface::serialize() does only seem to accept string, maybe add an additional type check?

        return new Response($serializedData, Response::HTTP_OK);
    }
}