Curl::generateCurlOptions() - Code Metrics - suricate-php/framework - Measure and Improve Code Quality continuously with Scrutinizer

Curl::generateCurlOptions() B
last analyzed 2019-08-10 15:27 UTC

↳ Parent: Curl

Complexity

Conditions	8
Paths	18

Size

Total Lines	46
Code Lines	30

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	72

Importance

Changes	4
Bugs	0	Features	0

Metric	Value
cc	8
eloc	30
c	4
b	0
f	0
nc	18
nop	0
dl	0
loc	46
ccs	0
cts	29
cp	0
crap	72
rs	8.1954

<?php

declare(strict_types=1);

namespace Suricate;

/**
 * Curl extension for Suricate
 *
 * @package Suricate
 * @author  Mathieu LESNIAK <[email protected]>
 *
 * @property string $userAgent
 * @property int $timeout
 * @property string $proxyHost
 * @property int $proxyPort
 * @property string $referer
 * @property string $cookie
 * @property string $userAgent
 * @property mixed $postFields
 * @property string $login
 * @property string $password
 * @property array $headers
 */

class Curl extends Service
{
    protected $parametersList = [
        'userAgent',
        'timeout',
        'proxyHost',
        'proxyPort',
        'referer',
        'cookie',
        'userAgent',
        'postFields',
        'login',
        'password',
        'headers'
    ];

    private $request;
    private $response;
    private $responseData;
    private $errorMsg;
    private $errorCode;

    public function __construct()
    {
        parent::__construct();

        $this->request = new Request();
        $this->response = new Request();
        $this->headers = [];
    }

    public function setUrl($url)
    {
        $this->request->setUrl($url);

        return $this;
    }

    public function getUrl()
    {
        return $this->request->getUrl();
    }

    public function setMethod($method)
    {
        $this->request->setMethod($method);

        return $this;
    }

    public function setUserAgent($userAgent)
    {
        $this->userAgent = $userAgent;

        return $this;
    }

    public function addHeader($headerLine)
    {
        $headers = $this->headers;
        $headers[] = $headerLine;

        $this->headers = $headers;

        return $this;
    }

    public function send()
    {
        $curlHandler = curl_init($this->request->getUrl());

        if ($curlHandler === false) {
            throw new \Exception('Can\'t init curl');
        }
        $curlOptions = $this->generateCurlOptions();
        curl_setopt_array($curlHandler, $curlOptions);

        $curlResponse = curl_exec($curlHandler);
        if ($curlResponse === false) {
            $this->errorMsg = curl_error($curlHandler);
            $this->errorCode = curl_errno($curlHandler);

            return false;
        }
        // No return transfer option
        if (is_bool($curlResponse)) {
            return true;
        }

        $this->responseData = curl_getinfo($curlHandler);
        $this->response->setUrl($this->responseData['url']);
        $redirectCount = curl_getinfo($curlHandler, CURLINFO_REDIRECT_COUNT);

        $splittedResponse = explode(
            "\r\n\r\n",
            $curlResponse,
            $redirectCount + 2
        );
        $lastHeader = $splittedResponse[$redirectCount];

        // get headers out of response
        $headers = explode("\n", trim($lastHeader));
        array_shift($headers);

        foreach ($headers as $headerLine) {
            preg_match('|^([\d\w\s_-]*):(.*)|', $headerLine, $matches);
            if (isset($matches[1])) {
                $this->response->addHeader($matches[1], trim($matches[2]));
            }
        }

        // Reponse data
        $this->response->setHttpCode($this->responseData['http_code']);
        $this->response->setBody(
            substr($curlResponse, $this->responseData['header_size'])
        );

        return $this;
    }

    private function generateCurlOptions()
    {
        $curlOptions = [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HEADER => true,
            CURLINFO_HEADER_OUT => true,
            CURLOPT_FOLLOWLOCATION => true,
            CURLOPT_SSL_VERIFYPEER => false,
            CURLOPT_SSL_VERIFYHOST => false
        ];

        $parametersMapping = [
            CURLOPT_CONNECTTIMEOUT => 'timeout',
            CURLOPT_PROXY => 'proxyHost',
            CURLOPT_PROXYPORT => 'proxyPort',
            CURLOPT_REFERER => 'referer',
            CURLOPT_COOKIE => 'cookie',
            CURLOPT_USERAGENT => 'userAgent',
            CURLOPT_HTTPHEADER => 'headers'
        ];

        foreach ($parametersMapping as $curlKey => $optionKey) {
            if (($value = $this->getParameter($optionKey)) !== null) {
                $curlOptions[$curlKey] = $value;
            }
        }

        //
        // Method management
        //
        if ($this->request->getMethod() == Request::HTTP_METHOD_GET) {
            $curlOptions[CURLOPT_HTTPGET] = true;
        } elseif ($this->request->getMethod() == Request::HTTP_METHOD_POST) {
            $curlOptions[CURLOPT_POST] = true;
            if ($this->getParameter('postFields') !== null) {
                $curlOptions[CURLOPT_POSTFIELDS] = $this->getParameter(
                    'postFields'
                );
            }
        } elseif ($this->request->getMethod() == Request::HTTP_METHOD_PUT) {
            $curlOptions[CURLOPT_PUT] = true;
        } elseif ($this->request->getMethod() == Request::HTTP_METHOD_HEAD) {
            $curlOptions[CURLOPT_NOBODY] = true;
        }

        return $curlOptions;
    }

    public function getResponse()
    {
        return $this->response;
    }

    public function getHeaders()
    {
        return $this->response->getHeaders();
    }

    public function getHttpCode()
    {
        return isset($this->responseData['http_code'])
            ? $this->responseData['http_code']
            : null;
    }

    public function getErrorMsg()
    {
        return $this->errorMsg;
    }

    public function getErrorCode()
    {
        return $this->errorCode;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Suricate;
6
7		/**
8		* Curl extension for Suricate
9		*
10		* @package Suricate
11		* @author Mathieu LESNIAK <[email protected]>
12		*
13		* @property string $userAgent
14		* @property int $timeout
15		* @property string $proxyHost
16		* @property int $proxyPort
17		* @property string $referer
18		* @property string $cookie
19		* @property string $userAgent
20		* @property mixed $postFields
21		* @property string $login
22		* @property string $password
23		* @property array $headers
24		*/
25
26		class Curl extends Service
27		{
28		protected $parametersList = [
29		'userAgent',
30		'timeout',
31		'proxyHost',
32		'proxyPort',
33		'referer',
34		'cookie',
35		'userAgent',
36		'postFields',
37		'login',
38		'password',
39		'headers'
40		];
41
42		private $request;
43		private $response;
44		private $responseData;
45		private $errorMsg;
46		private $errorCode;
47
48	1	public function __construct()
49		{
50	1	parent::__construct();
51
52	1	$this->request = new Request();
53	1	$this->response = new Request();
54	1	$this->headers = [];
55	1	}
56
57	1	public function setUrl($url)
58		{
59	1	$this->request->setUrl($url);
60
61	1	return $this;
62		}
63
64	1	public function getUrl()
65		{
66	1	return $this->request->getUrl();
67		}
68
69	1	public function setMethod($method)
70		{
71	1	$this->request->setMethod($method);
72
73	1	return $this;
74		}
75
76	1	public function setUserAgent($userAgent)
77		{
78	1	$this->userAgent = $userAgent;
79
80	1	return $this;
81		}
82
83	1	public function addHeader($headerLine)
84		{
85	1	$headers = $this->headers;
86	1	$headers[] = $headerLine;
87
88	1	$this->headers = $headers;
89
90	1	return $this;
91		}
92
93		public function send()
94		{
95		$curlHandler = curl_init($this->request->getUrl());
96
97		if ($curlHandler === false) {
98		throw new \Exception('Can\'t init curl');
99		}
100		$curlOptions = $this->generateCurlOptions();
101		curl_setopt_array($curlHandler, $curlOptions);
102
103		$curlResponse = curl_exec($curlHandler);
104		if ($curlResponse === false) {
105		$this->errorMsg = curl_error($curlHandler);
106		$this->errorCode = curl_errno($curlHandler);
107
108		return false;
109		}
110		// No return transfer option
111		if (is_bool($curlResponse)) {
112		return true;
113		}
114
115		$this->responseData = curl_getinfo($curlHandler);
116		$this->response->setUrl($this->responseData['url']);
117		$redirectCount = curl_getinfo($curlHandler, CURLINFO_REDIRECT_COUNT);
118
119		$splittedResponse = explode(
120		"\r\n\r\n",
121		$curlResponse,
122		$redirectCount + 2
123		);
124		$lastHeader = $splittedResponse[$redirectCount];
125
126		// get headers out of response
127		$headers = explode("\n", trim($lastHeader));
128		array_shift($headers);
129
130		foreach ($headers as $headerLine) {
131		preg_match('\|^([\d\w\s_-]):(.)\|', $headerLine, $matches);
132		if (isset($matches[1])) {
133		$this->response->addHeader($matches[1], trim($matches[2]));
134		}
135		}
136
137		// Reponse data
138		$this->response->setHttpCode($this->responseData['http_code']);
139		$this->response->setBody(
140		substr($curlResponse, $this->responseData['header_size'])
141		);
142
143		return $this;
144		}
145
146		private function generateCurlOptions()
147		{
148		$curlOptions = [
149		CURLOPT_RETURNTRANSFER => true,
150		CURLOPT_HEADER => true,
151		CURLINFO_HEADER_OUT => true,
152		CURLOPT_FOLLOWLOCATION => true,
153		CURLOPT_SSL_VERIFYPEER => false,
154		CURLOPT_SSL_VERIFYHOST => false
155		];
156
157		$parametersMapping = [
158		CURLOPT_CONNECTTIMEOUT => 'timeout',
159		CURLOPT_PROXY => 'proxyHost',
160		CURLOPT_PROXYPORT => 'proxyPort',
161		CURLOPT_REFERER => 'referer',
162		CURLOPT_COOKIE => 'cookie',
163		CURLOPT_USERAGENT => 'userAgent',
164		CURLOPT_HTTPHEADER => 'headers'
165		];
166
167		foreach ($parametersMapping as $curlKey => $optionKey) {
168		if (($value = $this->getParameter($optionKey)) !== null) {
169		$curlOptions[$curlKey] = $value;
170		}
171		}
172
173		//
174		// Method management
175		//
176		if ($this->request->getMethod() == Request::HTTP_METHOD_GET) {
177		$curlOptions[CURLOPT_HTTPGET] = true;
178		} elseif ($this->request->getMethod() == Request::HTTP_METHOD_POST) {
179		$curlOptions[CURLOPT_POST] = true;
180		if ($this->getParameter('postFields') !== null) {
181		$curlOptions[CURLOPT_POSTFIELDS] = $this->getParameter(
182		'postFields'
183		);
184		}
185		} elseif ($this->request->getMethod() == Request::HTTP_METHOD_PUT) {
186		$curlOptions[CURLOPT_PUT] = true;
187		} elseif ($this->request->getMethod() == Request::HTTP_METHOD_HEAD) {
188		$curlOptions[CURLOPT_NOBODY] = true;
189		}
190
191		return $curlOptions;
192		}
193
194		public function getResponse()
195		{
196		return $this->response;
197		}
198
199		public function getHeaders()
200		{
201		return $this->response->getHeaders();
202		}
203
204		public function getHttpCode()
205		{
206		return isset($this->responseData['http_code'])
207		? $this->responseData['http_code']
208		: null;
209		}
210
211		public function getErrorMsg()
212		{
213		return $this->errorMsg;
214		}
215
216		public function getErrorCode()
217		{
218		return $this->errorCode;
219		}
220		}
221

suricate-php / framework

Curl::generateCurlOptions() B last analyzed 2019-08-10 15:27 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Curl::generateCurlOptions() B
last analyzed 2019-08-10 15:27 UTC