sokolnikov911\YandexXml\Client

Complexity

Total Complexity

62

Size/Duplication

Total Lines	425
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

76.38%

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	15	3
A	lr()	0	10	2
A	l10n()	0	19	6
A	sortBy()	0	18	5
A	filter()	0	10	2
A	maxPassages()	0	10	3
B	groupBy()	0	28	10
A	page()	0	10	2
A	showMeCaptcha()	0	6	1
A	query()	0	6	1
A	action()	0	6	1
A	get()	0	6	2
A	getData()	0	24	4
A	generateSortByAttribute()	0	10	2
A	generateGroupByAttribute()	0	18	4
A	getEndpointUrlWithParams()	0	19	3
A	getActionParams()	0	6	1
C	getQueryParams()	0	17	9
A	getEndpointUrl()	0	4	1

<?php

namespace sokolnikov911\YandexXml;

use sokolnikov911\YandexXml\Exceptions\YandexException;
use sokolnikov911\YandexXml\Exceptions\YandexInvalidArgumentException;
use GuzzleHttp\Client as HttpClient;
use GuzzleHttp\Exception\ClientException;
use GuzzleHttp\Exception\GuzzleException;

class Client
{
    private $user;
    private $key;
    private $selectedLanguage;

    private $lr;
    private $l10n;
    private $sortByType;
    private $sortByDirection;
    private $filter;
    private $maxPassages;
    private $groupByMode;
    private $groupByGroupsOnPage;
    private $groupByDocsInGroup;
    private $page;
    private $showMeCaptcha;
    private $action;
    private $query;

    private $url = 'https://yandex.{lang}/search/xml';

    const AVAILABLE_REGIONS = [
        '225', '187', '149', '159', '20', '1092', '37', '30', '197', '47', '4', '65', '77', '66', '191', '10', '24',
        '48', '75', '49', '33', '50', '192', '25', '38', '39', '21', '11', '193', '51', '1106', '2', '54', '42', '5',
        '12', '63', '239', '41', '36', '43', '973', '22', '13', '64', '14', '7', '67', '35', '15', '62', '195', '53',
        '172', '8', '76', '9', '45', '28', '56', '1', '1104', '213', '16', '23'
    ];

    const DOMAIN_RU = 'ru';
    const DOMAIN_COM_TR = 'com.tr';
    const DOMAIN_COM = 'com';

    const ACTION_LIMITS_INFO = 'limits-info';

    const L10N_RUSSIAN = 'ru';
    const L10N_UKRAINIAN = 'uk';
    const L10N_BELARUSIAN = 'be';
    const L10N_KAZAKH = 'kk';
    const L10N_TURKISH = 'tr';
    const L10N_ENGLISH = 'en';

    const SORT_BY_RLV = 'rlv';
    const SORT_BY_TM = 'tm';

    const SORTING_DIRECTION_DESC = 'descending';
    const SORTING_DIRECTION_ASC = 'ascending';

    const FILTER_STRICT = 'strict';
    const FILTER_MODERATE = 'moderate';
    const FILTER_NONE = 'none';

    const GROUP_MODE_FLAT = 'flat';
    const GROUP_MODE_DEEP = 'deep';

    /**
     * @param string $user API user
     * @param string $key API key
     * @param string|null $domainLanguage (optional) Domain language
     * @param string|null $endpointUrl
     * @see https://yandex.ru/dev/xml/
     */
    public function __construct(string $user, string $key, ?string $domainLanguage = null,
                                ?string $endpointUrl = null)
    {
        $this->user = $user;
        $this->key = $key;
        $this->selectedLanguage = $domainLanguage;

        if ($domainLanguage === null) {
            $this->selectedLanguage = self::DOMAIN_RU;
        }

        if ($endpointUrl !== null) {
            $this->url = $endpointUrl;
        }
    }

    /**
     * Set a search region id. Region list you can find here: https://yandex.ru/dev/xml/doc/dg/reference/regions.html/
     *
     * @param integer $lr region id
     * @return Client $client
     * @throws YandexInvalidArgumentException
     * @see https://yandex.ru/dev/xml/doc/dg/reference/regions.html/
     */
    public function lr(int $lr): Client
    {
        if (!in_array($lr, self::AVAILABLE_REGIONS)) {
            throw new YandexInvalidArgumentException();
        }

        $this->lr = $lr;

        return $this;
    }

    /**
     * Set a response language
     *
     * @param string $l10n region id
     * @return Client $client
     * @throws YandexInvalidArgumentException
     */
    public function l10n(string $l10n): Client
    {
        if (!in_array($l10n, [self::L10N_TURKISH, self::L10N_ENGLISH, self::L10N_BELARUSIAN, self::L10N_KAZAKH,
            self::L10N_RUSSIAN, self::L10N_UKRAINIAN])) {
            throw new YandexInvalidArgumentException();
        }

        if (($l10n == self::L10N_TURKISH) && ($this->selectedLanguage != self::DOMAIN_COM_TR)) {
            throw new YandexInvalidArgumentException();
        }

        if (($l10n == self::L10N_ENGLISH) && ($this->selectedLanguage != self::DOMAIN_COM)) {
            throw new YandexInvalidArgumentException();
        }

        $this->l10n = $l10n;

        return $this;
    }

    /**
     * Set a search region id. Region list you can find here: https://yandex.ru/dev/xml/doc/dg/reference/regions.html/
     *
     * @param string $type sorting type
     * @param string|null $direction (optional) sorting direction
     * @return Client $client
     * @throws YandexInvalidArgumentException
     */
    public function sortBy(string $type, ?string $direction = null): Client
    {
        if (!in_array($type, [self::SORT_BY_TM, self::SORT_BY_RLV])) {
            throw new YandexInvalidArgumentException();
        }

        if (($type == self::SORT_BY_TM) && ($direction !== null)) {
            if (!in_array($direction, [self::SORTING_DIRECTION_ASC, self::SORTING_DIRECTION_DESC])) {
                throw new YandexInvalidArgumentException();
            }

            $this->sortByDirection = $direction;
        }

        $this->sortByType = $type;

        return $this;
    }

    /**
     * Set a filtering rules
     *
     * @param string $type filtering type
     * @return Client $client
     * @throws YandexInvalidArgumentException
     */
    public function filter(string $type): Client
    {
        if (!in_array($type, [self::FILTER_MODERATE, self::FILTER_NONE, self::FILTER_STRICT])) {
            throw new YandexInvalidArgumentException();
        }

        $this->filter = $type;

        return $this;
    }

    /**
     * Set a maximum passages number
     *
     * @param integer $number maximum passages number
     * @return Client $client
     * @throws YandexInvalidArgumentException
     */
    public function maxPassages(int $number): Client
    {
        if (($number < 1) || ($number > 5)) {
            throw new YandexInvalidArgumentException();
        }

        $this->maxPassages = $number;

        return $this;
    }

    /**
     * Set a grouping rules
     *
     * @param string $mode grouping method
     * @param integer|null $groupsOnPage (optional) groups on page number
     * @param integer|null $docsInGroup (optional) documents in group number
     * @return Client $client
     * @throws YandexInvalidArgumentException
     */
    public function groupBy(string $mode,
                            ?int $groupsOnPage = null,
                            ?int $docsInGroup = null): Client
    {
        if (!in_array($mode, [self::GROUP_MODE_DEEP, self::GROUP_MODE_FLAT])) {
            throw new YandexInvalidArgumentException();
        }

        if (($groupsOnPage !== null) && (($groupsOnPage < 1) || ($groupsOnPage > 100))) {
            throw new YandexInvalidArgumentException();
        }

        if (($docsInGroup !== null) && (($docsInGroup < 1) || ($docsInGroup > 3))) {
            throw new YandexInvalidArgumentException();
        }

        $this->groupByMode = $mode;

        if ($groupsOnPage !== null) {
            $this->groupByGroupsOnPage = $groupsOnPage;
        }

        if ($docsInGroup !== null) {
            $this->groupByDocsInGroup = $docsInGroup;
        }

        return $this;
    }

    /**
     * Set a page number
     *
     * @param integer $number page number. Starts from "0"
     * @return Client $client
     * @throws YandexInvalidArgumentException
     */
    public function page(int $number): Client
    {
        if ($number < 0) {
            throw new YandexInvalidArgumentException();
        }

        $this->page = $number;

        return $this;
    }

    /**
     * Enable Captcha on result page
     *
     * @return Client $client
     */
    public function showMeCaptcha(): Client
    {
        $this->showMeCaptcha = 'yes';

        return $this;
    }

    /**
     * Set query string
     *
     * @param string $query query string
     * @return Client $client
     */
    public function query(string $query): Client
    {
        $this->query = $query;

        return $this;
    }

    /**
     * Set action value (at this time uses only for getting information about day or hour limits)
     *
     * @return Client $client
     */
    public function action(): Client
    {
        $this->action = self::ACTION_LIMITS_INFO;

        return $this;
    }

    /**
     * Retrieving search results
     *
     * @return string Response body
     * @throws YandexException|ClientException|GuzzleException
     */
    public function get(): string
    {
        $data = $this->getData();

        return $data ? $data : '';
    }

    /**
     * Sends a request
     *
     * @return string Response body
     * @throws YandexException|ClientException|GuzzleException
     */
    protected function getData(): string
    {
        $url = $this->getEndpointUrlWithParams();

        $client = new HttpClient();

        try {
            $response = $client->get($url);
        } catch (ClientException $e) {
            $response = $e->getResponse();
            $responseData = $response->getBody()->getContents();

            $xml = simplexml_load_string($responseData);
            $responseData = json_encode($xml, JSON_UNESCAPED_UNICODE);

            $dataArray = json_decode($responseData, true);

            if ($dataArray['response'] && $dataArray['response']['error']) {
                throw new YandexException($dataArray['error']['text'], $dataArray['response']['error']);
            } else throw $e;
        }

        return $response->getBody();
    }

    private function generateSortByAttribute(): string
    {
        $string = $this->sortByType;

        if ($this->sortByDirection) {
            $string .= '.order=' . $this->sortByDirection;
        }

        return $string;
    }

    private function generateGroupByAttribute(): string
    {
        $string = $this->groupByMode;

        if ($this->groupByMode == self::GROUP_MODE_DEEP) {
            $string .= '.attr=d';
        }

        if ($this->groupByGroupsOnPage) {
            $string .= '.groups-on-page=' . $this->groupByGroupsOnPage;
        }

        if ($this->groupByDocsInGroup) {
            $string .= '.docs-in-group=' . $this->groupByDocsInGroup;
        }

        return $string;
    }

    /**
     * Generates end-point URL with parameters
     *
     * @return string Full end-point URL
     * @throws YandexException
     */
    public function getEndpointUrlWithParams(): string
    {
        $url = $this->getEndpointUrl();

        if ($this->action) {
            $params = $this->getActionParams();
        } else {
            if (!$this->query) {
                throw new YandexException();
            }

            $params = $this->getQueryParams();
        }

        $params['user'] = $this->user;
        $params['key'] = $this->key;

        return $url . '?' . http_build_query($params);
    }

    /**
     * Generates action parameters array
     *
     * @return array Action parameters array
     */
    private function getActionParams(): array
    {
        return [
            'action' => $this->action
        ];
    }

    /**
     * Generates query parameters array
     *
     * @return array Query parameters array
     */
    private function getQueryParams(): array
    {
        $params = [
            'query' => $this->query
        ];

        if ($this->lr) $params['lr'] = $this->lr;
        if ($this->l10n) $params['l10n'] = $this->l10n;
        if ($this->page) $params['page'] = $this->page;
        if ($this->showMeCaptcha) $params['showmecaptcha'] = $this->showMeCaptcha;
        if ($this->maxPassages) $params['maxpassages'] = $this->maxPassages;
        if ($this->filter) $params['filter'] = $this->filter;
        if ($this->sortByType) $params['sortby'] = $this->generateSortByAttribute();
        if ($this->groupByMode) $params['groupby'] = $this->generateGroupByAttribute();

        return $params;
    }

    /**
     * Generates end-point URL
     *
     * @return string Full end-point URL
     */
    public function getEndpointUrl(): string
    {
        return str_replace('{lang}', $this->selectedLanguage, $this->url);
    }
}