EventClient::performeResponse() - Code Metrics - Inspection of "- Initial commit" - tonicforhealth/pagerduty-client - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 570173...f1a8d5 )

by Dmitry

created 2016-07-27 15:09 UTC

EventClient::performeResponse() A

↳ Parent: EventClient

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	2.0185

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	10
ccs	5
cts	6
cp	0.8333
rs	9.4285
cc	2
eloc	6
nc	2
nop	1
crap	2.0185

<?php

namespace TonicForHealth\PagerDutyClient\Client;

use Http\Client\Exception as HttpClientException;
use Http\Client\Common\HttpMethodsClient;
use Http\Discovery\HttpClientDiscovery;
use Http\Discovery\MessageFactoryDiscovery;
use Psr\Http\Message\ResponseInterface;
use TonicForHealth\PagerDutyClient\Client\Exception\EventApiResponseCorruptException;
use TonicForHealth\PagerDutyClient\Client\Exception\EventApiResponseErrorException;
use TonicForHealth\PagerDutyClient\Client\Exception\EventClientException;
use TonicForHealth\PagerDutyClient\Entity\Event\EventRepresentation;
use TonicForHealth\PagerDutyClient\Entity\PagerDutyEntityInterface;
use TonicForHealth\PagerDutyClient\RepresentProcessor\RepresentProcessor;
use TonicForHealth\PagerDutyClient\RepresentProcessor\RepresentProcessorInterface;

/**
 * Class EventClient.
 */
class EventClient
{
    protected $headers = ['Content-type' => 'application/json'];
    /**
     * @var HttpMethodsClient
     */
    protected $httpClient;

    /**
     * @var string
     */
    protected $apiRootUrl;

    /**
     * @var RepresentProcessorInterface
     */
    protected $representProcessor;

    /**
     * RequestNotificationType constructor.
     *
     * @param string                      $apiRootUrl
     * @param HttpMethodsClient           $httpClient
     * @param RepresentProcessorInterface $representProcessor
     */
    public function __construct(
        $apiRootUrl,
        HttpMethodsClient $httpClient = null,
        RepresentProcessorInterface $representProcessor = null
    ) {
        $this->setApiRootUrl($apiRootUrl);

        if (null === $httpClient) {
            $httpClient = $this->createHttpClient();
        }
        $this->setHttpClient($httpClient);

        if (null === $representProcessor) {
            $representProcessor = $this->createRepresentProcessor();
        }
        $this->setRepresentProcessor($representProcessor);

        $this->addBasicRepresentation();
    }

    /**
     * @param PagerDutyEntityInterface $pagerDutyEntity
     *
     * @return ResponseInterface
     *
     * @throws EventApiResponseErrorException
     */
    public function post(PagerDutyEntityInterface $pagerDutyEntity)
    {
        $data = null;

        try {
            $response = $this->getHttpClient()->post(
                $this->getResourceUrl($pagerDutyEntity),
                $this->headers,
                $this->getRepresentProcessor()->representJSON($pagerDutyEntity)
            );

            $data = $this->performResponse($response);
        } catch (HttpClientException $exception) {
            EventClientException::internalProblem($exception);
        }

        return $data;
    }

    /**
     * @return HttpMethodsClient
     */
    public function getHttpClient()
    {
        return $this->httpClient;
    }

    /**
     * @return string
     */
    public function getApiRootUrl()
    {
        return $this->apiRootUrl;
    }

    /**
     * @return RepresentProcessorInterface
     */
    public function getRepresentProcessor()
    {
        return $this->representProcessor;
    }

    /**
     * @param HttpMethodsClient $httpClient
     */
    protected function setHttpClient($httpClient)
    {
        $this->httpClient = $httpClient;
    }

    /**
     * @param string $apiRootUrl
     */
    protected function setApiRootUrl($apiRootUrl)
    {
        $this->apiRootUrl = $apiRootUrl;
    }

    /**
     * @param RepresentProcessorInterface $representProcessor
     */
    protected function setRepresentProcessor($representProcessor)
    {
        $this->representProcessor = $representProcessor;
    }

    /**
     * add basic representation for EventClient.
     */
    protected function addBasicRepresentation()
    {
        $this->getRepresentProcessor()->addRepresentation(new EventRepresentation());
    }

    /**
     * @return HttpMethodsClient
     */
    protected function createHttpClient()
    {
        $httpClient = new HttpMethodsClient(
            HttpClientDiscovery::find(),
            MessageFactoryDiscovery::find()
        );

        return $httpClient;
    }

    /**
     * @return RepresentProcessor
     */
    protected function createRepresentProcessor()
    {
        return new RepresentProcessor();
    }

    /**
     * @param PagerDutyEntityInterface $pagerDutyEntity
     *
     * @return string
     */
    private function getResourceUrl(PagerDutyEntityInterface $pagerDutyEntity)
    {
        return sprintf(
            '%s/%s',
            $this->getApiRootUrl(),
            $this->getRepresentProcessor()->getRESTResourcePath($pagerDutyEntity)
        );
    }

    /**
     * @param $response
     *
     * @return bool|\stdClass
     *
     * @throws EventApiResponseErrorException
     */
    private function performResponse($response)
    {
        $data = false;
        if ($response instanceof ResponseInterface) {
            $data = json_decode($response->getBody()->getContents());
            self::validateResponseData($data);
        }

        return $data;
    }

    /**
     * @param mixed $data
     *
     * @throws EventClientException
     */
    private static function validateResponseData($data)
    {
        if (!isset($data->status)) {
            throw EventApiResponseCorruptException::eventApiResponseCorrupt($data);
        } elseif (isset($data->errors)) {
            throw EventApiResponseErrorException::eventApiResponseError($data->errors[0]);
        }
    }
}


1		<?php
2
3		namespace TonicForHealth\PagerDutyClient\Client;
4
5		use Http\Client\Exception as HttpClientException;
6		use Http\Client\Common\HttpMethodsClient;
7		use Http\Discovery\HttpClientDiscovery;
8		use Http\Discovery\MessageFactoryDiscovery;
9		use Psr\Http\Message\ResponseInterface;
10		use TonicForHealth\PagerDutyClient\Client\Exception\EventApiResponseCorruptException;
11		use TonicForHealth\PagerDutyClient\Client\Exception\EventApiResponseErrorException;
12		use TonicForHealth\PagerDutyClient\Client\Exception\EventClientException;
13		use TonicForHealth\PagerDutyClient\Entity\Event\EventRepresentation;
14		use TonicForHealth\PagerDutyClient\Entity\PagerDutyEntityInterface;
15		use TonicForHealth\PagerDutyClient\RepresentProcessor\RepresentProcessor;
16		use TonicForHealth\PagerDutyClient\RepresentProcessor\RepresentProcessorInterface;
17
18		/**
19		* Class EventClient.
20		*/
21		class EventClient
22		{
23		protected $headers = ['Content-type' => 'application/json'];
24		/**
25		* @var HttpMethodsClient
26		*/
27		protected $httpClient;
28
29		/**
30		* @var string
31		*/
32		protected $apiRootUrl;
33
34		/**
35		* @var RepresentProcessorInterface
36		*/
37		protected $representProcessor;
38
39		/**
40		* RequestNotificationType constructor.
41		*
42		* @param string $apiRootUrl
43		* @param HttpMethodsClient $httpClient
44		* @param RepresentProcessorInterface $representProcessor
45		*/
46	1	public function __construct(
47		$apiRootUrl,
48		HttpMethodsClient $httpClient = null,
49		RepresentProcessorInterface $representProcessor = null
50		) {
51	1	$this->setApiRootUrl($apiRootUrl);
52
53	1	if (null === $httpClient) {
54		$httpClient = $this->createHttpClient();
55		}
56	1	$this->setHttpClient($httpClient);
57
58	1	if (null === $representProcessor) {
59		$representProcessor = $this->createRepresentProcessor();
60		}
61	1	$this->setRepresentProcessor($representProcessor);
62
63	1	$this->addBasicRepresentation();
64	1	}
65
66		/**
67		* @param PagerDutyEntityInterface $pagerDutyEntity
68		*
69		* @return ResponseInterface
70		*
71		* @throws EventApiResponseErrorException
72		*/
73	1	public function post(PagerDutyEntityInterface $pagerDutyEntity)
74		{
75	1	$data = null;
76
77		try {
78	1	$response = $this->getHttpClient()->post(
79	1	$this->getResourceUrl($pagerDutyEntity),
80	1	$this->headers,
81	1	$this->getRepresentProcessor()->representJSON($pagerDutyEntity)
82		);
83
84	1	$data = $this->performResponse($response);
85	1	} catch (HttpClientException $exception) {
86		EventClientException::internalProblem($exception);
87		}
88
89		return $data;
90		}
91
92		/**
93		* @return HttpMethodsClient
94		*/
95	1	public function getHttpClient()
96		{
97	1	return $this->httpClient;
98		}
99
100		/**
101		* @return string
102		*/
103	1	public function getApiRootUrl()
104		{
105	1	return $this->apiRootUrl;
106		}
107
108		/**
109		* @return RepresentProcessorInterface
110		*/
111	1	public function getRepresentProcessor()
112		{
113	1	return $this->representProcessor;
114		}
115
116		/**
117		* @param HttpMethodsClient $httpClient
118		*/
119	1	protected function setHttpClient($httpClient)
120		{
121	1	$this->httpClient = $httpClient;
122	1	}
123
124		/**
125		* @param string $apiRootUrl
126		*/
127	1	protected function setApiRootUrl($apiRootUrl)
128		{
129	1	$this->apiRootUrl = $apiRootUrl;
130	1	}
131
132		/**
133		* @param RepresentProcessorInterface $representProcessor
134		*/
135	1	protected function setRepresentProcessor($representProcessor)
136		{
137	1	$this->representProcessor = $representProcessor;
138	1	}
139
140		/**
141		* add basic representation for EventClient.
142		*/
143	1	protected function addBasicRepresentation()
144		{
145	1	$this->getRepresentProcessor()->addRepresentation(new EventRepresentation());
146	1	}
147
148		/**
149		* @return HttpMethodsClient
150		*/
151		protected function createHttpClient()
152		{
153		$httpClient = new HttpMethodsClient(
154		HttpClientDiscovery::find(),
155		MessageFactoryDiscovery::find()
156		);
157
158		return $httpClient;
159		}
160
161		/**
162		* @return RepresentProcessor
163		*/
164		protected function createRepresentProcessor()
165		{
166		return new RepresentProcessor();
167		}
168
169		/**
170		* @param PagerDutyEntityInterface $pagerDutyEntity
171		*
172		* @return string
173		*/
174	1	private function getResourceUrl(PagerDutyEntityInterface $pagerDutyEntity)
175		{
176	1	return sprintf(
177	1	'%s/%s',
178	1	$this->getApiRootUrl(),
179	1	$this->getRepresentProcessor()->getRESTResourcePath($pagerDutyEntity)
180		);
181		}
182
183		/**
184		* @param $response
185		*
186		* @return bool\|\stdClass
187		*
188		* @throws EventApiResponseErrorException
189		*/
190	1	private function performResponse($response)
191		{
192	1	$data = false;
193	1	if ($response instanceof ResponseInterface) {
194	1	$data = json_decode($response->getBody()->getContents());
195	1	self::validateResponseData($data);
196		}
197
198		return $data;
199		}
200
201		/**
202		* @param mixed $data
203		*
204		* @throws EventClientException
205		*/
206	1	private static function validateResponseData($data)
207		{
208	1	if (!isset($data->status)) {
209	1	throw EventApiResponseCorruptException::eventApiResponseCorrupt($data);
210		} elseif (isset($data->errors)) {
211		throw EventApiResponseErrorException::eventApiResponseError($data->errors[0]);
212		}
213		}
214		}
215

tonicforhealth / pagerduty-client

Push — master ( 570173...f1a8d5 )

EventClient::performeResponse() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like