neilherbertuk\celcatwebapi\CelcatWebAPI

Complexity

Total Complexity

22

Size/Duplication

Total Lines	158
Duplicated Lines	0 %

Importance

Changes	6
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	throwRunTimeException()	0	3	1
A	buildRequest()	0	2	1
A	log()	0	2	1
B	query()	0	50	9
A	__construct()	0	3	1
A	buildClient()	0	11	3
A	setConfiguration()	0	11	5
A	get()	0	3	1

<?php

namespace neilherbertuk\celcatwebapi;

use GuzzleHttp\Client;
use GuzzleHttp\Exception\ClientException;
use Illuminate\Config\Repository as Config;

use neilherbertuk\celcatwebapi\Classes\RequestBuilder;
use neilherbertuk\celcatwebapi\Classes\Log;
use neilherbertuk\celcatwebapi\Traits\ResourcesTrait;

class CelcatWebAPI
{
    use ResourcesTrait;

    /**
     * @var
     */
    private $config;

    /**
     * @var
     */
    public $logs;

    /**
     * CelcatWebAPI constructor.
     * @param $config
     */
    public function __construct(Config $config)
    {
        $this->setConfiguration($config);
    }

    /**
     * @param Config $config
     */
    private function setConfiguration(Config $config)
    {
        if ($config->has('celcat')) {
            $this->config['ServerAddress'] = $config->get('celcat.ServerAddress');
            $this->config['APICode'] = $config->get('celcat.APICode') ?: $this->throwRunTimeException('No API Code Provided');
            $this->config['VerifySSL'] = $config->get('celcat.VerifySSL');
            $this->config['PEM'] = $config->get('celcat.PEM');
            $this->config['DEBUG'] = $config->get('celcat.DEBUG') ?: false;
            $this->config['PROXY'] = $config->get('celcat.PROXY') ?: null;
        } else {
            $this->throwRunTimeException('No config found');
        }
    }

    /**
     * @param $exceptionMessage
     */
    private function throwRunTimeException($exceptionMessage)
    {
        throw new \RuntimeException($exceptionMessage);
    }

    /**
     * Perform an API Query from the Celcat Web API
     *
     * @param $name
     * @param string $requestMethod
     * @param array $parameters
     * @return mixed
     * @throws \GuzzleHttp\Exception\GuzzleException
     */
    private function query($name, $requestMethod = 'GET', $parameters = [])
    {
        $this->log()->info("Starting to perform query - resource: {$name} method: {$requestMethod}".(empty($parameters ?: " parameters: ".implode($parameters))));

        $client = $this->buildClient();
        $options = $this->buildRequest($requestMethod)->options($parameters);
        $url = $this->buildRequest()->URL($name);

        try {
            $request = $client->request($requestMethod, $url, $options);
            $header = $request->getHeaders();
            if ($request->getStatusCode() >= 200 and $request->getStatusCode() <= 299) {

                $this->log()->info('Received '.$request->getStatusCode());

                // Build object to return
                $result = [];

                // Include pagination details
                if ($header['Pagination'] !== null) {
                    $result['pagination'] = json_decode($header['Pagination'][0], true);
                }

                if (!empty($parameters)) {
                    $result['parameters'] = $parameters;
                }
                $result['data'] = json_decode($request->getBody()->getContents(), true);

                return $result;
            } else {
                // TODO - Error Handling
                $this->log()->error('An error occurred, received a '.$request->getStatusCode());
                $this->log()->transferLogs();
                $this->throwRunTimeException('An error occurred, received a '.$request->getStatusCode());
                return null;
            }
        } catch (\Exception $exception) {
            if ($exception instanceof ClientException) {
                if ($exception->getCode() == 404) {
                    $this->log()->info('Received '.$exception->getCode());
                    $result['error']['code'] = 404;
                    $result['error']['message'] = "No Results Found";
                    return $result;
                }
            }
            // TODO - Error Handling
            $this->log()->error('An error occurred, received a '.$exception->getCode().' '.$exception->getMessage());
            $this->log()->transferLogs();
            $this->throwRunTimeException('An error occurred, received a '.$exception->getCode());
            return null;
        }
    }

    /**
     * Build HTTP Client and add proxy config if required
     *
     * @return Client
     */
    private function buildClient()
    {
        if ($this->config['PROXY']) {
            $client = new Client(['proxy' => $this->config['PROXY']]);
            if (!empty($this->config['PROXY']['no'])) {
                putenv('no_proxy=' .implode(' ,', $this->config['PROXY']['no']));
            }

            return $client;
        }
        return new Client();
    }

    /**
     * Returns RequestBuilder instance - used to build an api request
     *
     * @param string $requestMethod
     * @return RequestBuilder
     */
    private function buildRequest($requestMethod = 'GET') {
        return new RequestBuilder($requestMethod, $this->config);
    }

    /**
     * Performs a get request to the Celcat Web API
     *
     * @param $name
     * @param array $parameters
     * @return mixed
     * @throws \GuzzleHttp\Exception\GuzzleException
     */
    public function get($name, $parameters = [])
    {
        return $this->query($name, 'GET', $parameters);
    }

    /**
     * Returns a log instance
     *
     * @return Log
     */
    public function log() {
        return new Log($this);
    }

}