light\Easemob\Core\Http

Complexity

Total Complexity

23

Size/Duplication

Total Lines	242
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

70.67%

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	setClient()	0	6	1
A	getClient()	0	15	2
A	buildUri()	0	4	1
A	request()	0	20	2
A	get()	0	4	1
A	post()	0	6	2
A	delete()	0	4	1
A	put()	0	4	1
A	upload()	0	17	3
A	parseJSON()	0	17	4
A	addMiddleware()	0	6	1
A	clearMiddlewares()	0	6	1
A	getHandler()	0	10	2

<?php

/*
 * This file is part of the light/easemob.
 *
 * (c) lichunqiang <light-li@hotmail.com>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace light\Easemob\Core;

use GuzzleHttp\Client as HttpClient;
use GuzzleHttp\Exception\RequestException;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Psr7;
use GuzzleHttp\Psr7\Request;
use light\Easemob\Exception\HttpException;
use light\Easemob\Support\Log;
use Psr\Http\Message\ResponseInterface;

class Http
{
    /**
     * @var string The base request url.
     */
    protected $baseUri;
    /**
     * @var \GuzzleHttp\Client
     */
    protected $client;
    /**
     * @var array The middlewares.
     */
    protected $middlewares = [];

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

    /**
     * Set http client.
     *
     * @param HttpClient $client
     *
     * @return $this
     */
    public function setClient(HttpClient $client)
    {
        $this->client = $client;

        return $this;
    }

    /**
     * Get http client.
     *
     * @return \GuzzleHttp\Client
     */
    public function getClient()
    {
        if (!($this->client instanceof HttpClient)) {
            $this->client = new HttpClient([
                'base_uri' => $this->baseUri,
                'verify' => false,
                'headers' => [
                    'Content-Type' => 'application/json',
                    'Accept' => 'application/json',
                ],
            ]);
        }

        return $this->client;
    }

    /**
     * @param string $path
     *
     * @return \Psr\Http\Message\UriInterface
     */
    public function buildUri($path)
    {
        return Psr7\Uri::resolve(Psr7\uri_for($this->baseUri), $path);
    }

    /**
     * Make request.
     *
     * @param string $url
     * @param string $method
     * @param array  $options
     *
     * @return mixed
     */
    public function request($url, $method = 'GET', $options = [])
    {
        $method = strtoupper($method);

        $options['handler'] = $this->getHandler();

        try {
            $response = $this->getClient()->request($method, $url, $options);
        } catch (RequestException $e) {
            $response = $e->getResponse();
            Log::error('Http Exception', [
                'uri' => $url,
                'method' => $method,
                'response' => (string) $response->getBody(),
                'request' => (string) $e->getRequest()->getUri(),
            ]);
        }

        return $response;
    }

    /**
     * Send a get request.
     *
     * @param string $url
     * @param array  $options
     *
     * @return mixed
     */
    public function get($url, array $options = [])
    {
        return $this->request($url, 'GET', ['query' => $options]);
    }

    /**
     * Send a post request.
     *
     * @param string $url
     * @param array  $options
     *
     * @return mixed
     */
    public function post($url, $options = [])
    {
        $options = is_array($options) ? json_encode($options, JSON_UNESCAPED_UNICODE) : $options;

        return $this->request($url, 'POST', ['body' => $options]);
    }

    /**
     * Send a delete request.
     *
     * @param string $url
     * @param array  $options
     *
     * @return mixed
     */
    public function delete($url, $options = [])
    {
        return $this->request($url, 'DELETE', $options);
    }

    /**
     * Send a put request.
     *
     * @param string $url
     * @param array  $options
     *
     * @return mixed
     */
    public function put($url, $options = [])
    {
        return $this->request($url, 'PUT', $options);
    }

    /**
     * Upload file.
     *
     * @param string $url
     * @param array  $files
     * @param array  $form
     * @param array  $queries
     *
     * @return ResponseInterface
     */
    public function upload($url, array $files = [], array $form = [], array $queries = [])
    {
        $multipart = [];

        foreach ($files as $name => $path) {
            $multipart[] = [
                'name' => $name,
                'contents' => fopen($path, 'r'),
            ];
        }

        foreach ($form as $name => $contents) {
            $multipart[] = compact('name', 'contents');
        }

        return $this->request($url, 'POST', ['query' => $queries, 'multipart' => $multipart]);
    }

    /**
     * Parse json data.
     *
     * @param string|ResponseInterface $body
     * @param bool                     $throws
     *
     * @throws HttpException
     *
     * @return array
     */
    public function parseJSON($body, $throws = true)
    {
        if ($body instanceof ResponseInterface) {
            $body = $body->getBody();
        }

        $contents = json_decode($body, true);

        if (JSON_ERROR_NONE !== json_last_error()) {
            Log::error('Failed to parse JSON.', ['body' => $body]);
            if ($throws) {
                throw new HttpException('Failed to parse JSON.', json_last_error());
            }
        }

        return $contents;
    }

    /**
     * Add a middleware.
     *
     * @param callable $middleware
     *
     * @return $this
     */
    public function addMiddleware(callable $middleware)
    {
        array_push($this->middlewares, $middleware);

        return $this;
    }

    public function clearMiddlewares()
    {
        $this->middlewares = [];

        return $this;
    }

    /**
     * Build a handler.
     *
     * @return HandlerStack
     */
    protected function getHandler()
    {
        $stack = HandlerStack::create();

        foreach ($this->middlewares as $middleware) {
            $stack->push($middleware);
        }

        return $stack;
    }
}