Chubbyphp\ApiHttp\Manager\ResponseManager

Complexity

Total Complexity

10

Size/Duplication

Total Lines	200
Duplicated Lines	32 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

23.64%

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	createByError()	0	8	1
A	createNotAuthenticated()	19	19	1
A	createNotAuthorized()	14	14	1
A	createResourceNotFound()	14	14	1
A	createAcceptNotSupported()	0	8	1
A	createContentTypeNotSupported()	17	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 createByError(
        ErrorInterface $error,
        string $accept,
        int $status = 400,
        NormalizerContextInterface $context = null
    ): Response {
        return $this->create($error, $accept, $status, $context);
    }

    /**
     * @param Request                         $request
     * @param string                          $accept
     * @param string                          $authenticationType
     * @param string                          $reason
     * @param NormalizerContextInterface|null $context
     *
     * @return Response
     */
    public function createNotAuthenticated(

This method seems to be duplicated in your project.

        Request $request,
        string $accept,
        string $authenticationType,
        string $reason,
        NormalizerContextInterface $context = null
    ): Response {
        return $this->createByError(new Error(
            Error::SCOPE_HEADER,
            'not_authenticated',
            'missing or invalid authentication token',
            'authentication',
            [
                'type' => $authenticationType,
                'value' => $request->getHeaderLine('Authorization'),
                'reason' => $reason,
            ]
        ), $accept, 401, $context);
    }

    /**
     * @param string                          $type
     * @param array                           $arguments
     * @param string                          $accept
     * @param NormalizerContextInterface|null $context
     *
     * @return Response
     */
    public function createNotAuthorized(

This method seems to be duplicated in your project.

        string $type,
        array $arguments,
        string $accept,
        NormalizerContextInterface $context = null
    ): Response {
        return $this->createByError(new Error(
            Error::SCOPE_HEADER,
            'permission_denied',
            'authenticated client/user is not allowed to perform this action',
            $type,
            $arguments
        ), $accept, 403, $context);
    }

    /**
     * @param string                          $type
     * @param array                           $arguments
     * @param string                          $accept
     * @param NormalizerContextInterface|null $context
     *
     * @return Response
     */
    public function createResourceNotFound(

This method seems to be duplicated in your project.

        string $type,
        array $arguments,
        string $accept,
        NormalizerContextInterface $context = null
    ): Response {
        return $this->createByError(new Error(
            Error::SCOPE_RESOURCE,
            'resource_not_found',
            'the requested resource cannot be found',
            $type,
            $arguments
        ), $accept, 404, $context);
    }

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

    /**
     * @param Request                         $request
     * @param string                          $accept
     * @param array                           $supportedContentTypes
     * @param NormalizerContextInterface|null $context
     *
     * @return Response
     */
    public function createContentTypeNotSupported(

This method seems to be duplicated in your project.

        Request $request,
        string $accept,
        array $supportedContentTypes,
        NormalizerContextInterface $context = null
    ): Response {
        return $this->createByError(new Error(
            Error::SCOPE_HEADER,
            'contentype_not_supported',
            'the given content type is not supported',
            'content-type',
            [
                'contentType' => $request->getHeaderLine('Content-Type'),
                'supportedContentTypes' => $supportedContentTypes,
            ]
        ), $accept, 415, $context);
    }
}