Innmind\Rest\ServerBundle\Controller\ResourceController

Complexity

Total Complexity

11

Size/Duplication

Total Lines	175
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	21

Test Coverage

Coverage

96.39%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	24	3
B	listAction()	0	66	6
B	getAction()	0	39	1
B	optionsAction()	0	32	1

<?php
declare(strict_types = 1);

namespace Innmind\Rest\ServerBundle\Controller;

use Innmind\Rest\ServerBundle\{
    Format,
    Exception\InvalidArgumentException
};
use Innmind\Rest\Server\{
    RangeExtractor\ExtractorInterface,
    SpecificationBuilder\BuilderInterface,
    Response\HeaderBuilder\ListBuilderInterface,
    Response\HeaderBuilder\GetBuilderInterface,
    GatewayInterface,
    Request\Range,
    Exception\RangeNotFoundException,
    Exception\NoFilterFoundException,
    Identity
};
use Innmind\Http\{
    Message\ResponseInterface,
    Message\Response,
    Message\StatusCode,
    Message\ReasonPhrase,
    Headers,
    Header\HeaderInterface,
    Header\ContentType,
    Header\ContentTypeValue,
    Header\ParameterInterface,
    Exception\Http\RangeNotSatisfiableException
};
use Innmind\Filesystem\Stream\StringStream;
use Innmind\Immutable\{
    Map,
    MapInterface
};
use Symfony\Component\{
    HttpFoundation\Request,
    Serializer\SerializerInterface
};

final class ResourceController
{
    private $format;
    private $serializer;
    private $rangeExtractor;
    private $specificationBuilder;
    private $gateways;
    private $listHeaderBuilder;
    private $getHeaderBuilder;

    public function __construct(
        Format $format,
        SerializerInterface $serializer,
        ExtractorInterface $rangeExtractor,
        BuilderInterface $specificationBuilder,
        MapInterface $gateways,
        ListBuilderInterface $listHeaderBuilder,
        GetBuilderInterface $getHeaderBuilder
    ) {
        if (
            (string) $gateways->keyType() !== 'string' ||
            (string) $gateways->valueType() !== GatewayInterface::class
        ) {
            throw new InvalidArgumentException;
        }

        $this->format = $format;
        $this->serializer = $serializer;
        $this->rangeExtractor = $rangeExtractor;
        $this->specificationBuilder = $specificationBuilder;
        $this->gateways = $gateways;
        $this->listHeaderBuilder = $listHeaderBuilder;
        $this->getHeaderBuilder = $getHeaderBuilder;
    }

    public function listAction(Request $request): ResponseInterface
    {
        $definition = $request->attributes->get('_innmind_resource_definition');
        $request = $request->attributes->get('_innmind_request');

        try {
            $range = $this->rangeExtractor->extract($request);
        } catch (RangeNotFoundException $e) {
            $range = null;
        }

        try {
            $specification = $this->specificationBuilder->buildFrom(
                $request,
                $definition
            );
        } catch (NoFilterFoundException $e) {
            $specification = null;
        }

        $accessor = $this
            ->gateways
            ->get((string) $definition->gateway())
            ->resourceListAccessor();
        $identities = $accessor(
            $definition,
            $specification,
            $range
        );

        if (
            $identities->size() === 0 &&
            $range instanceof Range
        ) {
            throw new RangeNotSatisfiableException;
        }

        return new Response(
            $code = new StatusCode(StatusCode::codes()->get(
                $range instanceof Range ? 'PARTIAL_CONTENT' : 'OK'
            )),
            new ReasonPhrase(ReasonPhrase::defaults()->get($code->value())),
            $request->protocolVersion(),
            new Headers(
                $this->listHeaderBuilder->build(
                    $identities,
                    $request,
                    $definition,
                    $specification,
                    $range
                )
            ),
            new StringStream(
                $this->serializer->serialize(
                    $identities,
                    $this->format->acceptable($request)->name(),
                    [
                        'request' => $request,
                        'definition' => $definition,
                        'specification' => $specification,
                        'range' => $range,
                    ]
                )
            )
        );
    }

    public function getAction(Request $request, $identity): ResponseInterface
    {
        $definition = $request->attributes->get('_innmind_resource_definition');
        $request = $request->attributes->get('_innmind_request');

        $accessor = $this
            ->gateways
            ->get((string) $definition->gateway())
            ->resourceAccessor();
        $resource = $accessor(
            $definition,
            $identity = new Identity($identity)
        );

        return new Response(
            $code = new StatusCode(StatusCode::codes()->get('OK')),
            new ReasonPhrase(ReasonPhrase::defaults()->get($code->value())),
            $request->protocolVersion(),
            new Headers(
                $this->getHeaderBuilder->build(
                    $resource,
                    $request,
                    $definition,
                    $identity
                )
            ),
            new StringStream(
                $this->serializer->serialize(
                    $resource,
                    $this->format->acceptable($request)->name(),
                    [
                        'request' => $request,
                        'definition' => $definition,
                        'identity' => $identity,
                    ]
                )
            )
        );
    }

    public function optionsAction(Request $request): ResponseInterface
    {
        $definition = $request->attributes->get('_innmind_resource_definition');
        $request = $request->attributes->get('_innmind_request');
        $format = $this->format->acceptable($request);
        $mediaType = $format->preferredMediaType();

        return new Response(
            $code = new StatusCode(StatusCode::codes()->get('OK')),
            new ReasonPhrase(ReasonPhrase::defaults()->get($code->value())),
            $request->protocolVersion(),
            new Headers(
                (new Map('string', HeaderInterface::class))
                    ->put(
                        'Content-Type',
                        new ContentType(
                            new ContentTypeValue(
                                $mediaType->topLevel(),
                                $mediaType->subType(),
                                new Map('string', ParameterInterface::class)
                            )
                        )
                    )
            ),
            new StringStream(
                $this->serializer->serialize(
                    $definition,
                    $format->name()
                )
            )
        );
    }
}