Shippinno\YahooShoppingJp\Client

Complexity

Total Complexity

15

Size/Duplication

Total Lines	179
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	11

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	15	2
A	execute()	0	21	4
A	setApi()	0	4	1
A	setAuthorizationHeader()	0	8	1
A	setRequestParams()	0	13	3
A	setRequestParamsForGetRequest()	0	6	1
A	setRequestParamsForPostRequest()	0	8	1
A	request()	0	8	1
A	decodeResponse()	0	13	1

<?php

namespace Shippinno\YahooShoppingJp;

use FluidXml\FluidXml;
use GuzzleHttp\Client as HttpClient;
use GuzzleHttp\Exception\ConnectException as GuzzleConnectException;
use GuzzleHttp\Exception\ServerException as GuzzleServerException;
use GuzzleHttp\Exception\ClientException as GuzzleClientException;
use Psr\Http\Message\ResponseInterface;
use Shippinno\YahooShoppingJp\Api\AbstractApi;
use Shippinno\YahooShoppingJp\Exception\ClientException;
use Shippinno\YahooShoppingJp\Exception\ConnectException;
use Shippinno\YahooShoppingJp\Exception\ServerException;
use Shippinno\YahooShoppingJp\Request\AbstractRequest;

class Client
{
//    /**
//     * @var string
//     */
//    const BASE_URL = 'https://circus.shopping.yahooapis.jp/ShoppingWebService/V1/';

    /**
     * @var string
     */
    const BASE_URL = 'https://test.circus.shopping.yahooapis.jp/ShoppingWebService/V1/';

    /**
     * @var HttpClient
     */
    private $httpClient;

    /**
     * @var AbstractApi
     */
    private $api;

    /**
     * @var string
     */
    private $accessToken;

    /**
     * @var string
     */
    private $refreshToken;

    /**
     * @param string $accessToken
     * @param string $refreshToken
     * @param HttpClient|null $httpClient
     */
    public function __construct(
        string $accessToken,
        string $refreshToken,
        HttpClient $httpClient = null
    ) {
        if (null === $httpClient) {
            $httpClient = new HttpClient([
                'base_uri' => self::BASE_URL,
            ]);
        }

        $this->accessToken = $accessToken;
        $this->refreshToken = $refreshToken;
        $this->httpClient = $httpClient;
    }

    /**
     * @param AbstractRequest $request
     * @return mixed
     * @throws ClientException
     * @throws ConnectException
     * @throws ServerException
     */
    public function execute(AbstractRequest $request): array
    {
        $this->setApi($request->api());

        $options = $this->setAuthorizationHeader($this->setRequestParams($request));

        try {
            $rawResponse = $this->request($options);
        } catch (GuzzleClientException $e) {
            throw new ClientException($e->getMessage(), $e->getCode(), $e);
        } catch (GuzzleServerException $e) {
            throw new ServerException($e->getMessage(), $e->getCode(), $e);
        } catch (GuzzleConnectException $e) {
            throw new ConnectException($e->getMessage(), $e->getCode(), $e);
        }

        $distilledResponse = $this->api->distillResponse($this->decodeResponse($rawResponse));
        $response = $request->response()->setData($distilledResponse);

        return $response;
    }

    /**
     * @param AbstractApi $api
     */
    private function setApi(AbstractApi $api)
    {
        $this->api = $api;
    }

    /**
     * @param array $options
     * @return array
     */
    private function setAuthorizationHeader(array $options): array
    {
        $options['headers'] = [
            'Authorization' => 'Bearer ' . $this->accessToken,
        ];

        return $options;
    }

    /**
     * @param AbstractRequest $request
     * @return array
     */
    private function setRequestParams(AbstractRequest $request): array
    {
        $options = [];
        if ($this->api->httpMethod()->equals(HttpMethod::GET())) {
            $options = $this->setRequestParamsForGetRequest($options, $request);
        } else {
            if ($this->api->httpMethod()->equals(HttpMethod::POST())) {
                $options = $this->setRequestParamsForPostRequest($options, $request);
            }
        }

        return $options;
    }

    /**
     * @param array $options
     * @param AbstractRequest $request
     * @return array
     */
    private function setRequestParamsForGetRequest(array $options, AbstractRequest $request): array
    {
        $options['query'] = $request->getParams();

        return $options;
    }

    /**
     * @param array $options
     * @param AbstractRequest $request
     * @return array
     */
    private function setRequestParamsForPostRequest(array $options, AbstractRequest $request): array
    {
        $fluidXml = new FluidXml('Req');
        $fluidXml->add($request->getParams());
        $options['form'] = $fluidXml->xml();

        return $options;
    }


    /**
     * @param $options
     * @return mixed|ResponseInterface
     */
    private function request($options)
    {
        return $this->httpClient->request(
            $this->api->httpMethod()->getValue(),
            $this->api->path(),
            $options
        );
    }

    /**
     * @param ResponseInterface $rawResponse
     * @return array
     */
    private function decodeResponse(ResponseInterface $rawResponse): array
    {
        return json_decode(
            json_encode(
                simplexml_load_string(
                    $rawResponse->getBody()->getContents(),
                    null,
                    LIBXML_NOCDATA
                )
            ),
            true
        );
    }
}