Minepic\Minecraft\MojangClient

Complexity

Total Complexity

17

Size/Duplication

Total Lines	159
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	sendRequest()	0	12	3
A	sendApiRequest()	0	23	4
A	sendUsernameInfoRequest()	0	9	2
A	handleThrowable()	0	4	1
A	getCacheKey()	0	3	1
A	getUuidInfo()	0	9	2
A	getSkin()	0	9	2
A	__construct()	0	6	1
A	handleGuzzleBadResponseException()	0	9	1

<?php

declare(strict_types=1);

namespace Minepic\Minecraft;

use GuzzleHttp\Client as HttpClient;
use GuzzleHttp\Exception\BadResponseException;
use Illuminate\Support\Facades\Log;
use Minepic\Minecraft\Exceptions\UserNotFoundException;
use Psr\Http\Message\ResponseInterface;

class MojangClient
{
    /**
     * API response TTL.
     */
    private const CACHE_TTL = 120;
    /**
     * User Agent used for requests.
     */
    private const USER_AGENT = 'Minepic/2.0 (minepic.org)';

    /**
     * HTTP Client for requests.
     */
    private HttpClient $httpClient;

    /**
     * MojangClient constructor.
     */
    public function __construct()
    {
        $this->httpClient = new HttpClient(
            [
                'headers' => [
                    'User-Agent' => self::USER_AGENT,
                ],
            ]
        );
    }

    /**
     * Account info from username.
     *
     * @throws \Throwable
     */
    public function sendUsernameInfoRequest(string $username): MojangAccount
    {
        $response = $this->sendApiRequest('GET', env('MINECRAFT_PROFILE_URL').$username);

        if ($response !== null) {
            return new MojangAccount($response['id'], $response['name']);
        }

        throw new UserNotFoundException("Unknown user {$username}");
    }

    /**
     * Account info from UUID.
     *
     * @param string $uuid User UUID
     *
     * @throws \Throwable
     */
    public function getUuidInfo(string $uuid): MojangAccount
    {
        $response = $this->sendApiRequest('GET', env('MINECRAFT_SESSION_URL').$uuid);

        if ($response === null) {
            throw new \Exception('Cannot create data account');
        }

        return MojangAccountFactory::makeFromApiResponse($response);
    }

    /**
     * Get Skin.
     *
     * @param string $skin Skin uuid
     *
     * @throws \Exception|\Throwable
     */
    public function getSkin(string $skin): string
    {
        $response = $this->sendRequest('GET', env('MINECRAFT_TEXTURE_URL').$skin);

        if ($response->getHeader('content-type')[0] === 'image/png') {
            return $response->getBody()->getContents();
        }

        throw new \Exception('Invalid Response content type: '.$response->getHeader('content-type')[0]);
    }

    private function handleGuzzleBadResponseException(
        BadResponseException $badResponseException
    ): void {
        Log::error(
            'Error from Minecraft API',
            [
                'status_code' => $badResponseException->getResponse()->getStatusCode(),
                'content_type' => $badResponseException->getResponse()->getHeader('content-type')[0] ?? '',
                'content' => $badResponseException->getResponse()->getBody()->getContents(),
            ]
        );
    }

    private function handleThrowable(\Throwable $exception): void
    {
        Log::error($exception->getFile().':'.$exception->getLine().' - '.$exception->getMessage());
        Log::error($exception->getTraceAsString());
    }

    private function getCacheKey(string $method, string $url): string
    {
        return 'minecraft_api_response_'.md5($method.'_'.$url);
    }

    /**
     * Send new request.
     *
     * @param string $method HTTP Verb
     * @param string $url    API Endpoint
     *
     * @throws \Throwable
     *
     * @return array
     */
    private function sendApiRequest(string $method, string $url): ?array
    {
        try {
            return \Cache::remember($this->getCacheKey($method, $url), self::CACHE_TTL, function () use ($method, $url) {
                $response = $this->httpClient->request($method, $url);
                // No Content
                if ($response->getStatusCode() === 204) {
                    return null;
                }

                $responseContents = $response->getBody()->getContents();
                Log::debug('Minecraft API Response: '.$responseContents, ['method' => $method, 'url' => $url]);

                return json_decode($responseContents, associative: true, flags: \JSON_THROW_ON_ERROR);
            });
        } catch (BadResponseException $exception) {
            $this->handleGuzzleBadResponseException($exception);

            throw $exception;
        } catch (\Throwable $exception) {
            $this->handleThrowable($exception);

            throw $exception;
        }
    }

    /**
     * Generic request.
     *
     * @throws \Throwable
     */
    private function sendRequest(string $method, string $url): ResponseInterface
    {
        try {
            return $this->httpClient->request($method, $url);
        } catch (BadResponseException $exception) {
            $this->handleGuzzleBadResponseException($exception);

            throw $exception;
        } catch (\Throwable $exception) {
            $this->handleThrowable($exception);

            throw $exception;
        }
    }
}