DeCaptchaAbstract::decodeResponse() - Code Metrics - Inspection of "Removed dependency on cURL" - jumper423/decaptcha - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#8)

by Dmitrii

created 2017-01-18 20:10 UTC

DeCaptchaAbstract::decodeResponse() C

↳ Parent: DeCaptchaAbstract

Complexity

Conditions	14
Paths	7

Size

Total Lines	40
Code Lines	26

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	16
CRAP Score	14.0398

Importance

Changes

Metric	Value
dl	0
loc	40
ccs	16
cts	17
cp	0.9412
rs	5.0864
c	0
b	0
f	0
cc	14
eloc	26
nc	7
nop	2
crap	14.0398

How to fix Complexity

<?php

namespace jumper423\decaptcha\core;

use Exception;
use GuzzleHttp\Client;

/**
 * Class DeCaptchaAbstract.
 */
abstract class DeCaptchaAbstract implements DeCaptchaInterface
{
    const RESPONSE_TYPE_STRING = 1;
    const RESPONSE_TYPE_JSON = 2;

    const ACTION_FIELDS = 1;
    const ACTION_URI = 2;
    const ACTION_METHOD = 3;
    const ACTION_JSON = 4;

    const ACTION_METHOD_POST = 'post';
    const ACTION_METHOD_GET = 'get';

    const DECODE_FORMAT = 1;
    const DECODE_ACTION = 2;
    const DECODE_SEPARATOR = 3;
    const DECODE_PARAMS = 4;
    const DECODE_PARAM_SETTING_MARKER = 5;

    const PARAM_FIELD_TYPE_STRING = 1;
    const PARAM_FIELD_TYPE_INTEGER = 2;
    const PARAM_FIELD_TYPE_MIX = 3;
    const PARAM_FIELD_TYPE_OBJECT = 4;
    const PARAM_FIELD_TYPE_BOOLEAN = 5;

    const PARAM_SLUG_DEFAULT = 1;
    const PARAM_SLUG_TYPE = 2;
    const PARAM_SLUG_REQUIRE = 3;
    const PARAM_SLUG_SPEC = 4;
    const PARAM_SLUG_VARIABLE = 5;
    const PARAM_SLUG_CODING = 6;
    const PARAM_SLUG_NOTWIKI = 7;
    const PARAM_SLUG_ENUM = 8;
    const PARAM_SLUG_WIKI = 9;

    const PARAM_SLUG_CODING_BASE64 = 1;

    const PARAM_SPEC_API_KEY = -1;
    const PARAM_SPEC_FILE = -2;
    const PARAM_SPEC_CAPTCHA = -3;
    const PARAM_SPEC_CODE = -4;

    /**
     * Сервис на который будем загружать капчу.
     *
     * @var string
     */
    protected $host;
    protected $scheme = 'http';
    protected $errorLang = DeCaptchaErrors::LANG_EN;
    protected $lastRunTime = null;
    /** @var DeCaptchaErrors */
    protected $errorObject;
    protected $causeAnError = false;

    protected $limit = [];
    protected $paramsSpec = [];
    protected $params = [];
    protected $limitSettings = [];
    protected $decodeSettings = [];
    protected $actions = [];
    protected $paramsNames = [];

    protected function resetLimits()
    {
        foreach ($this->limitSettings as $action => $value) {
            $this->limit[$action] = $value;
        }
    }

    /**
     * @param $action
     *
     * @return bool
     */
    protected function limitHasNotYetEnded($action)
    {
        return $this->limit[$action]-- > 0;
    }

    /**
     * @param $action
     * @param $data
     *
     * @throws DeCaptchaErrors
     *
     * @return array
     */
    protected function decodeResponse($action, $data)
    {
        if (!array_key_exists($action, $this->decodeSettings[static::DECODE_ACTION])) {
            throw new DeCaptchaErrors('нет action');
        }
        $decodeSetting = $this->decodeSettings[static::DECODE_ACTION][$action];
        $decodeFormat = array_key_exists(static::DECODE_FORMAT, $decodeSetting) ?
            $decodeSetting[static::DECODE_FORMAT] :
            $this->decodeSettings[static::DECODE_FORMAT];
        $values = [];
        switch ($decodeFormat) {
            case static::RESPONSE_TYPE_STRING:
                foreach (explode($decodeSetting[static::DECODE_SEPARATOR], $data) as $key => $value) {
                    foreach ($decodeSetting[static::DECODE_PARAMS] as $param => $paramSetting) {
                        if ($key === $paramSetting[static::DECODE_PARAM_SETTING_MARKER]) {
                            $values[$param] = $value;
                        }
                    }
                }
                break;
            case static::RESPONSE_TYPE_JSON:
                foreach (json_decode($data, true) as $key => $value) {
                    foreach ($decodeSetting[static::DECODE_PARAMS] as $param => $paramSetting) {
                        if (count(explode('.', $paramSetting[static::DECODE_PARAM_SETTING_MARKER])) > 1) {
                            if ($key === explode('.', $paramSetting[static::DECODE_PARAM_SETTING_MARKER])[0]) {
                                if (array_key_exists(explode('.', $paramSetting[static::DECODE_PARAM_SETTING_MARKER])[1], $value)) {
                                    $values[$param] = $value[explode('.', $paramSetting[static::DECODE_PARAM_SETTING_MARKER])[1]];
                                }
                            }
                        }
                        if ($key === $paramSetting[static::DECODE_PARAM_SETTING_MARKER]) {
                            $values[$param] = $value;
                        }
                    }
                }
                break;
        }

        return $values;
    }

    /**
     * @param $errorLang
     */
    public function setErrorLang($errorLang)
    {
        $this->errorLang = $errorLang;
    }

    /**
     * Узнаём путь до файла
     * Если передана ссылка, то скачиваем и кладём во временную директорию.
     *
     * @param string $fileName
     *
     * @throws Exception
     *
     * @return string
     */
    protected function getFilePath($fileName)
    {
        if (strpos($fileName, 'http://') !== false || strpos($fileName, 'https://') !== false) {
            try {
                $current = file_get_contents($fileName);
            } catch (\Exception $e) {
                throw new DeCaptchaErrors(DeCaptchaErrors::ERROR_FILE_IS_NOT_LOADED, $fileName, $this->errorLang);
            }
            $path = tempnam(sys_get_temp_dir(), 'captcha');
            file_put_contents($path, $current);

            return $path;
        }
        if (file_exists($fileName)) {
            return $fileName;
        }
        throw new DeCaptchaErrors(DeCaptchaErrors::ERROR_FILE_NOT_FOUND, $fileName, $this->errorLang);
    }

    /**
     * @param $action
     *
     * @return string
     */
    protected function getActionUrl($action)
    {
        return $this->getBaseUrl().$this->actions[$action][static::ACTION_URI];
    }

    /**
     * @return string
     */
    protected function getBaseUrl()
    {
        return "{$this->scheme}://{$this->host}/";
    }

    /**
     * @param $params
     */
    public function setParams($params)
    {
        if (is_array($params)) {
            foreach ($params as $param => $value) {
                $this->params[$param] = $value;
            }
        }
    }

    /**
     * @param $param
     * @param $value
     */
    public function setParam($param, $value)
    {
        $this->params[$param] = $value;
    }

    /**
     * @param $param
     * @param $spec
     * @param $coding
     *
     * @return \CURLFile|mixed|null|string
     */
    public function getParamSpec($param, $spec = null, $coding = null)
    {
        if (is_null($spec)) {
            $spec = $param;
        }
        if (!array_key_exists($param, $this->params) || is_null($this->params[$param])) {
            if (!array_key_exists($spec, $this->params) || is_null($this->params[$spec])) {
                return null;
            }
            $param = $spec;
        }
        switch ($spec) {
            case static::PARAM_SPEC_FILE:
                switch ($coding) {
                    case static::PARAM_SLUG_CODING_BASE64:
                        return base64_encode(file_get_contents($this->params[$param]));
                }

                return (version_compare(PHP_VERSION, '5.5.0') >= 0) ? new \CURLFile($this->getFilePath($this->params[$param])) : '@'.$this->getFilePath($this->params[$param]);
            case static::PARAM_SPEC_API_KEY:
                return is_callable($this->params[$param]) ? $this->params[$param]() : $this->params[$param];
            case static::PARAM_SPEC_CAPTCHA:
                return (int) $this->params[$param];
            case static::PARAM_SPEC_CODE:
                return (string) $this->params[$param];
        }

        return null;
    }

    /**
     * @param $action
     * @param $field
     *
     * @throws DeCaptchaErrors
     *
     * @return array
     */
    protected function getParams($action, $field = null)
    {
        if (empty($this->actions[$action])) {
            return [];
        }
        $fields = $this->actions[$action][static::ACTION_FIELDS];
        if (!is_null($field)) {
            $fields = $fields[$field][static::ACTION_FIELDS];
        }
        $params = [];
        foreach ($fields as $field => $settings) {
            $value = null;
            if (array_key_exists(self::PARAM_SLUG_DEFAULT, $settings)) {
                $value = $settings[self::PARAM_SLUG_DEFAULT];
            }
            if (array_key_exists($field, $this->params) && (!array_key_exists(self::PARAM_SLUG_VARIABLE, $settings) ^ (array_key_exists(self::PARAM_SLUG_VARIABLE, $settings) && $settings[self::PARAM_SLUG_VARIABLE] === false))) {
                $value = $this->params[$field];
            }
            if (array_key_exists(self::PARAM_SLUG_SPEC, $settings) && array_key_exists($settings[self::PARAM_SLUG_SPEC], $this->params)) {
                $value = $this->getParamSpec($field, $settings[self::PARAM_SLUG_SPEC], array_key_exists(self::PARAM_SLUG_CODING, $settings) ? $settings[self::PARAM_SLUG_CODING] : null);
            }
            if (is_null($value)) {
                if (array_key_exists(self::PARAM_SLUG_REQUIRE, $settings) && $settings[self::PARAM_SLUG_REQUIRE] === true) {
                    throw new DeCaptchaErrors(DeCaptchaErrors::ERROR_PARAM_REQUIRE, array_key_exists($field, $this->paramsNames) ? $this->paramsNames[$field] : $field, $this->errorLang);
                }
                continue;
            }
            if (array_key_exists($field, $this->paramsNames)) {
                switch ($settings[self::PARAM_SLUG_TYPE]) {
                    case self::PARAM_FIELD_TYPE_INTEGER:
                        $value = (int) $value;
                        break;
                    case self::PARAM_FIELD_TYPE_STRING:
                        $value = (string) $value;
                        break;
                    case self::PARAM_FIELD_TYPE_BOOLEAN:
                        $value = (bool) $value;
                        break;
                    case self::PARAM_FIELD_TYPE_OBJECT:
                        $value = $this->getParams($action, $field);
                        break;
                }
                if (array_key_exists(self::PARAM_SLUG_ENUM, $settings) && !in_array($value, $settings[static::PARAM_SLUG_ENUM])) {
                    throw new DeCaptchaErrors(DeCaptchaErrors::ERROR_PARAM_ENUM, (array_key_exists($field, $this->paramsNames) ? $this->paramsNames[$field] : $field).' = '.$value, $this->errorLang);
                }
                $params[$this->paramsNames[$field]] = $value;
            }
        }

        return $params;
    }

    /**
     * @param string $action
     *
     * @return string
     */
    protected function getResponse($action)
    {
        return $this->sendRequest(
            $this->actions[$action][static::ACTION_METHOD],
            $this->getActionUrl($action),
            $this->getParams($action),
            array_key_exists(static::ACTION_JSON, $this->actions[$action]) && $this->actions[$action][static::ACTION_JSON] === true
        );
    }

    /**
     * Задержка выполнения.
     *
     * @param int           $delay    Количество секунд
     * @param \Closure|null $callback
     *
     * @return mixed
     */
    protected function executionDelayed($delay = 0, $callback = null)
    {
        $time = microtime(true);
        $timePassed = $time - $this->lastRunTime;
        if ($timePassed < $delay) {
            usleep(($delay - $timePassed) * 1000000);
        }
        $this->lastRunTime = microtime(true);

        return $callback instanceof \Closure ? $callback($this) : $callback;
    }

    /**
     * @param string       $method Request method
     * @param string       $url    Request URL
     * @param array|string $data   Request payload
     * @param bool         $isJson Whether request payload should be serialized as JSON
     *
     * @throws \InvalidArgumentException Invalid arguments combination
     *
     * @return string
     */
    protected function sendRequest($method, $url, $data, $isJson = false)
    {
        $client = new Client([
            'timeout'         => 30,
            'connect_timeout' => 30,
            'headers'         => [
                'Accept-Encoding' => 'gzip,deflate',
                'User-Agent'      => 'DeCaptcha',
            ],
        ]);

        if ($method === static::ACTION_METHOD_GET && $isJson) {
            throw new \InvalidArgumentException('JSON encoding with GET requests is not supported.');
        }

        $options = [];

        $encType = $isJson ? 'json' : 'query';
        $options[$encType] = $data;

        $response = $client->request($method, $url, $options);

        $body = $response->getBody();

        return (string) $body;
    }

    abstract public function getCode();

    abstract public function getError();
}


1		<?php
2
3		namespace jumper423\decaptcha\core;
4
5		use Exception;
6		use GuzzleHttp\Client;
7
8		/**
9		* Class DeCaptchaAbstract.
10		*/
11		abstract class DeCaptchaAbstract implements DeCaptchaInterface
12		{
13		const RESPONSE_TYPE_STRING = 1;
14		const RESPONSE_TYPE_JSON = 2;
15
16		const ACTION_FIELDS = 1;
17		const ACTION_URI = 2;
18		const ACTION_METHOD = 3;
19		const ACTION_JSON = 4;
20
21		const ACTION_METHOD_POST = 'post';
22		const ACTION_METHOD_GET = 'get';
23
24		const DECODE_FORMAT = 1;
25		const DECODE_ACTION = 2;
26		const DECODE_SEPARATOR = 3;
27		const DECODE_PARAMS = 4;
28		const DECODE_PARAM_SETTING_MARKER = 5;
29
30		const PARAM_FIELD_TYPE_STRING = 1;
31		const PARAM_FIELD_TYPE_INTEGER = 2;
32		const PARAM_FIELD_TYPE_MIX = 3;
33		const PARAM_FIELD_TYPE_OBJECT = 4;
34		const PARAM_FIELD_TYPE_BOOLEAN = 5;
35
36		const PARAM_SLUG_DEFAULT = 1;
37		const PARAM_SLUG_TYPE = 2;
38		const PARAM_SLUG_REQUIRE = 3;
39		const PARAM_SLUG_SPEC = 4;
40		const PARAM_SLUG_VARIABLE = 5;
41		const PARAM_SLUG_CODING = 6;
42		const PARAM_SLUG_NOTWIKI = 7;
43		const PARAM_SLUG_ENUM = 8;
44		const PARAM_SLUG_WIKI = 9;
45
46		const PARAM_SLUG_CODING_BASE64 = 1;
47
48		const PARAM_SPEC_API_KEY = -1;
49		const PARAM_SPEC_FILE = -2;
50		const PARAM_SPEC_CAPTCHA = -3;
51		const PARAM_SPEC_CODE = -4;
52
53		/**
54		* Сервис на который будем загружать капчу.
55		*
56		* @var string
57		*/
58		protected $host;
59		protected $scheme = 'http';
60		protected $errorLang = DeCaptchaErrors::LANG_EN;
61		protected $lastRunTime = null;
62		/** @var DeCaptchaErrors */
63		protected $errorObject;
64		protected $causeAnError = false;
65
66		protected $limit = [];
67		protected $paramsSpec = [];
68		protected $params = [];
69		protected $limitSettings = [];
70		protected $decodeSettings = [];
71		protected $actions = [];
72		protected $paramsNames = [];
73
74		protected function resetLimits()
75		{
76		foreach ($this->limitSettings as $action => $value) {
77		$this->limit[$action] = $value;
78		}
79		}
80
81		/**
82		* @param $action
83		*
84		* @return bool
85		*/
86		protected function limitHasNotYetEnded($action)
87		{
88		return $this->limit[$action]-- > 0;
89		}
90
91		/**
92	3	* @param $action
93		* @param $data
94	3	*
95	1	* @throws DeCaptchaErrors
96	1	*
97	3	* @return array
98		*/
99	3	protected function decodeResponse($action, $data)
100		{
101		if (!array_key_exists($action, $this->decodeSettings[static::DECODE_ACTION])) {
102		throw new DeCaptchaErrors('нет action');
103		}
104		$decodeSetting = $this->decodeSettings[static::DECODE_ACTION][$action];
105		$decodeFormat = array_key_exists(static::DECODE_FORMAT, $decodeSetting) ?
106		$decodeSetting[static::DECODE_FORMAT] :
107		$this->decodeSettings[static::DECODE_FORMAT];
108		$values = [];
109		switch ($decodeFormat) {
110		case static::RESPONSE_TYPE_STRING:
111		foreach (explode($decodeSetting[static::DECODE_SEPARATOR], $data) as $key => $value) {
112		foreach ($decodeSetting[static::DECODE_PARAMS] as $param => $paramSetting) {
113		if ($key === $paramSetting[static::DECODE_PARAM_SETTING_MARKER]) {
114	3	$values[$param] = $value;
115	3	}
116	2	}
117	2	}
118	1	break;
119	1	case static::RESPONSE_TYPE_JSON:
120	1	foreach (json_decode($data, true) as $key => $value) {
121	1	foreach ($decodeSetting[static::DECODE_PARAMS] as $param => $paramSetting) {
122		if (count(explode('.', $paramSetting[static::DECODE_PARAM_SETTING_MARKER])) > 1) {
123		if ($key === explode('.', $paramSetting[static::DECODE_PARAM_SETTING_MARKER])[0]) {
124	1	if (array_key_exists(explode('.', $paramSetting[static::DECODE_PARAM_SETTING_MARKER])[1], $value)) {
125	1	$values[$param] = $value[explode('.', $paramSetting[static::DECODE_PARAM_SETTING_MARKER])[1]];
126		}
127	2	}
128	1	}
129		if ($key === $paramSetting[static::DECODE_PARAM_SETTING_MARKER]) {
130	1	$values[$param] = $value;
131		}
132		}
133		}
134		break;
135		}
136	4
137	4	return $values;
138		}
139
140		/**
141		* @param $errorLang
142		*/
143		public function setErrorLang($errorLang)
144	2	{
145	2	$this->errorLang = $errorLang;
146		}
147
148		/**
149		* Узнаём путь до файла
150		* Если передана ссылка, то скачиваем и кладём во временную директорию.
151		*
152	1	* @param string $fileName
153	1	*
154		* @throws Exception
155		*
156		* @return string
157		*/
158		protected function getFilePath($fileName)
159	1	{
160	1	if (strpos($fileName, 'http://') !== false \|\| strpos($fileName, 'https://') !== false) {
161		try {
162		$current = file_get_contents($fileName);
163		} catch (\Exception $e) {
164		throw new DeCaptchaErrors(DeCaptchaErrors::ERROR_FILE_IS_NOT_LOADED, $fileName, $this->errorLang);
165		}
166		$path = tempnam(sys_get_temp_dir(), 'captcha');
167		file_put_contents($path, $current);
168
169	2	return $path;
170		}
171	2	if (file_exists($fileName)) {
172	1	return $fileName;
173		}
174	1	throw new DeCaptchaErrors(DeCaptchaErrors::ERROR_FILE_NOT_FOUND, $fileName, $this->errorLang);
175		}
176
177		/**
178		* @param $action
179		*
180		* @return string
181		*/
182		protected function getActionUrl($action)
183		{
184		return $this->getBaseUrl().$this->actions[$action][static::ACTION_URI];
185	1	}
186	1
187	1	/**
188	1	* @return string
189	1	*/
190	1	protected function getBaseUrl()
191	1	{
192	1	return "{$this->scheme}://{$this->host}/";
193		}
194
195		/**
196		* @param $params
197		*/
198		public function setParams($params)
199		{
200		if (is_array($params)) {
201		foreach ($params as $param => $value) {
202		$this->params[$param] = $value;
203		}
204		}
205		}
206
207		/**
208		* @param $param
209		* @param $value
210		*/
211		public function setParam($param, $value)
212		{
213		$this->params[$param] = $value;
214		}
215
216		/**
217		* @param $param
218		* @param $spec
219		* @param $coding
220		*
221		* @return \CURLFile\|mixed\|null\|string
222		*/
223		public function getParamSpec($param, $spec = null, $coding = null)
224		{
225		if (is_null($spec)) {
226		$spec = $param;
227		}
228		if (!array_key_exists($param, $this->params) \|\| is_null($this->params[$param])) {
229		if (!array_key_exists($spec, $this->params) \|\| is_null($this->params[$spec])) {
230		return null;
231		}
232		$param = $spec;
233		}
234		switch ($spec) {
235		case static::PARAM_SPEC_FILE:
236		switch ($coding) {
237		case static::PARAM_SLUG_CODING_BASE64:
238		return base64_encode(file_get_contents($this->params[$param]));
239		}
240
241		return (version_compare(PHP_VERSION, '5.5.0') >= 0) ? new \CURLFile($this->getFilePath($this->params[$param])) : '@'.$this->getFilePath($this->params[$param]);
242		case static::PARAM_SPEC_API_KEY:
243		return is_callable($this->params[$param]) ? $this->params[$param]() : $this->params[$param];
244		case static::PARAM_SPEC_CAPTCHA:
245		return (int) $this->params[$param];
246		case static::PARAM_SPEC_CODE:
247		return (string) $this->params[$param];
248		}
249
250		return null;
251		}
252
253		/**
254		* @param $action
255		* @param $field
256		*
257		* @throws DeCaptchaErrors
258		*
259		* @return array
260		*/
261		protected function getParams($action, $field = null)
262		{
263		if (empty($this->actions[$action])) {
264		return [];
265		}
266		$fields = $this->actions[$action][static::ACTION_FIELDS];
267		if (!is_null($field)) {
268		$fields = $fields[$field][static::ACTION_FIELDS];
269		}
270		$params = [];
271		foreach ($fields as $field => $settings) {
272		$value = null;
273		if (array_key_exists(self::PARAM_SLUG_DEFAULT, $settings)) {
274		$value = $settings[self::PARAM_SLUG_DEFAULT];
275		}
276		if (array_key_exists($field, $this->params) && (!array_key_exists(self::PARAM_SLUG_VARIABLE, $settings) ^ (array_key_exists(self::PARAM_SLUG_VARIABLE, $settings) && $settings[self::PARAM_SLUG_VARIABLE] === false))) {
277		$value = $this->params[$field];
278		}
279		if (array_key_exists(self::PARAM_SLUG_SPEC, $settings) && array_key_exists($settings[self::PARAM_SLUG_SPEC], $this->params)) {
280		$value = $this->getParamSpec($field, $settings[self::PARAM_SLUG_SPEC], array_key_exists(self::PARAM_SLUG_CODING, $settings) ? $settings[self::PARAM_SLUG_CODING] : null);
281		}
282		if (is_null($value)) {
283		if (array_key_exists(self::PARAM_SLUG_REQUIRE, $settings) && $settings[self::PARAM_SLUG_REQUIRE] === true) {
284		throw new DeCaptchaErrors(DeCaptchaErrors::ERROR_PARAM_REQUIRE, array_key_exists($field, $this->paramsNames) ? $this->paramsNames[$field] : $field, $this->errorLang);
285		}
286		continue;
287		}
288		if (array_key_exists($field, $this->paramsNames)) {
289		switch ($settings[self::PARAM_SLUG_TYPE]) {
290		case self::PARAM_FIELD_TYPE_INTEGER:
291		$value = (int) $value;
292		break;
293		case self::PARAM_FIELD_TYPE_STRING:
294		$value = (string) $value;
295		break;
296		case self::PARAM_FIELD_TYPE_BOOLEAN:
297		$value = (bool) $value;
298		break;
299		case self::PARAM_FIELD_TYPE_OBJECT:
300		$value = $this->getParams($action, $field);
301		break;
302		}
303		if (array_key_exists(self::PARAM_SLUG_ENUM, $settings) && !in_array($value, $settings[static::PARAM_SLUG_ENUM])) {
304		throw new DeCaptchaErrors(DeCaptchaErrors::ERROR_PARAM_ENUM, (array_key_exists($field, $this->paramsNames) ? $this->paramsNames[$field] : $field).' = '.$value, $this->errorLang);
305		}
306		$params[$this->paramsNames[$field]] = $value;
307		}
308		}
309
310		return $params;
311		}
312
313		/**
314		* @param string $action
315		*
316		* @return string
317		*/
318		protected function getResponse($action)
319		{
320		return $this->sendRequest(
321		$this->actions[$action][static::ACTION_METHOD],
322		$this->getActionUrl($action),
323		$this->getParams($action),
324		array_key_exists(static::ACTION_JSON, $this->actions[$action]) && $this->actions[$action][static::ACTION_JSON] === true
325		);
326		}
327
328		/**
329		* Задержка выполнения.
330		*
331		* @param int $delay Количество секунд
332		* @param \Closure\|null $callback
333		*
334		* @return mixed
335		*/
336		protected function executionDelayed($delay = 0, $callback = null)
337		{
338		$time = microtime(true);
339		$timePassed = $time - $this->lastRunTime;
340		if ($timePassed < $delay) {
341		usleep(($delay - $timePassed) * 1000000);
342		}
343		$this->lastRunTime = microtime(true);
344
345		return $callback instanceof \Closure ? $callback($this) : $callback;
346		}
347
348		/**
349		* @param string $method Request method
350		* @param string $url Request URL
351		* @param array\|string $data Request payload
352		* @param bool $isJson Whether request payload should be serialized as JSON
353		*
354		* @throws \InvalidArgumentException Invalid arguments combination
355		*
356		* @return string
357		*/
358		protected function sendRequest($method, $url, $data, $isJson = false)
359		{
360		$client = new Client([
361		'timeout' => 30,
362		'connect_timeout' => 30,
363		'headers' => [
364		'Accept-Encoding' => 'gzip,deflate',
365		'User-Agent' => 'DeCaptcha',
366		],
367		]);
368
369		if ($method === static::ACTION_METHOD_GET && $isJson) {
370		throw new \InvalidArgumentException('JSON encoding with GET requests is not supported.');
371		}
372
373		$options = [];
374
375		$encType = $isJson ? 'json' : 'query';
376		$options[$encType] = $data;
377
378		$response = $client->request($method, $url, $options);
379
380		$body = $response->getBody();
381
382		return (string) $body;
383		}
384
385		abstract public function getCode();
386
387		abstract public function getError();
388		}
389

jumper423 / decaptcha

Pull Request — master (#8)

DeCaptchaAbstract::decodeResponse() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like