ResponseFactory::setHttpResponse() - Code Metrics - alex-kalanis/restful - Measure and Improve Code Quality continuously with Scrutinizer

ResponseFactory::setHttpResponse() A
last analyzed 2024-12-26 06:23 UTC

↳ Parent: ResponseFactory

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
eloc	2
dl	0
loc	4
ccs	0
cts	2
cp	0
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1
crap	2

<?php

namespace kalanis\Restful\Application;


use kalanis\Restful\Exceptions\InvalidArgumentException;
use kalanis\Restful\Exceptions\InvalidStateException;
use kalanis\Restful\IResource;
use kalanis\Restful\Mapping\MapperContext;
use Nette\Http\IRequest;
use Nette\Http\IResponse;
use function str_contains;


/**
 * REST ResponseFactory
 * @package kalanis\Restful\Application
 */
class ResponseFactory implements IResponseFactory
{

    /** @var string|null JSONP request key */
    private ?string $jsonp = null;

    /** @var string pretty print key */
    private string $prettyPrintKey = 'prettyPrint';

    private bool $prettyPrint = true;

    /** @var array<string, class-string> */

    private array $responses = [
        IResource::JSON => Responses\TextResponse::class,
        IResource::JSONP => Responses\JsonpResponse::class,
        IResource::QUERY => Responses\TextResponse::class,
        IResource::XML => Responses\TextResponse::class,
        IResource::FILE => Responses\FileResponse::class,
        IResource::NULL => Responses\NullResponse::class
    ];

    public function __construct(
        private IResponse              $response,
        private readonly IRequest      $request,
        private readonly MapperContext $mapperContext,
    )
    {
    }

    /**
     * Get JSONP key
     * @return string|null [type] [description]
     */
    public function getJsonp(): ?string
    {
        return $this->jsonp;
    }

    /**
     * Set JSONP key
     */
    public function setJsonp(?string $jsonp): self
    {
        $this->jsonp = $jsonp;
        return $this;
    }

    /**
     * Set pretty print key
     */
    public function setPrettyPrintKey(string $prettyPrintKey): self
    {
        $this->prettyPrintKey = $prettyPrintKey;
        return $this;
    }

    /**
     * Register new response type to factory
     * @param string $mimeType
     * @param class-string $responseClass

     * @throws InvalidArgumentException
     * @return $this
     *
     */
    public function registerResponse(string $mimeType, string $responseClass): static
    {
        if (!class_exists($responseClass)) {
            throw new InvalidArgumentException('Response class does not exist.');
        }

        $this->responses[$mimeType] = $responseClass;
        return $this;
    }

    /**
     * Unregister API response from factory
     */
    public function unregisterResponse(string $mimeType): void
    {
        unset($this->responses[$mimeType]);
    }

    /**
     * Set HTTP response
     */
    public function setHttpResponse(IResponse $response): self
    {
        $this->response = $response;
        return $this;
    }

    /**
     * Create new api response
     * @param IResource $resource
     * @param string|null $contentType
     * @throws InvalidStateException
     * @return Responses\IResponse
     */
    public function create(IResource $resource, ?string $contentType = null): Responses\IResponse
    {
        if (is_null($contentType)) {
            $contentType = is_null($this->jsonp) || empty($this->request->getQuery($this->jsonp))
                ? $this->getPreferredContentType(strval($this->request->getHeader('Accept')))
                : IResource::JSONP;
        }

        if (!isset($this->responses[$contentType])) {
            throw new InvalidStateException('Unregistered API response for ' . $contentType);
        }

        if (!class_exists($this->responses[$contentType])) {
            throw new InvalidStateException('API response class does not exist.');
        }

        if (empty($resource->getData())) {
            $this->response->setCode(204); // No content
            $reflection = new \ReflectionClass($this->responses[$contentType]);
            $response = $reflection->newInstance(
                $resource->getData(),
                $this->mapperContext->getMapper($contentType),
            );
            /** @var Responses\IResponse $response */
            return $response;
        }

        $responseClass = $this->responses[$contentType];
        $reflection = new \ReflectionClass($responseClass);
        $response = $reflection->newInstance(
            $resource->getData(),
            $this->mapperContext->getMapper($contentType),
            $contentType,
        );
        /** @var Responses\IResponse $response */
        if ($response instanceof Responses\BaseResponse) {
            $response->setPrettyPrint($this->isPrettyPrint());
        }
        return $response;
    }

    /**
     * Get preferred request content type
     * @param string $contentType may be separated with comma
     * @throws  InvalidStateException If Accept header is unknown
     * @return string
     */
    protected function getPreferredContentType(string $contentType): string
    {
        $accept = explode(',', $contentType);
        $acceptableTypes = array_keys($this->responses);
        if (!$contentType) {
            return $acceptableTypes[0];
        }
        foreach ($accept as $mimeType) {
            if ('*/*' === $mimeType) return $acceptableTypes[0];
            foreach ($acceptableTypes as $formatMime) {
                if (empty($formatMime)) {
                    continue;
                }
                if (str_contains($mimeType, $formatMime)) {
                    return $formatMime;
                }
            }
        }
        throw new InvalidStateException('Unknown Accept header: ' . $contentType);
    }

    /**
     * Is pretty print enabled
     * @return boolean
     */
    protected function isPrettyPrint(): bool
    {
        $prettyPrintKey = $this->request->getQuery($this->prettyPrintKey);
        if ('false' === $prettyPrintKey) {
            return false;
        }
        if ('true' === $prettyPrintKey) {
            return true;
        }
        return $this->prettyPrint;
    }

    /**
     * Set pretty print
     */
    public function setPrettyPrint(bool $prettyPrint): self
    {
        $this->prettyPrint = $prettyPrint;
        return $this;
    }

    /**
     * Is given content type acceptable for response
     */
    public function isAcceptable(string $contentType): bool
    {
        try {
            $this->getPreferredContentType($contentType);
            return true;
        } catch (InvalidStateException) {
            return false;
        }
    }
}


1		<?php
2
3		namespace kalanis\Restful\Application;
4
5
6		use kalanis\Restful\Exceptions\InvalidArgumentException;
7		use kalanis\Restful\Exceptions\InvalidStateException;
8		use kalanis\Restful\IResource;
9		use kalanis\Restful\Mapping\MapperContext;
10		use Nette\Http\IRequest;
11		use Nette\Http\IResponse;
12		use function str_contains;
13
14
15		/**
16		* REST ResponseFactory
17		* @package kalanis\Restful\Application
18		*/
19	1	class ResponseFactory implements IResponseFactory
20		{
21
22		/** @var string\|null JSONP request key */
23		private ?string $jsonp = null;
24
25		/** @var string pretty print key */
26		private string $prettyPrintKey = 'prettyPrint';
27
28		private bool $prettyPrint = true;
29
30		/** @var array<string, class-string> */
		0 ignored issues – show Documentation Bug introduced 2024-12-26 05:23 UTC by Report Bug Copy Issue Report The doc comment `array<string, class-string>` at position `4` could not be parsed: Unknown type name 'class-string' at position 4 in array<string, class-string>. Loading history...
31		private array $responses = [
32		IResource::JSON => Responses\TextResponse::class,
33		IResource::JSONP => Responses\JsonpResponse::class,
34		IResource::QUERY => Responses\TextResponse::class,
35		IResource::XML => Responses\TextResponse::class,
36		IResource::FILE => Responses\FileResponse::class,
37		IResource::NULL => Responses\NullResponse::class
38		];
39
40	1	public function __construct(
41		private IResponse $response,
42		private readonly IRequest $request,
43		private readonly MapperContext $mapperContext,
44		)
45		{
46	1	}
47
48		/**
49		* Get JSONP key
50		* @return string\|null [type] [description]
51		*/
52		public function getJsonp(): ?string
53		{
54		return $this->jsonp;
55		}
56
57		/**
58		* Set JSONP key
59		*/
60		public function setJsonp(?string $jsonp): self
61		{
62	1	$this->jsonp = $jsonp;
63	1	return $this;
64		}
65
66		/**
67		* Set pretty print key
68		*/
69		public function setPrettyPrintKey(string $prettyPrintKey): self
70		{
71	1	$this->prettyPrintKey = $prettyPrintKey;
72	1	return $this;
73		}
74
75		/**
76		* Register new response type to factory
77		* @param string $mimeType
78		* @param class-string $responseClass
		0 ignored issues – show Documentation Bug introduced 2024-12-26 05:23 UTC by Report Bug Copy Issue Report The doc comment `class-string` at position `0` could not be parsed: Unknown type name 'class-string' at position 0 in class-string. Loading history...
79		* @throws InvalidArgumentException
80		* @return $this
81		*
82		*/
83		public function registerResponse(string $mimeType, string $responseClass): static
84		{
85	1	if (!class_exists($responseClass)) {
86	1	throw new InvalidArgumentException('Response class does not exist.');
87		}
88
89	1	$this->responses[$mimeType] = $responseClass;
90	1	return $this;
91		}
92
93		/**
94		* Unregister API response from factory
95		*/
96		public function unregisterResponse(string $mimeType): void
97		{
98		unset($this->responses[$mimeType]);
99		}
100
101		/**
102		* Set HTTP response
103		*/
104		public function setHttpResponse(IResponse $response): self
105		{
106		$this->response = $response;
107		return $this;
108		}
109
110		/**
111		* Create new api response
112		* @param IResource $resource
113		* @param string\|null $contentType
114		* @throws InvalidStateException
115		* @return Responses\IResponse
116		*/
117		public function create(IResource $resource, ?string $contentType = null): Responses\IResponse
118		{
119	1	if (is_null($contentType)) {
120	1	$contentType = is_null($this->jsonp) \|\| empty($this->request->getQuery($this->jsonp))
121	1	? $this->getPreferredContentType(strval($this->request->getHeader('Accept')))
122	1	: IResource::JSONP;
123		}
124
125	1	if (!isset($this->responses[$contentType])) {
126		throw new InvalidStateException('Unregistered API response for ' . $contentType);
127		}
128
129	1	if (!class_exists($this->responses[$contentType])) {
130		throw new InvalidStateException('API response class does not exist.');
131		}
132
133	1	if (empty($resource->getData())) {
134	1	$this->response->setCode(204); // No content
135	1	$reflection = new \ReflectionClass($this->responses[$contentType]);
136	1	$response = $reflection->newInstance(
137	1	$resource->getData(),
138	1	$this->mapperContext->getMapper($contentType),
139		);
140		/** @var Responses\IResponse $response */
141	1	return $response;
142		}
143
144	1	$responseClass = $this->responses[$contentType];
145	1	$reflection = new \ReflectionClass($responseClass);
146	1	$response = $reflection->newInstance(
147	1	$resource->getData(),
148	1	$this->mapperContext->getMapper($contentType),
149		$contentType,
150		);
151		/** @var Responses\IResponse $response */
152	1	if ($response instanceof Responses\BaseResponse) {
153	1	$response->setPrettyPrint($this->isPrettyPrint());
154		}
155	1	return $response;
156		}
157
158		/**
159		* Get preferred request content type
160		* @param string $contentType may be separated with comma
161		* @throws InvalidStateException If Accept header is unknown
162		* @return string
163		*/
164		protected function getPreferredContentType(string $contentType): string
165		{
166	1	$accept = explode(',', $contentType);
167	1	$acceptableTypes = array_keys($this->responses);
168	1	if (!$contentType) {
169		return $acceptableTypes[0];
170		}
171	1	foreach ($accept as $mimeType) {
172	1	if ('/' === $mimeType) return $acceptableTypes[0];
173	1	foreach ($acceptableTypes as $formatMime) {
174	1	if (empty($formatMime)) {
175	1	continue;
176		}
177	1	if (str_contains($mimeType, $formatMime)) {
178	1	return $formatMime;
179		}
180		}
181		}
182	1	throw new InvalidStateException('Unknown Accept header: ' . $contentType);
183		}
184
185		/**
186		* Is pretty print enabled
187		* @return boolean
188		*/
189		protected function isPrettyPrint(): bool
190		{
191	1	$prettyPrintKey = $this->request->getQuery($this->prettyPrintKey);
192	1	if ('false' === $prettyPrintKey) {
193		return false;
194		}
195	1	if ('true' === $prettyPrintKey) {
196		return true;
197		}
198	1	return $this->prettyPrint;
199		}
200
201		/**
202		* Set pretty print
203		*/
204		public function setPrettyPrint(bool $prettyPrint): self
205		{
206		$this->prettyPrint = $prettyPrint;
207		return $this;
208		}
209
210		/**
211		* Is given content type acceptable for response
212		*/
213		public function isAcceptable(string $contentType): bool
214		{
215		try {
216	1	$this->getPreferredContentType($contentType);
217	1	return true;
218	1	} catch (InvalidStateException) {
219	1	return false;
220		}
221		}
222		}
223

alex-kalanis / restful

ResponseFactory::setHttpResponse() A last analyzed 2024-12-26 06:23 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

ResponseFactory::setHttpResponse() A
last analyzed 2024-12-26 06:23 UTC