Rucaptcha\GenericClient

Complexity

Total Complexity

25

Size/Duplication

Total Lines	244
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	13

Test Coverage

Coverage

66.67%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getLastCaptchaId()	0	4	1
A	setHttpClient()	0	6	1
A	setVerbose()	0	7	1
A	recognizeFile()	0	16	3
A	recognize()	0	25	4
A	sendCaptcha()	0	28	3
A	getCaptchaResult()	0	21	4
A	getErrorMessage()	0	6	2
A	getHttpClient()	0	9	2
A	getLogger()	0	10	3

<?php
/**
 * @author Dmitry Gladyshev <deel@email.ru>
 */

namespace Rucaptcha;

use GuzzleHttp\Psr7\Request;
use Psr\Http\Client\ClientInterface;
use GuzzleHttp\RequestOptions;
use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerAwareTrait;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
use Rucaptcha\Exception\ErrorResponseException;
use Rucaptcha\Exception\InvalidArgumentException;
use Rucaptcha\Exception\RuntimeException;
use SplFileObject;
use Throwable;

class GenericClient implements LoggerAwareInterface
{
    use LoggerAwareTrait;
    use ConfigurableTrait;

    /* Statuses */
    const STATUS_OK = 'OK';
    const STATUS_CAPTCHA_NOT_READY = 'CAPCHA_NOT_READY';

    /**
     * @var string
     */
    protected $lastCaptchaId = '';

    /**
     * @var string
     */
    protected $serverBaseUri = '';

    /**
     * @var bool
     */
    protected $verbose = false;

    /**
     * @var string
     */
    protected $apiKey = '';

    /**
     * @var int
     */
    protected $rTimeout = 5;

    /**
     * @var int
     */
    protected $mTimeout = 120;

    /**
     * @var ClientInterface
     */
    private $httpClient = null;

    /**
     * @param array $options
     * @param string $apiKey
     * @throws InvalidArgumentException
     */
    public function __construct($apiKey, array $options = [])
    {
        $this->apiKey = $apiKey;
        $this->setOptions($options);
    }

    /**
     * @return string   # Last successfully sent captcha task ID
     */
    public function getLastCaptchaId()
    {
        return $this->lastCaptchaId;
    }

    /**
     * @param ClientInterface $client
     * @return $this
     */
    public function setHttpClient(ClientInterface $client)
    {
        $this->httpClient = $client;

        return $this;
    }

    /**
     * @param bool $verbose
     * @return $this
     */
    public function setVerbose($verbose)
    {
        $this->logger = null;
        $this->verbose = $verbose;

        return $this;
    }

    /**
     * @param string $path
     * @param array $extra
     * @return string
     * @throws InvalidArgumentException
     * @throws RuntimeException
     * @throws \GuzzleHttp\Exception\GuzzleException
     */
    public function recognizeFile($path, array $extra = [])
    {
        if (!file_exists($path)) {
            throw new InvalidArgumentException("Captcha file `$path` not found.");
        }

        $file = new SplFileObject($path, 'r');

        $content = '';

        while (!$file->eof()) {
            $content .= $file->fgets();
        }

        return $this->recognize($content, $extra);
    }

    /**
     * @param string $content
     * @param array $extra
     * @return string
     * @throws RuntimeException
     * @throws \GuzzleHttp\Exception\GuzzleException
     */
    public function recognize($content, array $extra = [])
    {
        $captchaId = $this->sendCaptcha($content, $extra);
        $startTime = time();

        while (true) {
            $this->getLogger()->info("Waiting {$this->rTimeout} sec.");

            sleep($this->rTimeout);

            if (time() - $startTime >= $this->mTimeout) {
                throw new RuntimeException("Captcha waiting timeout.");
            }

            $result = $this->getCaptchaResult($captchaId);

            if ($result === false) {
                continue;
            }

            $this->getLogger()->info("Elapsed " . (time()-$startTime) . " second(s).");

            return $result;
        }
    }

    /**
     * @param string $content       # Captcha image content
     * @param array $extra          # Array of recognition options
     * @return string               # Captcha task ID
     * @throws Throwable
     */
    public function sendCaptcha($content, array $extra = [])
    {
        $this->getLogger()->info("Try send captcha image on {$this->serverBaseUri}/in.php");

        $headers = [
            'Content-Type' => 'application/x-www-form-urlencoded'
        ];

        $body = http_build_query(array_merge($extra, [
            'method' => 'base64',
            'key' => $this->apiKey,
            'body' => base64_encode($content)
        ]));

        $request = new Request('POST', '/in.php', $headers, $body);

        $response = $this->getHttpClient()->sendRequest($request);

        $responseText = $response->getBody()->getContents();

        if (mb_strpos($responseText, 'OK|') !== false) {
            $this->lastCaptchaId = explode("|", $responseText)[1];
            $this->getLogger()->info("Sending success. Got captcha id `{$this->lastCaptchaId}`.");
            return $this->lastCaptchaId;
        }

        throw new ErrorResponseException($this->getErrorMessage($responseText) ?: "Unknown error: `{$responseText}`.");
    }

    /**
     * @param string $captchaId     # Captcha task ID
     * @return string|false         # Solved captcha text or false if captcha is not ready
     * @throws Throwable
     */
    public function getCaptchaResult($captchaId)
    {
        $request = new \GuzzleHttp\Psr7\Request('GET', "/res.php?key={$this->apiKey}&action=get&id={$captchaId}");

        $response = $this
            ->getHttpClient()
            ->sendRequest($request);

        $responseText = $response->getBody()->getContents();

        if ($responseText === self::STATUS_CAPTCHA_NOT_READY) {
            return false;
        }

        if (mb_strpos($responseText, 'OK|') !== false) {
            $this->getLogger()->info("Got OK response: `{$responseText}`.");
            return html_entity_decode(trim(explode('|', $responseText)[1]));
        }

        throw new ErrorResponseException($this->getErrorMessage($responseText) ?: $responseText);
    }

    /**
     * @param string $responseText  # Server response text usually begin with `ERROR_` prefix
     * @return false|string         # Error message text or false if associated message in not found
     */
    protected function getErrorMessage($responseText)
    {
        return isset(Error::$messages[$responseText])
            ? Error::$messages[$responseText]
            : false;
    }

    /**
     * @return ClientInterface
     */
    protected function getHttpClient()
    {
        if ($this->httpClient === null) {
            $this->httpClient = new \GuzzleHttp\Client([
                'base_uri' => $this->serverBaseUri
            ]);
        }
        return $this->httpClient;
    }

    /**
     * @return LoggerInterface
     */
    public function getLogger()
    {
        if ($this->logger === null) {
            $defaultLogger = $this->verbose
                ? new Logger
                : new NullLogger;
            $this->setLogger($defaultLogger);
        }
        return $this->logger;
    }
}