service.php

См. документацию.

<?php
 
namespace Bitrix\Seo;
 
use Bitrix\Main\Application;
use Bitrix\Main\Context;
use Bitrix\Main\Loader;
use Bitrix\Main\LoaderException;
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;
use Bitrix\Seo\Retargeting\Request;
 
Loc::loadMessages(__FILE__);
 
if (!defined("BITRIX_CLOUD_ADV_URL"))
{
    $domain = (new \Bitrix\Main\License\UrlProvider())->getTechDomain();
    $cloudAdvUrl = 'https://cloud-adv.' . $domain;
 
    define("BITRIX_CLOUD_ADV_URL", $cloudAdvUrl);
}
 
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();
    }

    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;
            }
        }
 
        return static::$auth["engine"][$engineCode] ?? false;
    }

    public static function getClientList($engineCode = false, string $type = null)
    {
        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
            {
                $request = Request::create($type);
                $clientDataProvider = static::getEngine($request)?->getInterface();
                if (!$clientDataProvider)
                {
                    return [];
                }
 
                $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);
 
        if ($engine && is_string($engine))
        {
            [$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): void
    {
        if (static::isRegistered())
        {
            $id = static::getEngine()->getId();
 
            $result = SearchEngineTable::update($id, [
                "CLIENT_ID" => $accessParams["client_id"],
                "CLIENT_SECRET" => $accessParams["client_secret"],
                "SETTINGS" => "",
            ]);
        }
        else
        {
            $result = SearchEngineTable::add([
                "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(?Request $request = null): ?Bitrix
    {
        if (!Loader::includeModule("socialservices"))
        {
            return null;
        }
 
        if (!static::$engine)
        {
            static::$engine = new Bitrix();
 
            if ($request)
            {
                static::$engine->setAuthSettings(['PROXY_URL' => $request->getProxyUrl()]);
            }
        }
 
        return static::$engine;
    }

    public static function register(string $serviceUrl = ''): void
    {
        static::clearClientsCache();
 
        $httpClient = new HttpClient();
 
        $queryParams = [
            "key" => static::getLicense(),
            "scope" => static::getEngine()?->getInterface()?->getScopeEncode(),
            "redirect_uri" => static::getRedirectUri(),
        ];
 
        $serviceUrl = $serviceUrl ?: static::SERVICE_URL;
 
        $result = $httpClient->post($serviceUrl . static::REGISTER, $queryParams);
 
        try
        {
            $result = Json::decode($result);
        }
        catch (\Exception $e)
        {
            $result = [
                'error' => $e->getCode() . ': ' . $e->getMessage(),
            ];
        }
 
        if (isset($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 = "";
        $session = Application::getInstance()
            ->getSession()
        ;
 
        if (Loader::includeModule("socialservices") && $session->isAccessible())
        {
            $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,
        ]);
    }
}