service.php

<?
 
namespace Bitrix\Seo\Analytics;
 
use Bitrix\Main\Loader;
 
use Bitrix\Seo\BusinessSuite\IInternalService;
use Bitrix\Seo\Retargeting;
 
class Service implements Retargeting\IService, Retargeting\IMultiClientService, IInternalService
{
    const GROUP = 'analytics';
 
    const TYPE_FACEBOOK = 'facebook';
    const TYPE_INSTAGRAM = 'instagram';
    const TYPE_VKONTAKTE = 'vkontakte';
    const TYPE_VKADS = 'vkads';
    const TYPE_GOOGLE = 'google';
    const TYPE_YANDEX = 'yandex';
 
    protected static $errors = [];
 
    protected $clientId;
 
    public static function getInstance()
    {
        static $instance = null;
        if ($instance === null)
        {
            $instance = new static();
        }
 
        return $instance;
    }
 
    public static function canUse()
    {
        return Loader::includeModule('seo') && Loader::includeModule('socialservices');
    }
 
    public static function canUseMultipleClients()
    {
        return true;
    }
 
    public static function getEngineCode($type)
    {
        return static::GROUP . '.' . $type;
    }
 
    public static function getAccount($type)
    {
        return Account::create($type, null, static::getInstance());
    }
 
    public static function getTypes()
    {
        return array(
            static::TYPE_FACEBOOK,
            static::TYPE_VKONTAKTE,
            static::TYPE_VKADS,
            static::TYPE_GOOGLE,
            static::TYPE_INSTAGRAM,
            static::TYPE_YANDEX,
        );
    }
 
    public static function getAuthAdapter($type)
    {
        return Retargeting\AuthAdapter::create($type, static::getInstance());
    }
 
    public static function getProviders(array $types = null)
    {
        $providers = static::getServiceProviders($types);
 
        return $providers;
    }
 
    protected static function isRegionRussian(bool $onlyRu = false): bool
    {
        $regions = $onlyRu ? ['ru'] : ['ru', 'kz', 'by'];
 
        $region = \Bitrix\Main\Application::getInstance()->getLicense()->getRegion() ?: 'ru';
        return in_array($region, $regions);
    }
 
    protected static function getServiceProviders(array $types = null)
    {
        $typeList = static::getTypes();
 
        $providers = array();
        foreach ($typeList as $type)
        {
            if ($types && !in_array($type, $types))
            {
                continue;
            }
 
            if (in_array($type, [static::TYPE_FACEBOOK, static::TYPE_INSTAGRAM]) && self::isRegionRussian(true))
            {
                continue;
            }
 
            $authAdapter = static::getInstance()->getAuthAdapter($type);
            $account = static::getInstance()->getAccount($type);
 
            $providers[$type] = array(
                'TYPE' => $type,
                'HAS_AUTH' => $authAdapter->hasAuth(),
                'AUTH_URL' => $authAdapter->getAuthUrl(),
                'HAS_ACCOUNTS' => $account->hasAccounts(),
                'PROFILE' => $account->getProfileCached(),
                'ENGINE_CODE' => static::getEngineCode($type),
                'CLIENTS' => static::getClientsProfiles($authAdapter)
            );
 
            // check if no profile, then may be auth was removed in service
            if ($providers[$type]['HAS_AUTH'] && empty($providers[$type]['PROFILE']))
            {
                static::removeAuth($type);
                $providers[$type]['HAS_AUTH'] = false;
            }
        }
 
        return $providers;
    }
 
    public static function getAccounts($type)
    {
        if (!static::canUse())
        {
            return array();
        }
 
        $result = array();
 
        $account = static::getAccount($type);
        $accountsResult = $account->getList();
        if ($accountsResult->isSuccess())
        {
            while ($accountData = $accountsResult->fetch())
            {
                $accountData = $account->normalizeListRow($accountData);
                if ($accountData['ID'])
                {
                    $result[] = array(
                        'id' => $accountData['ID'],
                        'name' => $accountData['NAME'] ? $accountData['NAME'] : $accountData['ID']
                    );
                }
            }
        }
        else
        {
            self::$errors = $accountsResult->getErrorMessages();
        }
 
        return $result;
    }
 
    public static function removeAuth($type)
    {
        static::getInstance()->getAuthAdapter($type)->removeAuth();
    }
 
    public static function getErrors()
    {
        return self::$errors;
    }
 
    public static function resetErrors()
    {
        self::$errors = array();
    }
 
    public static function hasErrors()
    {
        return count(self::$errors) > 0;
    }
 
    public function getClientId()
    {
        return $this->clientId;
    }
    public function setClientId($clientId)
    {
        $this->clientId = $clientId;
        return $this;
    }
 
    public static function getClientsProfiles(Retargeting\AuthAdapter $authAdapter)
    {
        $type = $authAdapter->getType();
        return array_values(array_filter(array_map(function ($item) use ($type) {
            $service = new static();
            $service->setClientId($item['proxy_client_id']);
 
            $authAdapter = Retargeting\AuthAdapter::create($type)->setService($service);
 
            $account = Account::create($type)->setService($service);
            $account->getRequest()->setAuthAdapter($authAdapter);
 
            $profile = $account->getProfileCached();
            if ($profile)
            {
                return $profile;
            }
            else
            {
                // if no profile, then may be auth was removed in service
                $authAdapter->removeAuth();
                return null;
            }
        }, $authAdapter->getAuthorizedClientsList())));
    }
 
    public static function getTypeByEngine(string $engineCode): ?string
    {
        foreach (static::getTypes() as $type)
        {
            if($engineCode == static::getEngineCode($type))
            {
                return $type;
            }
        }
        return null;
    }
 
    public static function canUseAsInternal(): bool
    {
        return true;
    }
 
    public static function getMethodPrefix(): string
    {
        return 'analytics';
    }
}