AbstractApi::httpGet() - Code Metrics - Inspection of "- refactored http client" - CloudPlayDev/confluence-php-client - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( a33de3...4370d9 )

by Artem

created 2021-06-24 21:06 UTC

AbstractApi::httpGet() A

↳ Parent: AbstractApi

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	3
dl	0
loc	3
rs	10
c	0
b	0
f	0

<?php
declare(strict_types=1);

namespace CloudPlayDev\ConfluenceClient\Api;


use CloudPlayDev\ConfluenceClient\ConfluenceClient;
use CloudPlayDev\ConfluenceClient\Entity\Hydratable;
use CloudPlayDev\ConfluenceClient\Exception\ConfluencePhpClientException;
use CloudPlayDev\ConfluenceClient\Exception\HttpClientException;
use CloudPlayDev\ConfluenceClient\Exception\HttpServerException;
use CloudPlayDev\ConfluenceClient\Exception\HydrationException;
use Http\Client\Exception;
use JsonException;
use Psr\Http\Message\ResponseInterface;
use Webmozart\Assert\Assert;
use function array_filter;
use function array_merge;
use function get_class;
use function in_array;
use function json_encode;
use function sprintf;

abstract class AbstractApi
{
    /**
     * default rest API prefix for confluence
     */
    private const URI_PREFIX = '/rest/api/';

    private ConfluenceClient $client;

    public function __construct(ConfluenceClient $client)
    {
        $this->client = $client;
    }

    /**
     * @param string $uri
     * @param mixed[] $params
     * @param array<string, string> $headers
     * @return ResponseInterface
     * @throws Exception
     */
    protected function httpGet(string $uri, array $params = [], array $headers = []): ResponseInterface
    {
        return $this->client->getHttpClient()->get(self::prepareUri($uri, $params), $headers);
    }

    /**
     * @param string $uri
     * @param mixed[] $params
     * @param array<string, string> $headers
     * @return ResponseInterface
     * @throws Exception
     * @throws JsonException
     */
    protected function httpPut(string $uri, array $params = [], array $headers = []): ResponseInterface
    {
        $body = self::prepareJsonBody($params);

        if ($body !== '') {
            $headers = self::addJsonContentType($headers);
        }

        return $this->client->getHttpClient()->put(self::prepareUri($uri), $headers, $body);
    }

    /**
     * @param string $uri
     * @param mixed[] $queryParams
     * @param mixed[] $bodyData
     * @param array<string, string> $headers
     * @return ResponseInterface
     * @throws Exception
     * @throws JsonException
     */
    protected function httpPost(string $uri, array $queryParams = [], array $bodyData = [], array $headers = []): ResponseInterface
    {
        $body = self::prepareJsonBody($bodyData);

        if ($body !== '') {
            $headers = self::addJsonContentType($headers);
        }

        return $this->client->getHttpClient()->post(self::prepareUri($uri, $queryParams), $headers, $body);
    }

    /**
     * @param string $uri
     * @param mixed[] $params
     * @param array<string, string> $headers
     * @return ResponseInterface
     * @throws Exception
     * @throws JsonException
     */
    protected function httpDelete(string $uri, array $params = [], array $headers = []): ResponseInterface
    {
        $body = self::prepareJsonBody($params);

        if ($body !== '') {
            $headers = self::addJsonContentType($headers);
        }

        return $this->client->getHttpClient()->delete(self::prepareUri($uri), $headers, $body);
    }

    /**
     * @param array<string, string> $headers
     * @return array<string, string>
     */
    private static function addJsonContentType(array $headers): array
    {
        return array_merge(['Content-Type' => 'application/json'], $headers);
    }

    /**
     * @param mixed[] $params
     * @return string
     * @throws JsonException
     */
    private static function prepareJsonBody(array $params): string
    {
        return json_encode($params, JSON_THROW_ON_ERROR);
    }

    /**
     * @param string $uri
     * @param mixed[] $query
     * @return string
     */
    private static function prepareUri(string $uri, array $query = []): string
    {
        $query = array_filter($query, static function($value): bool {
            return null !== $value;
        });

        $httpQueryParameter = http_build_query($query);
        if ($httpQueryParameter !== '') {
            $uri .= '?';
        }
        return sprintf('%s%s%s', self::URI_PREFIX, $uri, $httpQueryParameter);
    }

    /**
     * @psalm-template ExpectedType of Hydratable
     * @psalm-param class-string<ExpectedType> $class
     * @psalm-return ExpectedType
     *
     * @psalm-suppress InvalidReturnType https://psalm.dev/r/46c8264450
     * @psalm-suppress InvalidReturnStatement https://psalm.dev/r/46c8264450
     *
     * @param ResponseInterface $response
     * @param class-string $class

     * @return Hydratable
     * @throws ConfluencePhpClientException
     * @throws HttpClientException
     * @throws HttpServerException
     * @throws HydrationException
     * @throws JsonException
     */
    protected function hydrateResponse(ResponseInterface $response, string $class): Hydratable
    {
        $this->handleErrors($response);

        $contentType = $response->getHeaderLine('Content-Type');

        if (!str_starts_with($contentType, 'application/json')) {
            throw new HydrationException('The ModelHydrator cannot hydrate response with Content-Type: ' . $contentType);
        }
        if (!is_subclass_of($class, Hydratable::class)) {
            throw new HydrationException('This class can not be hydrated: ' . $class);
        }

        $data = json_decode($response->getBody()->getContents(), true, 512, JSON_THROW_ON_ERROR);
        Assert::isArray($data);

        $entity = $class::load($data);
        if (!$entity instanceof $class) {
            throw new HydrationException('An unexpected class was created: ' . get_class($entity));
        }
        return $entity;
    }

    /**
     * Throw the correct exception for this error.
     */
    protected function handleErrors(ResponseInterface $response): void
    {
        $statusCode = $response->getStatusCode();

        if (in_array($response->getStatusCode(), [200, 201, 202, 204], true)) {
            return;
        }

        switch ($statusCode) {
            case 400:
                throw HttpClientException::badRequest($response);
            case 401:
                throw HttpClientException::unauthorized($response);
            case 402:
                throw HttpClientException::requestFailed($response);
            case 403:
                throw HttpClientException::forbidden($response);
            case 404:
                throw HttpClientException::notFound($response);
            case 409:
                throw HttpClientException::conflict($response);
            case 413:
                throw HttpClientException::payloadTooLarge($response);
            case 429:
                throw HttpClientException::tooManyRequests($response);
            case 500 <= $statusCode:
                throw HttpServerException::serverError($response);
            default:
                throw new ConfluencePhpClientException($response->getBody()->getContents(), $response->getStatusCode());
        }
    }

    /**
     * @param string|int|null ...$parameter
     * @return string
     */
    protected static function getRestfulUri(...$parameter): string
    {
        $parameterString = implode('/', array_filter($parameter));

        if (!empty($parameterString)) {
            return '/' . $parameterString;
        }

        return '';
    }
}


1			<?php
2			declare(strict_types=1);
3
4			namespace CloudPlayDev\ConfluenceClient\Api;
5
6
7			use CloudPlayDev\ConfluenceClient\ConfluenceClient;
8			use CloudPlayDev\ConfluenceClient\Entity\Hydratable;
9			use CloudPlayDev\ConfluenceClient\Exception\ConfluencePhpClientException;
10			use CloudPlayDev\ConfluenceClient\Exception\HttpClientException;
11			use CloudPlayDev\ConfluenceClient\Exception\HttpServerException;
12			use CloudPlayDev\ConfluenceClient\Exception\HydrationException;
13			use Http\Client\Exception;
14			use JsonException;
15			use Psr\Http\Message\ResponseInterface;
16			use Webmozart\Assert\Assert;
17			use function array_filter;
18			use function array_merge;
19			use function get_class;
20			use function in_array;
21			use function json_encode;
22			use function sprintf;
23
24			abstract class AbstractApi
25			{
26			/**
27			* default rest API prefix for confluence
28			*/
29			private const URI_PREFIX = '/rest/api/';
30
31			private ConfluenceClient $client;
32
33			public function __construct(ConfluenceClient $client)
34			{
35			$this->client = $client;
36			}
37
38			/**
39			* @param string $uri
40			* @param mixed[] $params
41			* @param array<string, string> $headers
42			* @return ResponseInterface
43			* @throws Exception
44			*/
45			protected function httpGet(string $uri, array $params = [], array $headers = []): ResponseInterface
46			{
47			return $this->client->getHttpClient()->get(self::prepareUri($uri, $params), $headers);
48			}
49
50			/**
51			* @param string $uri
52			* @param mixed[] $params
53			* @param array<string, string> $headers
54			* @return ResponseInterface
55			* @throws Exception
56			* @throws JsonException
57			*/
58			protected function httpPut(string $uri, array $params = [], array $headers = []): ResponseInterface
59			{
60			$body = self::prepareJsonBody($params);
61
62			if ($body !== '') {
63			$headers = self::addJsonContentType($headers);
64			}
65
66			return $this->client->getHttpClient()->put(self::prepareUri($uri), $headers, $body);
67			}
68
69			/**
70			* @param string $uri
71			* @param mixed[] $queryParams
72			* @param mixed[] $bodyData
73			* @param array<string, string> $headers
74			* @return ResponseInterface
75			* @throws Exception
76			* @throws JsonException
77			*/
78			protected function httpPost(string $uri, array $queryParams = [], array $bodyData = [], array $headers = []): ResponseInterface
79			{
80			$body = self::prepareJsonBody($bodyData);
81
82			if ($body !== '') {
83			$headers = self::addJsonContentType($headers);
84			}
85
86			return $this->client->getHttpClient()->post(self::prepareUri($uri, $queryParams), $headers, $body);
87			}
88
89			/**
90			* @param string $uri
91			* @param mixed[] $params
92			* @param array<string, string> $headers
93			* @return ResponseInterface
94			* @throws Exception
95			* @throws JsonException
96			*/
97			protected function httpDelete(string $uri, array $params = [], array $headers = []): ResponseInterface
98			{
99			$body = self::prepareJsonBody($params);
100
101			if ($body !== '') {
102			$headers = self::addJsonContentType($headers);
103			}
104
105			return $this->client->getHttpClient()->delete(self::prepareUri($uri), $headers, $body);
106			}
107
108			/**
109			* @param array<string, string> $headers
110			* @return array<string, string>
111			*/
112			private static function addJsonContentType(array $headers): array
113			{
114			return array_merge(['Content-Type' => 'application/json'], $headers);
115			}
116
117			/**
118			* @param mixed[] $params
119			* @return string
120			* @throws JsonException
121			*/
122			private static function prepareJsonBody(array $params): string
123			{
124			return json_encode($params, JSON_THROW_ON_ERROR);
125			}
126
127			/**
128			* @param string $uri
129			* @param mixed[] $query
130			* @return string
131			*/
132			private static function prepareUri(string $uri, array $query = []): string
133			{
134			$query = array_filter($query, static function($value): bool {
135			return null !== $value;
136			});
137
138			$httpQueryParameter = http_build_query($query);
139			if ($httpQueryParameter !== '') {
140			$uri .= '?';
141			}
142			return sprintf('%s%s%s', self::URI_PREFIX, $uri, $httpQueryParameter);
143			}
144
145			/**
146			* @psalm-template ExpectedType of Hydratable
147			* @psalm-param class-string<ExpectedType> $class
148			* @psalm-return ExpectedType
149			*
150			* @psalm-suppress InvalidReturnType https://psalm.dev/r/46c8264450
151			* @psalm-suppress InvalidReturnStatement https://psalm.dev/r/46c8264450
152			*
153			* @param ResponseInterface $response
154			* @param class-string $class
			0 ignored issues – show Documentation Bug introduced 2021-06-24 21:09 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...
155			* @return Hydratable
156			* @throws ConfluencePhpClientException
157			* @throws HttpClientException
158			* @throws HttpServerException
159			* @throws HydrationException
160			* @throws JsonException
161			*/
162			protected function hydrateResponse(ResponseInterface $response, string $class): Hydratable
163			{
164			$this->handleErrors($response);
165
166			$contentType = $response->getHeaderLine('Content-Type');
167
168			if (!str_starts_with($contentType, 'application/json')) {
169			throw new HydrationException('The ModelHydrator cannot hydrate response with Content-Type: ' . $contentType);
170			}
171			if (!is_subclass_of($class, Hydratable::class)) {
172			throw new HydrationException('This class can not be hydrated: ' . $class);
173			}
174
175			$data = json_decode($response->getBody()->getContents(), true, 512, JSON_THROW_ON_ERROR);
176			Assert::isArray($data);
177
178			$entity = $class::load($data);
179			if (!$entity instanceof $class) {
180			throw new HydrationException('An unexpected class was created: ' . get_class($entity));
181			}
182			return $entity;
183			}
184
185			/**
186			* Throw the correct exception for this error.
187			*/
188			protected function handleErrors(ResponseInterface $response): void
189			{
190			$statusCode = $response->getStatusCode();
191
192			if (in_array($response->getStatusCode(), [200, 201, 202, 204], true)) {
193			return;
194			}
195
196			switch ($statusCode) {
197			case 400:
198			throw HttpClientException::badRequest($response);
199			case 401:
200			throw HttpClientException::unauthorized($response);
201			case 402:
202			throw HttpClientException::requestFailed($response);
203			case 403:
204			throw HttpClientException::forbidden($response);
205			case 404:
206			throw HttpClientException::notFound($response);
207			case 409:
208			throw HttpClientException::conflict($response);
209			case 413:
210			throw HttpClientException::payloadTooLarge($response);
211			case 429:
212			throw HttpClientException::tooManyRequests($response);
213			case 500 <= $statusCode:
214			throw HttpServerException::serverError($response);
215			default:
216			throw new ConfluencePhpClientException($response->getBody()->getContents(), $response->getStatusCode());
217			}
218			}
219
220			/**
221			* @param string\|int\|null ...$parameter
222			* @return string
223			*/
224			protected static function getRestfulUri(...$parameter): string
225			{
226			$parameterString = implode('/', array_filter($parameter));
227
228			if (!empty($parameterString)) {
229			return '/' . $parameterString;
230			}
231
232			return '';
233			}
234			}
235

CloudPlayDev / confluence-php-client

Push — main ( a33de3...4370d9 )

AbstractApi::httpGet() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like