client.php

<?
 
namespace Bitrix\Socialservices\Properties;
 
use Bitrix\Main\ArgumentException;
use Bitrix\Main\Config\Option;
use Bitrix\Main\Error;
use Bitrix\Main\ErrorCollection;
use Bitrix\Main\Localization\Loc;
use Bitrix\Main\Text\Encoding;
use Bitrix\Main\Web\HttpClient;
use Bitrix\Main\Web\Json;
use Bitrix\Main\Context;
 
Loc::loadMessages(__FILE__);
 
class Client
{
    const SERVICE_HOST = 'https://properties.bitrix.info';
    const REST_URI = '/rest/';
    const REGISTER_URI = '/oauth/register/';
    const SCOPE = 'ps';
    const SERVICE_ACCESS_OPTION = 'properties_service_access';
    const METHOD_COMMON_GET_BY_INN = 'ps.common.getByInn';
    const METHOD_COMMON_GET_BY_OGRN = 'ps.common.getByOgrn';
    const METHOD_ORGANIZATION_SEARCH_BY_NAME = 'ps.organization.searchByName';
    const METHOD_IP_SEARCH_BY_NAME = 'ps.ip.searchByName';
    const METHOD_UA_GET_BY_EDRPOU = 'ps.ua.getByEdrpou';
    const METHOD_UA_GET_UO_BY_ID = 'ps.ua.getUoById';
    const METHOD_UA_GET_FO_BY_ID = 'ps.ua.getFoById';
    const METHOD_UA_SEARCH_UO_BY_NAME = 'ps.ua.searchUoByName';
    const METHOD_UA_SEARCH_FO_BY_NAME = 'ps.ua.searchFoByName';
    const METHOD_UA_SEARCH_BY_NAME = 'ps.ua.searchByName';
    const METHOD_IS_SERVICE_ONLINE = 'ps.common.isOnline';
    const METHOD_COMMON_GET_BY_BIC = 'ps.bic.getByBic';
    const ERROR_WRONG_INPUT = 1;
    const ERROR_WRONG_LICENSE = 2;
    const ERROR_SERVICE_UNAVAILABLE = 3;
    const ERROR_NOTHING_FOUND = 4;
 
    protected $httpTimeout = 5;
    protected $accessSettings = null;
 
    protected $errorCollection;
 
    public function __construct()
    {
        $this->errorCollection = new ErrorCollection();
    }
 
    public function getByOgrn($ogrn, $showTerminated = false)
    {
        return $this->call(static::METHOD_COMMON_GET_BY_OGRN, array('ogrn' => $ogrn, 'showTerminated'=> $showTerminated));
    }
 
    public function getByInn($inn, $showTerminated = false)
    {
        return $this->call(static::METHOD_COMMON_GET_BY_INN, array('inn' => $inn, 'showTerminated' => $showTerminated));
    }
 
    public function searchOrganizationByName($name, $limit, $offset = 0)
    {
        return $this->call(static::METHOD_ORGANIZATION_SEARCH_BY_NAME, array(
            'name' => $name,
            'limit' => $limit,
            'offset' => $offset
        ));
    }
 
    public function searchIpByName($name, $secondName, $lastName, $limit, $offset = 0)
    {
        return $this->call(static::METHOD_IP_SEARCH_BY_NAME, array(
            'name' => $name,
            'second_name' => $secondName,
            'last_name' => $lastName,
            'limit' => $limit,
            'offset' => $offset
        ));
    }
 
    public function uaGetByEdrpou($edrpou)
    {
        return $this->call(static::METHOD_UA_GET_BY_EDRPOU, array('edrpou' => $edrpou));
    }
 
    public function uaGetUoById($id)
    {
        return $this->call(static::METHOD_UA_GET_UO_BY_ID, array('id' => $id));
    }
 
    public function uaGetFoById($id)
    {
        return $this->call(static::METHOD_UA_GET_FO_BY_ID, array('id' => $id));
    }
 
    public function uaSearchUoByName($name, $limit, $offset = 0)
    {
        return $this->call(static::METHOD_UA_SEARCH_UO_BY_NAME, array(
            'name' => $name,
            'limit' => $limit,
            'offset' => $offset
        ));
    }
 
    public function uaSearchFoByName($name, $limit, $offset = 0)
    {
        return $this->call(static::METHOD_UA_SEARCH_FO_BY_NAME, array(
            'name' => $name,
            'limit' => $limit,
            'offset' => $offset
        ));
    }
 
    public function uaSearchByName($name, $limit, $offset = 0)
    {
        return $this->call(static::METHOD_UA_SEARCH_BY_NAME, array(
            'name' => $name,
            'limit' => $limit,
            'offset' => $offset
        ));
    }
 
    public function getByBic($bic)
    {
        return $this->call(static::METHOD_COMMON_GET_BY_BIC, ['bic' => $bic]);
    }
 
    public function isServiceOnline()
    {
        return $this->call(static::METHOD_IS_SERVICE_ONLINE);
    }
 
    protected function call($methodName, $additionalParams = null, $licenseCheck = false, $clearAccessSettings = false)
    {
        $this->errorCollection->clear();
 
        if($clearAccessSettings)
            $this->clearAccessSettings();
 
        if(is_null($this->accessSettings))
            $this->accessSettings = $this->getAccessSettings();
 
        if($this->accessSettings === false)
            return false;
 
        if(!is_array($additionalParams))
        {
            $additionalParams = array();
        }
        else
        {
            $additionalParams = Encoding::convertEncodingArray($additionalParams, LANG_CHARSET, "utf-8");
        }
 
        $additionalParams['client_id'] = $this->accessSettings['client_id'];
        $additionalParams['client_secret'] = $this->accessSettings['client_secret'];
        if($licenseCheck)
            $additionalParams['key'] = static::getLicenseHash();
 
        $http = new HttpClient(array('socketTimeout' => $this->httpTimeout));
        $result = $http->post(
                static::SERVICE_HOST.static::REST_URI.$methodName,
                $additionalParams
        );
 
        if($result === false)
        {
            $httpErrors = $http->getError();
            foreach ($httpErrors as $errorCode => $errorText)
            {
                $this->errorCollection->add(array(new Error($errorText, $errorCode)));
            }
            return false;
        }
 
        $answer = $this->prepareAnswer($result);
 
        if(!is_array($answer) || count($answer) == 0)
        {
            $this->errorCollection->add(array(new Error('Malformed answer from service: '.$http->getStatus().' '.$result, static::ERROR_SERVICE_UNAVAILABLE)));
            return false;
        }
 
        if(array_key_exists('error', $answer))
        {
            if($answer['error'] === 'verification_needed' && !$licenseCheck)
            {
                return $this->call($methodName, $additionalParams, true);
            }
            else if(($answer['error'] === 'ACCESS_DENIED' || $answer['error'] === 'Invalid client')
                    && !$clearAccessSettings)
            {
                return $this->call($methodName, $additionalParams, true, true);
            }
 
            $this->errorCollection->add(array(new Error($answer['error_description'], $answer['error'])));
            return false;
        }
 
        if($answer['result'] == false)
        {
            $this->errorCollection->add(array(new Error(Loc::getMessage('SALE_PROPERTIES_ERROR_NOTHING_FOUND'), static::ERROR_NOTHING_FOUND)));
        }
 
        return $answer['result'];
    }
 
    protected function prepareAnswer($result)
    {
        try
        {
            return Json::decode($result);
        }
        catch (ArgumentException $e)
        {
            return false;
        }
    }
 
    protected function register()
    {
        $httpClient = new HttpClient();
 
        $queryParams = array(
                "key" => static::getLicenseHash(),
                "scope" => static::SCOPE,
                "redirect_uri" => static::getRedirectUri(),
        );
 
        $result = $httpClient->post(static::SERVICE_HOST.static::REGISTER_URI, $queryParams);
 
        if($result === false)
        {
            $this->errorCollection->add(array(new Error($result["error"], static::ERROR_SERVICE_UNAVAILABLE)));
            return false;
        }
 
        $result = Json::decode($result);
        if($result["error"])
        {
            $this->errorCollection->add(array(new Error($result["error"], static::ERROR_WRONG_LICENSE)));
            return false;
        }
        else
        {
            return $result;
        }
    }
 
    protected static function setAccessSettings(array $params)
    {
        Option::set('sale', static::SERVICE_ACCESS_OPTION, serialize($params));
    }
 
    protected function getAccessSettings()
    {
        $accessSettings = Option::get('sale', static::SERVICE_ACCESS_OPTION);
 
        if($accessSettings != '')
        {
            return unserialize($accessSettings, ["allowed_classes" => false]);
        }
        else
        {
            if($accessSettings = $this->register())
            {
                $this->setAccessSettings($accessSettings);
                return $accessSettings;
            }
            else
            {
                return false;
            }
        }
    }
 
    public function clearAccessSettings()
    {
        Option::set('sale', static::SERVICE_ACCESS_OPTION, null);
    }
 
    protected static function getRedirectUri()
    {
        $request = Context::getCurrent()->getRequest();
 
        $host = $request->getHttpHost();
        $isHttps = $request->isHttps();
 
        return ($isHttps ? 'https' : 'http').'://'.$host."/";
    }
 
    public function getErrors()
    {
        return $this->errorCollection->toArray();
    }
 
    protected static function getLicenseHash()
    {
        return md5(LICENSE_KEY);
    }
}