Saikootau\ApiBundle\EventListener\ResourceResponseListener

Complexity

Total Complexity

15

Size/Duplication

Total Lines	127
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	getResource()	0	7	2
A	getStatusCode()	0	7	3
A	getSerializer()	0	15	2
A	getHeaders()	0	8	2
A	getRequestAcceptableContentTypes()	0	9	2
A	onKernelView()	0	19	3
A	__construct()	0	4	1

<?php

declare(strict_types=1);

namespace Saikootau\ApiBundle\EventListener;

use Saikootau\ApiBundle\Http\ResourceResponse;
use Saikootau\ApiBundle\MediaType\Exception\NonNegotiableMediaTypeException;
use Saikootau\ApiBundle\MediaType\MediaTypeNegotiator;
use Saikootau\ApiBundle\MediaType\MediaTypes;
use Saikootau\ApiBundle\Serializer\Serializer;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Event\GetResponseForControllerResultEvent;
use Symfony\Component\HttpKernel\Exception\NotAcceptableHttpException;

class ResourceResponseListener
{
    private $defaultContentType;
    private $mediaTypeNegotiator;

    public function __construct(MediaTypeNegotiator $mediaTypeNegotiator, string $defaultContentType)
    {
        $this->mediaTypeNegotiator = $mediaTypeNegotiator;
        $this->defaultContentType = $defaultContentType;
    }

    public function onKernelView(GetResponseForControllerResultEvent $event): void
    {
        $controllerResult = $event->getControllerResult();

        if ($controllerResult instanceof Response) {
            return;
        }

        $serializer = $this->getSerializer($event->getRequest());

        $body = '';
        if (null !== $controllerResult) {
            $body = $serializer->serialize($this->getResource($controllerResult));
        }

        $event->setResponse(new Response(
            $body,
            $this->getStatusCode($event->getRequest(), $controllerResult),
            $this->getHeaders($controllerResult, $serializer->getContentType())
        ));
    }

    /**
     * Get the actual resource from the controller result.
     *
     * @param object $controllerResult
     *
     * @return object
     */
    private function getResource(object $controllerResult): object
    {
        if ($controllerResult instanceof ResourceResponse) {
            return $controllerResult->getResource();
        }

        return $controllerResult;
    }

    /**
     * Get the status code to return from the controller result.
     * Defaults to 202 for POST, PUT and 200 for every other method.
     *
     * @param Request     $request
     * @param object|null $controllerResult
     *
     * @return int
     */
    private function getStatusCode(Request $request, ?object $controllerResult): int
    {
        if ($controllerResult instanceof ResourceResponse) {
            return $controllerResult->getStatusCode();
        }

        return in_array($request->getMethod(), ['POST', 'PUT']) ? Response::HTTP_ACCEPTED : Response::HTTP_OK;
    }

    /**
     * Generates an array of headers for the given controller result.
     *
     * @param object|null $controllerResult
     * @param string      $contentType
     *
     * @return array
     */
    private function getHeaders(?object $controllerResult, string $contentType): array
    {
        $headers = ['Content-Type' => $contentType];
        if ($controllerResult instanceof ResourceResponse) {
            $headers = array_merge($controllerResult->getHeaders(), $headers);
        }

        return $headers;
    }

    /**
     * Get a matching serializer for the given request's acceptable content types.
     *
     * @param Request $request
     *
     * @return Serializer
     *
     * @throws NotAcceptableHttpException
     */
    private function getSerializer(Request $request): Serializer
    {
        try {
            /** @var Serializer $serializer */
            $serializer = $this->mediaTypeNegotiator->negotiate(...$this->getRequestAcceptableContentTypes($request));
        } catch (NonNegotiableMediaTypeException $exception) {
            throw new NotAcceptableHttpException(
                sprintf(
                    'Deliverable content types are: %s',
                    implode(', ', $this->mediaTypeNegotiator->getSupportedMediaTypes())
                )
            );
        }

        return $serializer;
    }

    /**
     * Returns an array of acceptable content types for the given request.
     *
     * @param Request $request
     *
     * @return string[]
     */
    private function getRequestAcceptableContentTypes(Request $request): array
    {
        $acceptableContentTypes = $request->getAcceptableContentTypes();

        if (false !== ($anyIndex = array_search(MediaTypes::TYPE_APPLICATION_ANY, $acceptableContentTypes))) {
            $acceptableContentTypes[$anyIndex] = $this->defaultContentType;
        }

        return $acceptableContentTypes;
    }
}