Chubbyphp\ApiHttp\Manager\ResponseManager

Complexity

Total Complexity

10

Size/Duplication

Total Lines	180
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

56.86%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	create()	0	13	1
A	createEmpty()	0	4	1
A	createRedirect()	0	4	1
A	createFromError()	0	8	1
A	createNotAuthenticated()	0	9	1
A	createNotAuthorized()	0	9	1
A	createResourceNotFound()	0	14	1
A	createAcceptNotSupported()	0	8	1
A	createContentTypeNotSupported()	0	17	1

<?php

declare(strict_types=1);

namespace Chubbyphp\ApiHttp\Manager;

use Chubbyphp\ApiHttp\Error\Error;
use Chubbyphp\ApiHttp\Error\ErrorInterface;
use Chubbyphp\ApiHttp\Factory\ResponseFactoryInterface;
use Chubbyphp\Serialization\Normalizer\NormalizerContextInterface;
use Chubbyphp\Serialization\SerializerInterface;
use Psr\Http\Message\ServerRequestInterface as Request;
use Psr\Http\Message\ResponseInterface as Response;

final class ResponseManager implements ResponseManagerInterface
{
    /**
     * @var ResponseFactoryInterface
     */
    private $responseFactory;

    /**
     * @var SerializerInterface
     */
    private $serializer;

    /**
     * @param ResponseFactoryInterface $responseFactory
     * @param SerializerInterface      $serializer
     */
    public function __construct(
        ResponseFactoryInterface $responseFactory,
        SerializerInterface $serializer
    ) {
        $this->responseFactory = $responseFactory;
        $this->serializer = $serializer;
    }

    /**
     * @param object                          $object
     * @param string                          $accept
     * @param int                             $status
     * @param NormalizerContextInterface|null $context
     *
     * @return Response
     */
    public function create(
        $object,
        string $accept,
        int $status = 200,
        NormalizerContextInterface $context = null
    ): Response {
        $body = $this->serializer->serialize($object, $accept, $context);

        $response = $this->responseFactory->createResponse($status)->withHeader('Content-Type', $accept);
        $response->getBody()->write($body);

        return $response;
    }

    /**
     * @param string $accept
     * @param int    $status
     *
     * @return Response
     */
    public function createEmpty(string $accept, int $status = 204): Response
    {
        return $this->responseFactory->createResponse($status)->withHeader('Content-Type', $accept);
    }

    /**
     * @param string $location
     * @param int    $status
     *
     * @return Response
     */
    public function createRedirect(string $location, int $status = 307): Response
    {
        return $this->responseFactory->createResponse($status)->withHeader('Location', $location);
    }

    /**
     * @param ErrorInterface                  $error
     * @param string                          $accept
     * @param int                             $status
     * @param NormalizerContextInterface|null $context
     *
     * @return Response
     */
    public function createFromError(
        ErrorInterface $error,
        string $accept,
        int $status = 400,
        NormalizerContextInterface $context = null
    ): Response {
        return $this->create($error, $accept, $status, $context);
    }

    /**
     * @param string                          $accept
     * @param NormalizerContextInterface|null $context
     *
     * @return Response
     */
    public function createNotAuthenticated(string $accept, NormalizerContextInterface $context = null): Response
    {
        return $this->createFromError(new Error(
            Error::SCOPE_HEADER,
            'not_authenticated',
            'missing or invalid authentication token to perform the request',
            'authentication'
        ), $accept, 401, $context);
    }

    /**
     * @param string                          $accept
     * @param NormalizerContextInterface|null $context
     *
     * @return Response
     */
    public function createNotAuthorized(string $accept, NormalizerContextInterface $context = null): Response
    {
        return $this->createFromError(new Error(
            Error::SCOPE_HEADER,
            'permission_denied',
            'missing authorization to perform request',
            'authorization'
        ), $accept, 403, $context);
    }

    /**
     * @param string                          $type
     * @param array                           $arguments
     * @param string                          $accept
     * @param NormalizerContextInterface|null $context
     *
     * @return Response
     */
    public function createResourceNotFound(
        string $type,
        array $arguments,
        string $accept,
        NormalizerContextInterface $context = null
    ): Response {
        return $this->createFromError(new Error(
            Error::SCOPE_RESOURCE,
            'resource_not_found',
            'the requested resource cannot be found',
            $type,
            $arguments
        ), $accept, 404, $context);
    }

    /**
     * @param string $accept
     *
     * @return Response
     */
    public function createAcceptNotSupported(string $accept): Response
    {
        return $this->responseFactory->createResponse(406)->withHeader('X-Not-Acceptable', sprintf(
            'Accept "%s" is not supported, supported are %s',
            $accept,
            implode(', ', $this->serializer->getContentTypes())
        ));
    }

    /**
     * @param string                          $contentType
     * @param string                          $accept
     * @param array                           $supportedContentTypes
     * @param NormalizerContextInterface|null $context
     *
     * @return Response
     */
    public function createContentTypeNotSupported(
        string $contentType,
        string $accept,
        array $supportedContentTypes,
        NormalizerContextInterface $context = null
    ): Response {
        return $this->createFromError(new Error(
            Error::SCOPE_HEADER,
            'contentype_not_supported',
            'the given content type is not supported',
            'content-type',
            [
                'contentType' => $contentType,
                'supportedContentTypes' => $supportedContentTypes,
            ]
        ), $accept, 415, $context);
    }
}