tokenrequester.php

<?php
 
namespace Bitrix\Location\Source\Osm;
 
use Bitrix\Location\Entity\Source\Config;
use Bitrix\Location\Entity\Source\OrmConverter;
use Bitrix\Location\Infrastructure\Service\LoggerService;
use Bitrix\Location\Repository\SourceRepository;
use Bitrix\Main\Data\ManagedCache;
use Bitrix\Main\Result;
use Bitrix\Main\Service\MicroService\BaseSender;
use Bitrix\Main\Application;
use Bitrix\Main\Service\MicroService\Client;
 
final class TokenRequester extends BaseSender
{
    private const SAFE_BUFFER_TIME_SECONDS = 60;
    private const ERROR_LICENSE_NOT_FOUND = 'LICENSE_NOT_FOUND';
    private const ERROR_WRONG_SIGN = 'WRONG_SIGN';
    private const ERROR_LICENSE_DEMO = 'LICENSE_DEMO';
    private const ERROR_LICENSE_NOT_ACTIVE = 'LICENSE_NOT_ACTIVE';
 
    private const CACHE_TABLE = '/bx/osmgateway/license';
    private const CACHE_TTL = 86400;
 
    private OsmSource $source;
    private ManagedCache $cacheManager;
 
    public function setSource(OsmSource $source): TokenRequester
    {
        $this->source = $source;
        $this->cacheManager = Application::getInstance()->getManagedCache();
        return $this;
    }
 
    public function getToken(): ?Token
    {
        $token = $this->getFromConfig();
        if ($token)
        {
            return $token;
        }
 
        if (!$this->hasLicenseIssues())
        {
            $token = $this->requestNewToken();
            if ($token)
            {
                $this->updateConfigToken($token);
            }
        }
 
        return $token;
    }
 
    private function updateConfigToken(Token $token): void
    {
        $config = $this->source->getConfig();
        if (!$config)
        {
            $config = new Config();
            $this->source->setConfig($config);
        }
        $config->setValue('TOKEN', serialize($token->convertToArray()));
 
        (new SourceRepository(new OrmConverter()))->save($this->source);
    }
 
    private function getFromConfig(): ?Token
    {
        $config = $this->source->getConfig();
        if ($config === null)
        {
            return null;
        }
 
        $tokenArray = $config->getValue('TOKEN');
        if (!$tokenArray)
        {
            return null;
        }
 
        if (!CheckSerializedData($tokenArray))
        {
            return null;
        }
 
        $token = Token::makeFromArray(unserialize($tokenArray, ['allowed_classes' => false]));
        if(!$token)
        {
            return null;
        }
 
        if ($token->getToken() === '')
        {
            return null;
        }
 
        if ($token->getExpiry() <= time() + self::SAFE_BUFFER_TIME_SECONDS)
        {
            $token = null;
        }
 
        return $token;
    }
 
    private function requestNewToken(): ?Token
    {
        $result = $this->performRequest('osmgateway.token.get');
        if (!$result->isSuccess())
        {
            $this->checkLicenseIssueByResult($result);
            return null;
        }
 
        $tokenData = $result->getData();
        if (
            !isset($tokenData['token'])
            || !isset($tokenData['expire'])
        )
        {
            LoggerService::getInstance()->log(
                LoggerService\LogLevel::ERROR,
                print_r($result, true),
                LoggerService\EventType::SOURCE_OSM_TREQUESTER_TOKEN_ERROR
            );
 
            return null;
        }
 
        return new Token(
            (string)$tokenData['token'],
            (int)$tokenData['expire']
        );
    }
 
    protected function getServiceUrl(): string
    {
        $serviceUrl = $this->source->getOsmServiceUrl();
 
        return $serviceUrl ?? '';
    }
 
    public function getHttpClientParameters(): array
    {
        return [
            'socketTimeout' => 5,
            'streamTimeout' => 10,
            'headers' => [
                'Bx-Location-Osm-Host' => $this->source->getOsmHostName()
            ]
        ];
    }
 
    private function checkLicenseIssueByResult(Result $result): void
    {
        $licenseIssueErrorCodes = [
            self::ERROR_LICENSE_NOT_FOUND,
            self::ERROR_WRONG_SIGN,
            self::ERROR_LICENSE_DEMO,
            self::ERROR_LICENSE_NOT_ACTIVE,
        ];
 
        $errors = $result->getErrors();
        foreach ($errors as $error)
        {
            if (in_array($error->getCode(), $licenseIssueErrorCodes, true))
            {
                $this->cacheManager->set(self::getCacheId(), true);
            }
        }
    }
 
    public function hasLicenseIssues(): bool
    {
        if ($this->cacheManager->read(self::CACHE_TTL, self::getCacheId(), self::CACHE_TABLE))
        {
            return (bool)$this->cacheManager->get(self::getCacheId());
        }
 
        return false;
    }
 
    private static function getCacheId(): string
    {
        return md5(serialize([
            'BX_TYPE' => Client::getPortalType(),
            'BX_LICENCE' => Client::getLicenseCode(),
        ]));
    }
}