HttpClient::lookForErrors() - Code Metrics - Inspection of "Add the option to implement custom cURL options" - woocommerce/wc-api-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#267)

unknown

created 2020-05-01 15:40 UTC

HttpClient::lookForErrors() A

↳ Parent: HttpClient

Complexity

Conditions	5
Paths	7

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	24
rs	9.2248
c	0
b	0
f	0
cc	5
nc	7
nop	1

<?php
/**
 * WooCommerce REST API HTTP Client
 *
 * @category HttpClient
 * @package  Automattic/WooCommerce
 */

namespace Automattic\WooCommerce\HttpClient;

use Automattic\WooCommerce\Client;
use Automattic\WooCommerce\HttpClient\BasicAuth;
use Automattic\WooCommerce\HttpClient\HttpClientException;
use Automattic\WooCommerce\HttpClient\OAuth;
use Automattic\WooCommerce\HttpClient\Options;
use Automattic\WooCommerce\HttpClient\Request;
use Automattic\WooCommerce\HttpClient\Response;

/**
 * REST API HTTP Client class.
 *
 * @package Automattic/WooCommerce
 */
class HttpClient
{

    /**
     * cURL handle.
     *
     * @var resource
     */
    protected $ch;

    /**
     * Store API URL.
     *
     * @var string
     */
    protected $url;

    /**
     * Consumer key.
     *
     * @var string
     */
    protected $consumerKey;

    /**
     * Consumer secret.
     *
     * @var string
     */
    protected $consumerSecret;

    /**
     * Client options.
     *
     * @var Options
     */
    protected $options;

    /**
     * The custom cURL options to use in the requests.
     *
     * @var array
     */
    private $customCurlOptions = [];

    /**
     * Request.
     *
     * @var Request
     */
    private $request;

    /**
     * Response.
     *
     * @var Response
     */
    private $response;

    /**
     * Response headers.
     *
     * @var string
     */
    private $responseHeaders;

    /**
     * Initialize HTTP client.
     *
     * @param string $url            Store URL.
     * @param string $consumerKey    Consumer key.
     * @param string $consumerSecret Consumer Secret.
     * @param array  $options        Client options.
     */
    public function __construct($url, $consumerKey, $consumerSecret, $options)
    {
        if (!\function_exists('curl_version')) {
            throw new HttpClientException('cURL is NOT installed on this server', -1, new Request(), new Response());
        }

        $this->options        = new Options($options);
        $this->url            = $this->buildApiUrl($url);
        $this->consumerKey    = $consumerKey;
        $this->consumerSecret = $consumerSecret;
    }

    /**
     * Check if is under SSL.
     *
     * @return bool
     */
    protected function isSsl()
    {
        return 'https://' === \substr($this->url, 0, 8);
    }

    /**
     * Build API URL.
     *
     * @param string $url Store URL.
     *
     * @return string
     */
    protected function buildApiUrl($url)
    {
        $api = $this->options->isWPAPI() ? $this->options->apiPrefix() : '/wc-api/';

        return \rtrim($url, '/') . $api . $this->options->getVersion() . '/';
    }

    /**
     * Build URL.
     *
     * @param string $url        URL.
     * @param array  $parameters Query string parameters.
     *
     * @return string
     */
    protected function buildUrlQuery($url, $parameters = [])
    {
        if (!empty($parameters)) {
            $url .= '?' . \http_build_query($parameters);
        }

        return $url;
    }

    /**
     * Authenticate.
     *
     * @param string $url        Request URL.
     * @param string $method     Request method.
     * @param array  $parameters Request parameters.
     *
     * @return array
     */
    protected function authenticate($url, $method, $parameters = [])
    {
        // Setup authentication.
        if ($this->isSsl()) {
            $basicAuth  = new BasicAuth(
                $this->ch,
                $this->consumerKey,
                $this->consumerSecret,
                $this->options->isQueryStringAuth(),
                $parameters
            );
            $parameters = $basicAuth->getParameters();
        } else {
            $oAuth      = new OAuth(
                $url,
                $this->consumerKey,
                $this->consumerSecret,
                $this->options->getVersion(),
                $method,
                $parameters,
                $this->options->oauthTimestamp()
            );
            $parameters = $oAuth->getParameters();
        }

        return $parameters;
    }

    /**
     * Setup method.
     *
     * @param string $method Request method.
     */
    protected function setupMethod($method)
    {
        if ('POST' == $method) {
            \curl_setopt($this->ch, CURLOPT_POST, true);
        } elseif (\in_array($method, ['PUT', 'DELETE', 'OPTIONS'])) {
            \curl_setopt($this->ch, CURLOPT_CUSTOMREQUEST, $method);
        }
    }

    /**
     * Get request headers.
     *
     * @param  bool $sendData If request send data or not.
     *
     * @return array
     */
    protected function getRequestHeaders($sendData = false)
    {
        $headers = [
            'Accept'     => 'application/json',
            'User-Agent' => $this->options->userAgent() . '/' . Client::VERSION,
        ];

        if ($sendData) {
            $headers['Content-Type'] = 'application/json;charset=utf-8';
        }

        return $headers;
    }

    /**
     * Create request.
     *
     * @param string $endpoint   Request endpoint.
     * @param string $method     Request method.
     * @param array  $data       Request data.
     * @param array  $parameters Request parameters.
     *
     * @return Request
     */
    protected function createRequest($endpoint, $method, $data = [], $parameters = [])
    {
        $body    = '';
        $url     = $this->url . $endpoint;
        $hasData = !empty($data);

        // Setup authentication.
        $parameters = $this->authenticate($url, $method, $parameters);

        // Setup method.
        $this->setupMethod($method);

        // Include post fields.
        if ($hasData) {
            $body = \json_encode($data);
            \curl_setopt($this->ch, CURLOPT_POSTFIELDS, $body);
        }

        $this->request = new Request(
            $this->buildUrlQuery($url, $parameters),
            $method,
            $parameters,
            $this->getRequestHeaders($hasData),
            $body
        );

        return $this->getRequest();
    }

    /**
     * Get response headers.
     *
     * @return array
     */
    protected function getResponseHeaders()
    {
        $headers = [];
        $lines   = \explode("\n", $this->responseHeaders);
        $lines   = \array_filter($lines, 'trim');

        foreach ($lines as $index => $line) {
            // Remove HTTP/xxx params.
            if (strpos($line, ': ') === false) {
                continue;
            }

            list($key, $value) = \explode(': ', $line);

            $headers[$key] = isset($headers[$key]) ? $headers[$key] . ', ' . trim($value) : trim($value);
        }

        return $headers;
    }

    /**
     * Create response.
     *
     * @return Response
     */
    protected function createResponse()
    {

        // Set response headers.
        $this->responseHeaders = '';
        \curl_setopt($this->ch, CURLOPT_HEADERFUNCTION, function ($_, $headers) {
            $this->responseHeaders .= $headers;
            return \strlen($headers);
        });

        // Get response data.
        $body    = \curl_exec($this->ch);
        $code    = \curl_getinfo($this->ch, CURLINFO_HTTP_CODE);
        $headers = $this->getResponseHeaders();

        // Register response.
        $this->response = new Response($code, $headers, $body);

        return $this->getResponse();
    }

    /**
     * Set default cURL settings.
     */
    protected function setDefaultCurlSettings()
    {
        $verifySsl       = $this->options->verifySsl();
        $timeout         = $this->options->getTimeout();
        $followRedirects = $this->options->getFollowRedirects();

        \curl_setopt($this->ch, CURLOPT_SSL_VERIFYPEER, $verifySsl);
        if (!$verifySsl) {
            \curl_setopt($this->ch, CURLOPT_SSL_VERIFYHOST, $verifySsl);
        }
        if ($followRedirects) {
            \curl_setopt($this->ch, CURLOPT_FOLLOWLOCATION, true);
        }
        \curl_setopt($this->ch, CURLOPT_CONNECTTIMEOUT, $timeout);
        \curl_setopt($this->ch, CURLOPT_TIMEOUT, $timeout);
        \curl_setopt($this->ch, CURLOPT_RETURNTRANSFER, true);
        \curl_setopt($this->ch, CURLOPT_HTTPHEADER, $this->request->getRawHeaders());
        \curl_setopt($this->ch, CURLOPT_URL, $this->request->getUrl());

        foreach ($this->customCurlOptions as $customCurlOptionKey => $customCurlOptionValue) {
            \curl_setopt($this->ch, $customCurlOptionKey, $customCurlOptionValue);
        }
    }

    /**
     * Look for errors in the request.
     *
     * @param array $parsedResponse Parsed body response.
     */
    protected function lookForErrors($parsedResponse)
    {
        // Any non-200/201/202 response code indicates an error.
        if (!\in_array($this->response->getCode(), ['200', '201', '202'])) {
            $errors = isset($parsedResponse->errors) ? $parsedResponse->errors : $parsedResponse;
            $errorMessage = '';
            $errorCode = '';

            if (is_array($errors)) {
                $errorMessage = $errors[0]->message;
                $errorCode    = $errors[0]->code;
            } elseif (isset($errors->message, $errors->code)) {
                $errorMessage = $errors->message;
                $errorCode    = $errors->code;
            }

            throw new HttpClientException(
                \sprintf('Error: %s [%s]', $errorMessage, $errorCode),
                $this->response->getCode(),
                $this->request,
                $this->response
            );
        }
    }

    /**
     * Process response.
     *
     * @return array
     */
    protected function processResponse()
    {
        $body = $this->response->getBody();

        // Look for UTF-8 BOM and remove.
        if (0 === strpos(bin2hex(substr($body, 0, 4)), 'efbbbf')) {
            $body = substr($body, 3);
        }

        $parsedResponse = \json_decode($body);

        // Test if return a valid JSON.
        if (JSON_ERROR_NONE !== json_last_error()) {
            $message = function_exists('json_last_error_msg') ? json_last_error_msg() : 'Invalid JSON returned';
            throw new HttpClientException(
                sprintf('JSON ERROR: %s', $message),
                $this->response->getCode(),
                $this->request,
                $this->response
            );
        }

        $this->lookForErrors($parsedResponse);

        return $parsedResponse;
    }

    /**
     * Make requests.
     *
     * @param string $endpoint   Request endpoint.
     * @param string $method     Request method.
     * @param array  $data       Request data.
     * @param array  $parameters Request parameters.
     *
     * @return array
     */
    public function request($endpoint, $method, $data = [], $parameters = [])
    {
        // Initialize cURL.
        $this->ch = \curl_init();

        // Set request args.
        $request = $this->createRequest($endpoint, $method, $data, $parameters);

        // Default cURL settings.
        $this->setDefaultCurlSettings();

        // Get response.
        $response = $this->createResponse();

        // Check for cURL errors.
        if (\curl_errno($this->ch)) {
            throw new HttpClientException('cURL Error: ' . \curl_error($this->ch), 0, $request, $response);
        }

        \curl_close($this->ch);

        return $this->processResponse();
    }

    /**
     * Get request data.
     *
     * @return Request
     */
    public function getRequest()
    {
        return $this->request;
    }

    /**
     * Get response data.
     *
     * @return Response
     */
    public function getResponse()
    {
        return $this->response;
    }

    /**
     * Set custom cURL options to use in requests.
     *
     * @param array $curlOptions
     */
    public function setCustomCurlOptions(array $curlOptions)
    {
        $this->customCurlOptions = $curlOptions;
    }
}


1			<?php
2			/**
3			* WooCommerce REST API HTTP Client
4			*
5			* @category HttpClient
6			* @package Automattic/WooCommerce
7			*/
8
9			namespace Automattic\WooCommerce\HttpClient;
10
11			use Automattic\WooCommerce\Client;
12			use Automattic\WooCommerce\HttpClient\BasicAuth;
13			use Automattic\WooCommerce\HttpClient\HttpClientException;
14			use Automattic\WooCommerce\HttpClient\OAuth;
15			use Automattic\WooCommerce\HttpClient\Options;
16			use Automattic\WooCommerce\HttpClient\Request;
17			use Automattic\WooCommerce\HttpClient\Response;
18
19			/**
20			* REST API HTTP Client class.
21			*
22			* @package Automattic/WooCommerce
23			*/
24			class HttpClient
25			{
26
27			/**
28			* cURL handle.
29			*
30			* @var resource
31			*/
32			protected $ch;
33
34			/**
35			* Store API URL.
36			*
37			* @var string
38			*/
39			protected $url;
40
41			/**
42			* Consumer key.
43			*
44			* @var string
45			*/
46			protected $consumerKey;
47
48			/**
49			* Consumer secret.
50			*
51			* @var string
52			*/
53			protected $consumerSecret;
54
55			/**
56			* Client options.
57			*
58			* @var Options
59			*/
60			protected $options;
61
62			/**
63			* The custom cURL options to use in the requests.
64			*
65			* @var array
66			*/
67			private $customCurlOptions = [];
68
69			/**
70			* Request.
71			*
72			* @var Request
73			*/
74			private $request;
75
76			/**
77			* Response.
78			*
79			* @var Response
80			*/
81			private $response;
82
83			/**
84			* Response headers.
85			*
86			* @var string
87			*/
88			private $responseHeaders;
89
90			/**
91			* Initialize HTTP client.
92			*
93			* @param string $url Store URL.
94			* @param string $consumerKey Consumer key.
95			* @param string $consumerSecret Consumer Secret.
96			* @param array $options Client options.
97			*/
98			public function __construct($url, $consumerKey, $consumerSecret, $options)
99			{
100			if (!\function_exists('curl_version')) {
101			throw new HttpClientException('cURL is NOT installed on this server', -1, new Request(), new Response());
102			}
103
104			$this->options = new Options($options);
105			$this->url = $this->buildApiUrl($url);
106			$this->consumerKey = $consumerKey;
107			$this->consumerSecret = $consumerSecret;
108			}
109
110			/**
111			* Check if is under SSL.
112			*
113			* @return bool
114			*/
115			protected function isSsl()
116			{
117			return 'https://' === \substr($this->url, 0, 8);
118			}
119
120			/**
121			* Build API URL.
122			*
123			* @param string $url Store URL.
124			*
125			* @return string
126			*/
127			protected function buildApiUrl($url)
128			{
129			$api = $this->options->isWPAPI() ? $this->options->apiPrefix() : '/wc-api/';
130
131			return \rtrim($url, '/') . $api . $this->options->getVersion() . '/';
132			}
133
134			/**
135			* Build URL.
136			*
137			* @param string $url URL.
138			* @param array $parameters Query string parameters.
139			*
140			* @return string
141			*/
142			protected function buildUrlQuery($url, $parameters = [])
143			{
144			if (!empty($parameters)) {
145			$url .= '?' . \http_build_query($parameters);
146			}
147
148			return $url;
149			}
150
151			/**
152			* Authenticate.
153			*
154			* @param string $url Request URL.
155			* @param string $method Request method.
156			* @param array $parameters Request parameters.
157			*
158			* @return array
159			*/
160			protected function authenticate($url, $method, $parameters = [])
161			{
162			// Setup authentication.
163			if ($this->isSsl()) {
164			$basicAuth = new BasicAuth(
165			$this->ch,
166			$this->consumerKey,
167			$this->consumerSecret,
168			$this->options->isQueryStringAuth(),
169			$parameters
170			);
171			$parameters = $basicAuth->getParameters();
172			} else {
173			$oAuth = new OAuth(
174			$url,
175			$this->consumerKey,
176			$this->consumerSecret,
177			$this->options->getVersion(),
178			$method,
179			$parameters,
180			$this->options->oauthTimestamp()
181			);
182			$parameters = $oAuth->getParameters();
183			}
184
185			return $parameters;
186			}
187
188			/**
189			* Setup method.
190			*
191			* @param string $method Request method.
192			*/
193			protected function setupMethod($method)
194			{
195			if ('POST' == $method) {
196			\curl_setopt($this->ch, CURLOPT_POST, true);
197			} elseif (\in_array($method, ['PUT', 'DELETE', 'OPTIONS'])) {
198			\curl_setopt($this->ch, CURLOPT_CUSTOMREQUEST, $method);
199			}
200			}
201
202			/**
203			* Get request headers.
204			*
205			* @param bool $sendData If request send data or not.
206			*
207			* @return array
208			*/
209			protected function getRequestHeaders($sendData = false)
210			{
211			$headers = [
212			'Accept' => 'application/json',
213			'User-Agent' => $this->options->userAgent() . '/' . Client::VERSION,
214			];
215
216			if ($sendData) {
217			$headers['Content-Type'] = 'application/json;charset=utf-8';
218			}
219
220			return $headers;
221			}
222
223			/**
224			* Create request.
225			*
226			* @param string $endpoint Request endpoint.
227			* @param string $method Request method.
228			* @param array $data Request data.
229			* @param array $parameters Request parameters.
230			*
231			* @return Request
232			*/
233			protected function createRequest($endpoint, $method, $data = [], $parameters = [])
234			{
235			$body = '';
236			$url = $this->url . $endpoint;
237			$hasData = !empty($data);
238
239			// Setup authentication.
240			$parameters = $this->authenticate($url, $method, $parameters);
241
242			// Setup method.
243			$this->setupMethod($method);
244
245			// Include post fields.
246			if ($hasData) {
247			$body = \json_encode($data);
248			\curl_setopt($this->ch, CURLOPT_POSTFIELDS, $body);
249			}
250
251			$this->request = new Request(
252			$this->buildUrlQuery($url, $parameters),
253			$method,
254			$parameters,
255			$this->getRequestHeaders($hasData),
256			$body
257			);
258
259			return $this->getRequest();
260			}
261
262			/**
263			* Get response headers.
264			*
265			* @return array
266			*/
267			protected function getResponseHeaders()
268			{
269			$headers = [];
270			$lines = \explode("\n", $this->responseHeaders);
271			$lines = \array_filter($lines, 'trim');
272
273			foreach ($lines as $index => $line) {
274			// Remove HTTP/xxx params.
275			if (strpos($line, ': ') === false) {
276			continue;
277			}
278
279			list($key, $value) = \explode(': ', $line);
280
281			$headers[$key] = isset($headers[$key]) ? $headers[$key] . ', ' . trim($value) : trim($value);
282			}
283
284			return $headers;
285			}
286
287			/**
288			* Create response.
289			*
290			* @return Response
291			*/
292			protected function createResponse()
293			{
294
295			// Set response headers.
296			$this->responseHeaders = '';
297			\curl_setopt($this->ch, CURLOPT_HEADERFUNCTION, function ($_, $headers) {
298			$this->responseHeaders .= $headers;
299			return \strlen($headers);
300			});
301
302			// Get response data.
303			$body = \curl_exec($this->ch);
304			$code = \curl_getinfo($this->ch, CURLINFO_HTTP_CODE);
305			$headers = $this->getResponseHeaders();
306
307			// Register response.
308			$this->response = new Response($code, $headers, $body);
309
310			return $this->getResponse();
311			}
312
313			/**
314			* Set default cURL settings.
315			*/
316			protected function setDefaultCurlSettings()
317			{
318			$verifySsl = $this->options->verifySsl();
319			$timeout = $this->options->getTimeout();
320			$followRedirects = $this->options->getFollowRedirects();
321
322			\curl_setopt($this->ch, CURLOPT_SSL_VERIFYPEER, $verifySsl);
323			if (!$verifySsl) {
324			\curl_setopt($this->ch, CURLOPT_SSL_VERIFYHOST, $verifySsl);
325			}
326			if ($followRedirects) {
327			\curl_setopt($this->ch, CURLOPT_FOLLOWLOCATION, true);
328			}
329			\curl_setopt($this->ch, CURLOPT_CONNECTTIMEOUT, $timeout);
330			\curl_setopt($this->ch, CURLOPT_TIMEOUT, $timeout);
331			\curl_setopt($this->ch, CURLOPT_RETURNTRANSFER, true);
332			\curl_setopt($this->ch, CURLOPT_HTTPHEADER, $this->request->getRawHeaders());
333			\curl_setopt($this->ch, CURLOPT_URL, $this->request->getUrl());
334
335			foreach ($this->customCurlOptions as $customCurlOptionKey => $customCurlOptionValue) {
336			\curl_setopt($this->ch, $customCurlOptionKey, $customCurlOptionValue);
337			}
338			}
339
340			/**
341			* Look for errors in the request.
342			*
343			* @param array $parsedResponse Parsed body response.
344			*/
345			protected function lookForErrors($parsedResponse)
346			{
347			// Any non-200/201/202 response code indicates an error.
348			if (!\in_array($this->response->getCode(), ['200', '201', '202'])) {
349			$errors = isset($parsedResponse->errors) ? $parsedResponse->errors : $parsedResponse;
350			$errorMessage = '';
351			$errorCode = '';
352
353			if (is_array($errors)) {
354			$errorMessage = $errors[0]->message;
355			$errorCode = $errors[0]->code;
356			} elseif (isset($errors->message, $errors->code)) {
357			$errorMessage = $errors->message;
358			$errorCode = $errors->code;
359			}
360
361			throw new HttpClientException(
362			\sprintf('Error: %s [%s]', $errorMessage, $errorCode),
363			$this->response->getCode(),
364			$this->request,
365			$this->response
366			);
367			}
368			}
369
370			/**
371			* Process response.
372			*
373			* @return array
374			*/
375			protected function processResponse()
376			{
377			$body = $this->response->getBody();
378
379			// Look for UTF-8 BOM and remove.
380			if (0 === strpos(bin2hex(substr($body, 0, 4)), 'efbbbf')) {
381			$body = substr($body, 3);
382			}
383
384			$parsedResponse = \json_decode($body);
385
386			// Test if return a valid JSON.
387			if (JSON_ERROR_NONE !== json_last_error()) {
388			$message = function_exists('json_last_error_msg') ? json_last_error_msg() : 'Invalid JSON returned';
389			throw new HttpClientException(
390			sprintf('JSON ERROR: %s', $message),
391			$this->response->getCode(),
392			$this->request,
393			$this->response
394			);
395			}
396
397			$this->lookForErrors($parsedResponse);
398
399			return $parsedResponse;
400			}
401
402			/**
403			* Make requests.
404			*
405			* @param string $endpoint Request endpoint.
406			* @param string $method Request method.
407			* @param array $data Request data.
408			* @param array $parameters Request parameters.
409			*
410			* @return array
411			*/
412			public function request($endpoint, $method, $data = [], $parameters = [])
413			{
414			// Initialize cURL.
415			$this->ch = \curl_init();
416
417			// Set request args.
418			$request = $this->createRequest($endpoint, $method, $data, $parameters);
419
420			// Default cURL settings.
421			$this->setDefaultCurlSettings();
422
423			// Get response.
424			$response = $this->createResponse();
425
426			// Check for cURL errors.
427			if (\curl_errno($this->ch)) {
428			throw new HttpClientException('cURL Error: ' . \curl_error($this->ch), 0, $request, $response);
429			}
430
431			\curl_close($this->ch);
432
433			return $this->processResponse();
434			}
435
436			/**
437			* Get request data.
438			*
439			* @return Request
440			*/
441			public function getRequest()
442			{
443			return $this->request;
444			}
445
446			/**
447			* Get response data.
448			*
449			* @return Response
450			*/
451			public function getResponse()
452			{
453			return $this->response;
454			}
455
456			/**
457			* Set custom cURL options to use in requests.
458			*
459			* @param array $curlOptions
460			*/
461			public function setCustomCurlOptions(array $curlOptions)
462			{
463			$this->customCurlOptions = $curlOptions;
464			}
465			}
466

woocommerce / wc-api-php

Pull Request — master (#267)

HttpClient::lookForErrors() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like