service.php

<?php
namespace Bitrix\Seo;
 
use Bitrix\Main\Application;
use Bitrix\Main\Context;
use Bitrix\Main\Loader;
use Bitrix\Main\Localization\Loc;
use Bitrix\Main\SystemException;
use Bitrix\Main\Web\HttpClient;
use Bitrix\Main\Web\Json;
use Bitrix\Seo\Engine\Bitrix;
use Bitrix\Seo\Retargeting\AdsAudience;
 
Loc::loadMessages(__FILE__);
 
if(!defined("BITRIX_CLOUD_ADV_URL"))
{
    define("BITRIX_CLOUD_ADV_URL", 'https://cloud-adv.bitrix.info');
}
 
if(!defined("SEO_SERVICE_URL"))
{
    define('SEO_SERVICE_URL', BITRIX_CLOUD_ADV_URL);
}
 
class Service
{
    const SERVICE_URL = SEO_SERVICE_URL;
    const REGISTER = "/oauth/register/";
    const AUTHORIZE = "/register/";
    const REDIRECT_URI = "/bitrix/tools/seo_client.php";
 
    const SERVICE_AUTH_CACHE_TLL = 86400;
    const SERVICE_AUTH_CACHE_TLL_ERROR = 3600;
    const SERVICE_AUTH_CACHE_ID = 'seo|service_auth';
    const SERVICE_AUTH_CACHE_ID_ERROR = 'seo|service_auth_error';
 
    const CLIENT_LIST_CACHE_TLL = 86400;
    const CLIENT_LIST_CACHE_ID = 'seo|client_list|2';
 
    const  CLIENT_TYPE_SINGLE = 'S';
    const  CLIENT_TYPE_MULTIPLE = 'M';
    const  CLIENT_TYPE_COMPATIBLE = 'C';
 
    protected static $engine = null;
    protected static $auth = null;
    protected static $clientList = null;
 
    public static function isRegistered()
    {
        return static::getEngine() ? static::getEngine()->isRegistered() : false;
    }
 
    public static function getAuth(string $engineCode)
    {
        global $CACHE_MANAGER;
        if (static::$auth === null)
        {
            if ($CACHE_MANAGER->Read(static::SERVICE_AUTH_CACHE_TLL, static::SERVICE_AUTH_CACHE_ID))
            {
                static::$auth = $CACHE_MANAGER->Get(static::SERVICE_AUTH_CACHE_ID);
            }
            elseif (!$CACHE_MANAGER->Read(static::SERVICE_AUTH_CACHE_TLL_ERROR, static::SERVICE_AUTH_CACHE_ID_ERROR))
            {
                static::$auth = static::getEngine()->getInterface()->getClientInfo();
                if (!static::$auth)
                {
                    static::$auth = false;
                    $CACHE_MANAGER->Read(static::SERVICE_AUTH_CACHE_TLL_ERROR, static::SERVICE_AUTH_CACHE_ID_ERROR);
                    $CACHE_MANAGER->Set(static::SERVICE_AUTH_CACHE_ID_ERROR, static::$auth);
                }
                else
                {
                    $CACHE_MANAGER->Set(static::SERVICE_AUTH_CACHE_ID, static::$auth);
                }
            }
            else
            {
                static::$auth = false;
            }
        }
 
        if (static::$auth)
        {
            return static::$auth["engine"][$engineCode];
        }
 
        return false;
    }
 
    public static function getClientList($engineCode = false)
    {
        if( static::$clientList == null)
        {
            $cache = Application::getInstance()->getManagedCache();
            if ($cache->read(static::CLIENT_LIST_CACHE_TLL, static::CLIENT_LIST_CACHE_ID))
            {
                static::$clientList = $cache->get(static::CLIENT_LIST_CACHE_ID);
                static::$clientList = is_array(static::$clientList) ? static::$clientList : [];
            }
            else
            {
                $clientDataProvider = static::getEngine()->getInterface();
                $result = $clientDataProvider->getClientList();
                if (!is_array($result)) // backward compatibility
                {
                    $result = [];
                    $data = $clientDataProvider->getClientInfo();
                    if (is_array($data))
                    {
                        foreach ($data as $code => $client)
                        {
                            $data['proxy_client_type'] = static::CLIENT_TYPE_COMPATIBLE;
                            $data['engine_code'] = $code;
                            $data['proxy_client_id'] = null;
                            $result[] = $data;
                        }
                    }
                }
                else
                {
                    $result = $result['items'];
                }
                $cache->set(static::CLIENT_LIST_CACHE_ID, $result);
                static::$clientList = $result;
            }
        }
        if ($engineCode)
        {
            return array_filter(static::$clientList, function ($item) use ($engineCode) {
                return $item['engine_code'] == $engineCode;
            });
        }
        return static::$clientList;
    }
 
    public static function clearLocalAuth()
    {
        global $CACHE_MANAGER;
 
        $CACHE_MANAGER->Clean(static::SERVICE_AUTH_CACHE_ID);
 
        static::$auth = null;
    }
 
    public static function clearClientsCache($engine = null, $clientId = null)
    {
        $cache = Application::getInstance()->getManagedCache();
        $cache->Clean(static::CLIENT_LIST_CACHE_ID);
        $cache->Clean(static::SERVICE_AUTH_CACHE_ID);
        $cache->Clean(static::SERVICE_AUTH_CACHE_ID_ERROR);
 
        [$group, $type] = explode('.', $engine, 2);
 
        if ($group == \Bitrix\Seo\Retargeting\Service::GROUP)
        {
            $service = AdsAudience::getService();
            $service->setClientId($clientId);
            $account = $service->getAccount($type);
            if ($account)
                $account->clearCache();
        }
 
        static::$clientList = null;
        static::$auth = null;
    }
 
    public static function clearAuth($engineCode, $localOnly = false)
    {
        static::clearClientsCache($engineCode);
 
        if(!$localOnly)
        {
            static::getEngine()->getInterface()->clearClientAuth($engineCode);
        }
    }
 
    public static function clearAuthForClient($client, $localOnly = false)
    {
        if(!$localOnly)
        {
            static::getEngine()->getInterface()->clearClientAuth($client['engine_code'], $client['proxy_client_id']);
        }
        static::clearClientsCache($client['engine_code'], $client['proxy_client_id']);
    }
 
    protected static function setAccessSettings(array $accessParams)
    {
        if(static::isRegistered())
        {
            $id = static::getEngine()->getId();
 
            $result = SearchEngineTable::update($id, array(
                "CLIENT_ID" => $accessParams["client_id"],
                "CLIENT_SECRET" => $accessParams["client_secret"],
                "SETTINGS" => "",
            ));
        }
        else
        {
            $result = SearchEngineTable::add(array(
                "CODE" => Bitrix::ENGINE_ID,
                "NAME" => "Bitrix",
                "ACTIVE" => SearchEngineTable::ACTIVE,
                "CLIENT_ID" => $accessParams["client_id"],
                "CLIENT_SECRET" => $accessParams["client_secret"],
                "REDIRECT_URI" => static::getRedirectUri(),
            ));
        }
 
        if($result->isSuccess())
        {
            static::clearAuth(Bitrix::ENGINE_ID, true);
            static::$engine = null;
        }
    }
 
    public static function getEngine()
    {
        if(!static::$engine && Loader::includeModule("socialservices"))
        {
            static::$engine = new Bitrix();
        }
 
        return static::$engine;
    }
 
    public static function register()
    {
        static::clearClientsCache();
 
        $httpClient = new HttpClient();
 
        $queryParams = [
            "key" => static::getLicense(),
            "scope" => static::getEngine()->getInterface()->getScopeEncode(),
            "redirect_uri" => static::getRedirectUri(),
        ];
 
        $result = $httpClient->post(static::SERVICE_URL.static::REGISTER, $queryParams);
        $result = Json::decode($result);
 
        if($result["error"])
        {
            throw new SystemException($result["error"]);
        }
 
        static::setAccessSettings($result);
    }
 
    public static function unregister()
    {
        if(static::isRegistered())
        {
            $id = static::getEngine()->getId();
            SearchEngineTable::delete($id);
            static::clearClientsCache();
        }
    }
 
    public static function getAuthorizeLink()
    {
        return static::SERVICE_URL.static::AUTHORIZE;
    }
 
    public static function getAuthorizeData($engine, $clientType = false): array
    {
        $checkKey = "";
        if(Loader::includeModule("socialservices"))
        {
            $checkKey = \CSocServAuthManager::GetUniqueKey();
        }
 
        $clientType = $clientType ?: Service::CLIENT_TYPE_COMPATIBLE;
 
        return [
            "action" => "authorize",
            "type" => $clientType,
            "engine" => $engine,
            "client_id" => static::getEngine()->getClientId(),
            "client_secret" => static::getEngine()->getClientSecret(),
            "key" => static::getLicense(),
            "check_key" => urlencode($checkKey),
            "redirect_uri" => static::getRedirectUri(),
        ];
    }
 
    protected static function getRedirectUri(): string
    {
        $request = Context::getCurrent()->getRequest();
 
        $host = $request->getHttpHost();
        $port = (int)$request->getServerPort();
        $host .= ($port && $port !== 80 && $port !== 443) ? ":{$port}" : '';
 
        $isHttps = $request->isHttps();
 
        return ($isHttps ? 'https' : 'http').'://'.$host.static::REDIRECT_URI;
    }
 
    protected static function getLicense(): string
    {
        return md5(LICENSE_KEY);
    }
 
    public static function changeRegisteredDomain(array $domains = []): void
    {
        if (!self::isRegistered())
        {
            return;
        }
        if(!$engine = static::getEngine())
        {
            return;
        }
 
        $newRedirectUri = static::getRedirectUri();
        if(!empty($domains))
        {
            $newRedirectUri = str_replace($domains['old_domain'], $domains['new_domain'], $newRedirectUri);
        }
 
        SearchEngineTable::update($engine->getId(), [
            'REDIRECT_URI' => $newRedirectUri
        ]);
    }
}