jumper423\decaptcha\core\DeCaptchaBase

Complexity

Total Complexity

27

Size/Duplication

Total Lines	318
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	4
Bugs	2	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	resetLimits()	0	6	2
A	limitHasNotYetEnded()	0	4	1
A	recognize()	0	11	3
B	requestRecognize()	0	18	5
B	requestCode()	0	17	5
A	getCode()	0	3	1
A	getError()	0	3	1
A	run()	0	4	1
A	notTrue()	0	4	1
C	decodeResponse()	0	24	7

<?php

namespace jumper423\decaptcha\core;

/**
 * Распознавание капчи.
 *
 * Class DeCaptchaBase
 */
class DeCaptchaBase extends DeCaptchaAbstract implements DeCaptchaInterface
{
    const PARAM_FIELD_METHOD = 0;
    const PARAM_FIELD_KEY = 1;
    const PARAM_FIELD_FILE = 2;
    const PARAM_FIELD_PHRASE = 3;
    const PARAM_FIELD_REGSENSE = 4;
    const PARAM_FIELD_NUMERIC = 5;
    const PARAM_FIELD_MIN_LEN = 6;
    const PARAM_FIELD_MAX_LEN = 7;
    const PARAM_FIELD_LANGUAGE = 8;
    const PARAM_FIELD_SOFT_ID = 9;
    const PARAM_FIELD_CAPTCHA_ID = 10;
    const PARAM_FIELD_ACTION = 11;
    const PARAM_FIELD_QUESTION = 12;
    const PARAM_FIELD_CALC = 13;
    const PARAM_FIELD_HEADER_ACAO = 14;
    const PARAM_FIELD_TEXTINSTRUCTIONS = 15;
    const PARAM_FIELD_PINGBACK = 16;

    const ACTION_RECOGNIZE = 0;
    const ACTION_UNIVERSAL = 1;
    const ACTION_UNIVERSAL_WITH_CAPTCHA = 2;

    protected $paramsNames = [
        self::PARAM_FIELD_METHOD               => 'method',
        self::PARAM_FIELD_KEY                  => 'key',
        self::PARAM_FIELD_FILE                 => 'file',
        self::PARAM_FIELD_PHRASE               => 'phrase',
        self::PARAM_FIELD_REGSENSE             => 'regsense',
        self::PARAM_FIELD_NUMERIC              => 'numeric',
        self::PARAM_FIELD_MIN_LEN              => 'min_len',
        self::PARAM_FIELD_MAX_LEN              => 'max_len',
        self::PARAM_FIELD_LANGUAGE             => 'language',
        self::PARAM_FIELD_SOFT_ID              => 'soft_id',
        self::PARAM_FIELD_CAPTCHA_ID           => 'id',
        self::PARAM_FIELD_ACTION               => 'action',
        self::PARAM_FIELD_QUESTION             => 'question',
        self::PARAM_FIELD_HEADER_ACAO          => 'header_acao',
        self::PARAM_FIELD_TEXTINSTRUCTIONS     => 'textinstructions',
        self::PARAM_FIELD_PINGBACK             => 'pingback',
    ];

    protected $paramsSettings = [
        self::ACTION_RECOGNIZE => [
            self::PARAM_FIELD_METHOD => [
                self::PARAM_SLUG_DEFAULT => 'post',
                self::PARAM_SLUG_TYPE    => self::PARAM_FIELD_TYPE_STRING,
            ],
            self::PARAM_FIELD_KEY => [
                self::PARAM_SLUG_REQUIRE => true,
                self::PARAM_SLUG_SPEC    => self::PARAM_SPEC_KEY,
                self::PARAM_SLUG_TYPE    => self::PARAM_FIELD_TYPE_STRING,
            ],
            self::PARAM_FIELD_FILE => [
                self::PARAM_SLUG_REQUIRE => true,
                self::PARAM_SLUG_SPEC    => self::PARAM_SPEC_FILE,
                self::PARAM_SLUG_TYPE    => self::PARAM_FIELD_TYPE_STRING,
            ],
            self::PARAM_FIELD_PHRASE => [
                self::PARAM_SLUG_DEFAULT => 0,
                self::PARAM_SLUG_TYPE    => self::PARAM_FIELD_TYPE_INTEGER,
            ],
            self::PARAM_FIELD_REGSENSE => [
                self::PARAM_SLUG_DEFAULT => 0,
                self::PARAM_SLUG_TYPE    => self::PARAM_FIELD_TYPE_INTEGER,
            ],
            self::PARAM_FIELD_NUMERIC => [
                self::PARAM_SLUG_DEFAULT => 0,
                self::PARAM_SLUG_TYPE    => self::PARAM_FIELD_TYPE_INTEGER,
            ],
            self::PARAM_FIELD_MIN_LEN => [
                self::PARAM_SLUG_DEFAULT => 0,
                self::PARAM_SLUG_TYPE    => self::PARAM_FIELD_TYPE_INTEGER,
            ],
            self::PARAM_FIELD_MAX_LEN => [
                self::PARAM_SLUG_DEFAULT => 0,
                self::PARAM_SLUG_TYPE    => self::PARAM_FIELD_TYPE_INTEGER,
            ],
            self::PARAM_FIELD_LANGUAGE => [
                self::PARAM_SLUG_DEFAULT => 0,
                self::PARAM_SLUG_TYPE    => self::PARAM_FIELD_TYPE_INTEGER,
            ],
            self::PARAM_FIELD_QUESTION => [
                self::PARAM_SLUG_DEFAULT => 0,
                self::PARAM_SLUG_TYPE    => self::PARAM_FIELD_TYPE_INTEGER,
            ],
            self::PARAM_FIELD_CALC => [
                self::PARAM_SLUG_DEFAULT => 0,
                self::PARAM_SLUG_TYPE    => self::PARAM_FIELD_TYPE_INTEGER,
            ],
            self::PARAM_FIELD_HEADER_ACAO => [
                self::PARAM_SLUG_DEFAULT => 0,
                self::PARAM_SLUG_TYPE    => self::PARAM_FIELD_TYPE_INTEGER,
            ],
            self::PARAM_FIELD_TEXTINSTRUCTIONS => [
                self::PARAM_SLUG_TYPE    => self::PARAM_FIELD_TYPE_STRING,
            ],
            self::PARAM_FIELD_PINGBACK => [
                self::PARAM_SLUG_TYPE    => self::PARAM_FIELD_TYPE_STRING,
            ],
            self::PARAM_FIELD_SOFT_ID => [
                self::PARAM_SLUG_VARIABLE => false,
                self::PARAM_SLUG_TYPE     => self::PARAM_FIELD_TYPE_INTEGER,
            ],
        ],
        self::ACTION_UNIVERSAL => [
            self::PARAM_FIELD_KEY => [
                self::PARAM_SLUG_REQUIRE => true,
                self::PARAM_SLUG_SPEC    => self::PARAM_SPEC_KEY,
                self::PARAM_SLUG_TYPE    => self::PARAM_FIELD_TYPE_STRING,
            ],
            self::PARAM_FIELD_ACTION => [
                self::PARAM_SLUG_REQUIRE => true,
                self::PARAM_SLUG_TYPE    => self::PARAM_FIELD_TYPE_STRING,
            ],
            self::PARAM_FIELD_HEADER_ACAO => [
                self::PARAM_SLUG_DEFAULT => 0,
                self::PARAM_SLUG_TYPE    => self::PARAM_FIELD_TYPE_INTEGER,
            ],
        ],
        self::ACTION_UNIVERSAL_WITH_CAPTCHA => [
            self::PARAM_FIELD_KEY => [
                self::PARAM_SLUG_REQUIRE => true,
                self::PARAM_SLUG_SPEC    => self::PARAM_SPEC_KEY,
                self::PARAM_SLUG_TYPE    => self::PARAM_FIELD_TYPE_STRING,
            ],
            self::PARAM_FIELD_CAPTCHA_ID => [
                self::PARAM_SLUG_REQUIRE => true,
                self::PARAM_SLUG_SPEC    => self::PARAM_SPEC_CAPTCHA,
                self::PARAM_SLUG_TYPE    => self::PARAM_FIELD_TYPE_INTEGER,
            ],
            self::PARAM_FIELD_ACTION => [
                self::PARAM_SLUG_REQUIRE => true,
                self::PARAM_SLUG_TYPE    => self::PARAM_FIELD_TYPE_STRING,
            ],
            self::PARAM_FIELD_HEADER_ACAO => [
                self::PARAM_SLUG_DEFAULT => 0,
                self::PARAM_SLUG_TYPE    => self::PARAM_FIELD_TYPE_INTEGER,
            ],
        ],
    ];

    protected $code;

    protected $limitSettings = [
        self::ACTION_RECOGNIZE              => 3,
        self::ACTION_UNIVERSAL_WITH_CAPTCHA => 20,
    ];

    protected $limit = [];

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

    protected function limitHasNotYetEnded($action)
    {
        return $this->limit[$action]-- > 0;
    }

    const RESPONSE_RECOGNIZE_OK = 'OK';
    const RESPONSE_RECOGNIZE_REPEAT = 'ERROR_NO_SLOT_AVAILABLE';
    const RESPONSE_GET_OK = 'OK';
    const RESPONSE_GET_REPEAT = 'CAPCHA_NOT_READY';

    const SLEEP_RECOGNIZE = 5;
    const SLEEP_GET = 2;
    const SLEEP_BETWEEN = 5;

    public function recognize($filePath)
    {
        try {
            $this->resetLimits();
            $this->setParamSpec(static::PARAM_SPEC_FILE, $this->getFilePath($filePath));
            return $this->requestRecognize() && $this->requestCode();
        } catch (DeCaptchaErrors $e) {
            $this->error = $e->getMessage();

The property error does not exist. Did you maybe forget to declare it?

            return false;
        }
    }

    protected function requestRecognize()
    {
        while ($this->limitHasNotYetEnded(static::ACTION_RECOGNIZE)) {
            $this->executionDelayed(static::SLEEP_RECOGNIZE);
            $response = $this->getCurlResponse($this->getInUrl(), $this->getParams(static::ACTION_RECOGNIZE));
            $dataRecognize = $this->decodeResponse(static::DECODE_ACTION_RECOGNIZE, $response);
            if ($dataRecognize[static::DECODE_PARAM_RESPONSE] === static::RESPONSE_RECOGNIZE_OK && !empty($dataRecognize[static::DECODE_PARAM_CAPTCHA])) {
                $this->setParamSpec(static::PARAM_SPEC_CAPTCHA, $dataRecognize[static::DECODE_PARAM_CAPTCHA]);
                $this->executionDelayed(static::SLEEP_BETWEEN);

                return true;
            } elseif ($dataRecognize[static::DECODE_PARAM_RESPONSE] === static::RESPONSE_RECOGNIZE_REPEAT) {
                continue;
            }
            throw new DeCaptchaErrors($dataRecognize[static::DECODE_PARAM_RESPONSE]);
        }
        throw new DeCaptchaErrors(DeCaptchaErrors::ERROR_LIMIT);
    }

    protected function requestCode()
    {
        while ($this->limitHasNotYetEnded(static::ACTION_UNIVERSAL_WITH_CAPTCHA)) {
            $this->executionDelayed(static::SLEEP_GET);
            $response = $this->getResponse(static::ACTION_UNIVERSAL_WITH_CAPTCHA);
            $dataGet = $this->decodeResponse(static::DECODE_ACTION_GET, $response);
            if ($dataGet[static::DECODE_PARAM_RESPONSE] === static::RESPONSE_GET_OK && !empty($dataGet[static::DECODE_PARAM_CODE])) {
                $this->code = $dataGet[static::DECODE_PARAM_CODE];

                return true;
            } elseif ($dataGet[static::DECODE_PARAM_RESPONSE] === static::RESPONSE_GET_REPEAT) {
                continue;
            }
            throw new DeCaptchaErrors($dataGet[static::DECODE_PARAM_RESPONSE]);
        }
        throw new DeCaptchaErrors(DeCaptchaErrors::ERROR_LIMIT);
    }

    public function getCode()
    {
    }

    public function getError()
    {
    }

    /**
     * Запуск распознавания капчи.
     *
     * @deprecated
     *
     * @param string $filePath Путь до файла или ссылка на него
     *
     * @return bool
     */
    public function run($filePath)
    {
        return $this->recognize($filePath);
    }

    /**
     * Не верно распознана.
     */
    public function notTrue()
    {
        $this->getResponse('reportbad');
    }

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

    const DECODE_ACTION_RECOGNIZE = 0;
    const DECODE_ACTION_GET = 1;

    const DECODE_PARAM_RESPONSE = 0;
    const DECODE_PARAM_CAPTCHA = 1;
    const DECODE_PARAM_CODE = 2;

    protected $decodeSettings = [
        self::DECODE_FORMAT => self::RESPONSE_TYPE_STRING,
        self::DECODE_ACTION => [
            self::DECODE_ACTION_RECOGNIZE => [
                self::DECODE_SEPARATOR => '|',
                self::DECODE_PARAMS    => [
                    self::DECODE_PARAM_RESPONSE => [
                        self::DECODE_PARAM_SETTING_MARKER => 0,
                    ],
                    self::DECODE_PARAM_CAPTCHA => [
                        self::DECODE_PARAM_SETTING_MARKER => 1,
                    ],
                ],
            ],
            self::DECODE_ACTION_GET => [
                self::DECODE_SEPARATOR => '|',
                self::DECODE_PARAMS    => [
                    self::DECODE_PARAM_RESPONSE => [
                        self::DECODE_PARAM_SETTING_MARKER => 0,
                    ],
                    self::DECODE_PARAM_CODE => [
                        self::DECODE_PARAM_SETTING_MARKER => 1,
                    ],
                ],
            ],
        ],
    ];

    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($decodeFormat[static::DECODE_SEPARATOR], $data) as $key => $value) {
                    foreach ($decodeFormat[static::DECODE_PARAMS] as $param => $paramKey) {
                        if ($key === $paramKey) {
                            $values[$param] = $value;
                        }
                    }
                }
                break;
        }

        return $values;
    }
}