urlpreview.php

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

<?php
 
namespace Bitrix\Main\UrlPreview;
 
use Bitrix\Main\ArgumentException;
use Bitrix\Main\Config\Option;
use Bitrix\Main\Loader;
use Bitrix\Main\Security\Random;
use Bitrix\Main\Security\Sign\Signer;
use Bitrix\Main\Web\HttpClient;
use Bitrix\Main\Web\Uri;
use Bitrix\Main\Web\IpAddress;
use Bitrix\Main\Web\Http\Response;
use Bitrix\Main\File\Image;
use Bitrix\Main\Web\MimeType;
 
class UrlPreview
{
    const SIGN_SALT = 'url_preview';
    const USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36 (Bitrix link preview)';
    const MAX_DESCRIPTION = 500;
    const MAX_FILE_SIZE = 1048576;
    const FILE_RANGE = 1023;
 
    const IFRAME_MAX_WIDTH = 640;
    const IFRAME_MAX_HEIGHT = 340;
 
    protected static $trustedHosts = [
        'youtube.com' => 'youtube.com',
        'youtu.be' => 'youtu.be',
        'youtube-nocookie.com' => 'youtube-nocookie.com',
        'www.youtube-nocookie.com' => 'www.youtube-nocookie.com',
        'vimeo.com' => 'vimeo.com',
        'player.vimeo.com' => 'player.vimeo.com',
        'rutube.ru' => 'rutube.ru',
        'www.rutube.ru' => 'www.rutube.ru',
        'facebook.com' => 'facebook.com',
        'fb.watch' => 'fb.watch',
        'vk.com' => 'vk.com',
        'vk.ru' => 'vk.ru',
        'instagram.com' => 'instagram.com',
    ];

    public static function getMetadataByUrl($url, $addIfNew = true, $reuseExistingMetadata = true)
    {
        if (!static::isEnabled())
        {
            return false;
        }
 
        $url = static::normalizeUrl($url);
        if ($url == '')
        {
            return false;
        }
 
        if ($reuseExistingMetadata)
        {
            if ($metadata = UrlMetadataTable::getByUrl($url))
            {
                if ($metadata['TYPE'] === UrlMetadataTable::TYPE_TEMPORARY && $addIfNew)
                {
                    $metadata = static::resolveTemporaryMetadata($metadata['ID']);
                    return $metadata;
                }
                if ($metadata['TYPE'] !== UrlMetadataTable::TYPE_STATIC
                    || !isset($metadata['DATE_EXPIRE'])
                    || $metadata['DATE_EXPIRE']->getTimestamp() > time()
                )
                {
                    return $metadata;
                }
                if (static::refreshMetadata($metadata))
                {
                    return $metadata;
                }
            }
        }
 
        if (!$addIfNew)
        {
            return false;
        }
 
        $metadataId = static::reserveIdForUrl($url);
        $metadata = static::fetchUrlMetadata($url);
        if (is_array($metadata) && !empty($metadata))
        {
            $result = UrlMetadataTable::update($metadataId, $metadata);
            $metadata['ID'] = $result->getId();
            return $metadata;
        }
 
        return false;
    }

    public static function showView($userField, $userFieldParams, &$cacheTag, $edit = false)
    {
        global $APPLICATION;
        $edit = !!$edit;
        $cacheTag = '';
 
        if (!static::isEnabled())
        {
            return null;
        }
 
        $metadataId = (int)$userField['VALUE'][0];
        $metadata = false;
        if ($metadataId > 0)
        {
            $metadata = UrlMetadataTable::getById($metadataId)->fetch();
            if (isset($metadata['TYPE']) && $metadata['TYPE'] == UrlMetadataTable::TYPE_TEMPORARY)
            {
                $metadata = static::resolveTemporaryMetadata($metadata['ID']);
            }
        }
 
        if (is_array($metadata))
        {
            $fullUrl = static::unfoldShortLink($metadata['URL']);
            if ($metadata['TYPE'] == UrlMetadataTable::TYPE_DYNAMIC)
            {
                $routeRecord = Router::dispatch(new Uri($fullUrl));
 
                if (isset($routeRecord['MODULE']) && Loader::includeModule($routeRecord['MODULE']))
                {
                    $className = $routeRecord['CLASS'];
                    $routeRecord['PARAMETERS']['URL'] = $metadata['URL'];
                    $parameters = $routeRecord['PARAMETERS'];
 
                    if ($edit && (!method_exists($className, 'checkUserReadAccess') || !$className::checkUserReadAccess($parameters, static::getCurrentUserId())))
                    {
                        return null;
                    }
 
                    if (method_exists($className, 'buildPreview'))
                    {
                        $metadata['HANDLER'] = $routeRecord;
                        $metadata['HANDLER']['BUILD_METHOD'] = 'buildPreview';
                    }
 
                    if (method_exists($className, 'getCacheTag'))
                    {
                        $cacheTag = $className::getCacheTag();
                    }
                }
                elseif (!$edit)
                {
                    return null;
                }
            }
        }
        elseif (!$edit)
        {
            return null;
        }
 
        ob_start();
        $APPLICATION->IncludeComponent(
            'bitrix:main.urlpreview',
            '',
            array(
                'USER_FIELD' => $userField,
                'METADATA' => is_array($metadata) ? $metadata : [],
                'PARAMS' => $userFieldParams,
                'EDIT' => ($edit ? 'Y' : 'N'),
                'CHECK_ACCESS' => ($edit ? 'Y' : 'N'),
            )
        );
        return ob_get_clean();
    }

    public static function showEdit($userField, $userFieldParams)
    {
        return static::showView($userField, $userFieldParams, $cacheTag, true);
    }

    public static function isUrlCached($url)
    {
        $url = static::normalizeUrl($url);
        if ($url == '')
        {
            return false;
        }
 
        return (static::isUrlLocal(new Uri($url)) || !!UrlMetadataTable::getByUrl($url));
    }

    public static function getMetadataAndHtmlByUrl($url, $addIfNew = true, $reuseExistingMetadata = true)
    {
        $metadata = static::getMetadataByUrl($url, $addIfNew, $reuseExistingMetadata);
        if ($metadata === false)
        {
            return false;
        }
 
        if ($metadata['TYPE'] == UrlMetadataTable::TYPE_STATIC || $metadata['TYPE'] == UrlMetadataTable::TYPE_FILE)
        {
            return $metadata;
        }
        elseif ($metadata['TYPE'] == UrlMetadataTable::TYPE_DYNAMIC)
        {
            if ($preview = static::getDynamicPreview($url))
            {
                $metadata['HTML'] = $preview;
                return $metadata;
            }
 
        }
 
        return false;
    }

    public static function getMetadataAndHtmlByIds(array $ids, $checkAccess = true, $userId = 0)
    {
        if (!static::isEnabled())
        {
            return false;
        }
 
        $result = [];
 
        $queryResult = UrlMetadataTable::getList([
            'filter' => [
                'ID' => $ids,
                '!=TYPE' => UrlMetadataTable::TYPE_TEMPORARY,
            ]
        ]);
 
        while ($metadata = $queryResult->fetch())
        {
            if ($metadata['TYPE'] == UrlMetadataTable::TYPE_DYNAMIC)
            {
                $metadata['HTML'] = static::getDynamicPreview($metadata['URL'], $checkAccess, $userId);
                if ($metadata['HTML'] === false)
                {
                    continue;
                }
            }
            if ($metadata['TYPE'] == UrlMetadataTable::TYPE_STATIC
                && isset($metadata['DATE_EXPIRE'])
                && $metadata['DATE_EXPIRE']->getTimestamp() <= time()
            )
            {
                $refreshResult = static::refreshMetadata($metadata);
                if (!$refreshResult)
                {
                    continue;
                }
            }
            $result[$metadata['ID']] = $metadata;
        }
 
        return $result;
    }
 
    public static function getMetadataByIds(array $ids)
    {
        if (!static::isEnabled())
        {
            return false;
        }
 
        $result = [];
 
        $queryResult = UrlMetadataTable::getList([
            'filter' => [
                'ID' => $ids,
                '!=TYPE' => UrlMetadataTable::TYPE_TEMPORARY,
            ]
        ]);
 
        while ($metadata = $queryResult->fetch())
        {
            if ($metadata['TYPE'] == UrlMetadataTable::TYPE_STATIC
                && isset($metadata['DATE_EXPIRE'])
                && $metadata['DATE_EXPIRE']->getTimestamp() <= time()
            )
            {
                $refreshResult = static::refreshMetadata($metadata);
                if (!$refreshResult)
                {
                    continue;
                }
            }
            $result[$metadata['ID']] = $metadata;
        }
 
        return $result;
    }

    public static function reserveIdForUrl($url)
    {
        if ($metadata = UrlMetadataTable::getByUrl($url))
        {
            $id = $metadata['ID'];
        }
        else
        {
            $result = UrlMetadataTable::add(array(
                    'URL' => $url,
                    'TYPE' => UrlMetadataTable::TYPE_TEMPORARY
            ));
            $id = $result->getId();
        }
 
        return $id;
    }

    public static function resolveTemporaryMetadata($id, $checkAccess = true, $userId = 0)
    {
        $metadata = UrlMetadataTable::getRowById($id);
        if (!is_array($metadata))
        {
            return false;
        }
 
        if ($metadata['TYPE'] == UrlMetadataTable::TYPE_TEMPORARY)
        {
            $metadata['URL'] = static::normalizeUrl($metadata['URL']);
            $metadata = static::fetchUrlMetadata($metadata['URL']);
            if ($metadata === false)
            {
                UrlMetadataTable::delete($id);
                return false;
            }
 
            UrlMetadataTable::update($id, $metadata);
            return $metadata;
        }
        elseif ($metadata['TYPE'] == UrlMetadataTable::TYPE_STATIC || $metadata['TYPE'] == UrlMetadataTable::TYPE_FILE)
        {
            return $metadata;
        }
        elseif ($metadata['TYPE'] == UrlMetadataTable::TYPE_DYNAMIC)
        {
            if ($preview = static::getDynamicPreview($metadata['URL'], $checkAccess, $userId))
            {
                $metadata['HTML'] = $preview;
                return $metadata;
            }
        }
 
        return false;
    }
 
    protected static function refreshMetadata(array &$metadata): bool
    {
        if ($metadata['TYPE'] !== UrlMetadataTable::TYPE_STATIC)
        {
            return false;
        }
        $url = static::normalizeUrl($metadata['URL']);
        $refreshedMetadata = static::fetchUrlMetadata($url);
        if (!$refreshedMetadata)
        {
            return false;
        }
        if ($metadata['ID'])
        {
            UrlMetadataTable::update($metadata['ID'], $refreshedMetadata);
            $refreshedMetadata['ID'] = $metadata['ID'];
        }
        $metadata = $refreshedMetadata;
 
        return true;
    }

    public static function getDynamicPreview($url, $checkAccess = true, $userId = 0)
    {
        $routeRecord = Router::dispatch(new Uri(static::unfoldShortLink($url)));
        if ($routeRecord === false)
        {
            return false;
        }
 
        if (isset($routeRecord['MODULE']) && Loader::includeModule($routeRecord['MODULE']))
        {
            $className = $routeRecord['CLASS'];
            $parameters = $routeRecord['PARAMETERS'];
            $parameters['URL'] = $url;
 
            if ($userId == 0)
            {
                $userId = static::getCurrentUserId();
            }
 
            if ($checkAccess && (!method_exists($className, 'checkUserReadAccess') || $userId == 0 || !$className::checkUserReadAccess($parameters, $userId)))
                return false;
 
            if (method_exists($className, 'buildPreview'))
            {
                $preview = $className::buildPreview($parameters);
                return ($preview <> '' ? $preview : false);
            }
        }
        return false;
    }

    public static function getImAttach($url, $checkAccess = true, $userId = 0)
    {
        return self::getUrlInfoFromExternal($url, 'getImAttach', $checkAccess, $userId);
    }

    public static function getImRich($url, $checkAccess = true, $userId = 0)
    {
        return self::getUrlInfoFromExternal($url, 'getImRich', $checkAccess, $userId);
    }

    public static function checkDynamicPreviewAccess($url, $userId = 0)
    {
        $routeRecord = Router::dispatch(new Uri(static::unfoldShortLink($url)));
        if ($routeRecord === false)
        {
            return false;
        }
 
        if (isset($routeRecord['MODULE']) && Loader::includeModule($routeRecord['MODULE']))
        {
            $className = $routeRecord['CLASS'];
            $parameters = $routeRecord['PARAMETERS'];
 
            if ($userId == 0)
            {
                $userId = static::getCurrentUserId();
            }
 
            return (method_exists($className, 'checkUserReadAccess') && $userId > 0 && $className::checkUserReadAccess($parameters, $userId));
        }
        return false;
    }

    public static function setMetadataImage($id, $imageUrl)
    {
        if (!is_int($id))
        {
            throw new ArgumentException("Id of the metadata must be an integer", "id");
        }
        if (!is_string($imageUrl) && !is_null($imageUrl))
        {
            throw new ArgumentException("Url of the image must be a string", "imageUrl");
        }
 
        $metadata = UrlMetadataTable::getList(array(
            'select' => array('IMAGE', 'IMAGE_ID', 'EXTRA'),
            'filter' => array('=ID' => $id)
        ))->fetch();
 
        if (isset($metadata['EXTRA']['IMAGES']))
        {
            $imageIndex = array_search($imageUrl, $metadata['EXTRA']['IMAGES']);
            if ($imageIndex === false)
            {
                unset($metadata['EXTRA']['SELECTED_IMAGE']);
            }
            else
            {
                $metadata['EXTRA']['SELECTED_IMAGE'] = $imageIndex;
            }
        }
 
        static::fetchImageMetadata($imageUrl, $metadata);
 
        return UrlMetadataTable::update($id, $metadata)->isSuccess();
    }

    public static function isEnabled()
    {
        static $result = null;
        if (is_null($result))
        {
            $result = Option::get('main', 'url_preview_enable', 'N') === 'Y';
        }
        return $result;
    }

    public static function sign($id)
    {
        $signer = new Signer();
        return $signer->sign((string)$id, static::SIGN_SALT);
    }
 
    protected static function getUrlInfoFromExternal($url, $method, $checkAccess = true, $userId = 0)
    {
        //todo: caching
        $routeRecord = Router::dispatch(new Uri(static::unfoldShortLink($url)));
        if ($routeRecord === false)
        {
            return false;
        }
 
        if ($userId == 0)
        {
            $userId = static::getCurrentUserId();
        }
 
        if (isset($routeRecord['MODULE']) && Loader::includeModule($routeRecord['MODULE']))
        {
            $className = $routeRecord['CLASS'];
            $parameters = $routeRecord['PARAMETERS'];
            $parameters['URL'] = $url;
 
            if ($checkAccess && (!method_exists($className, 'checkUserReadAccess') || $userId == 0 || !$className::checkUserReadAccess($parameters, $userId)))
                return false;
 
            if (method_exists($className, $method))
            {
                return $className::$method($parameters);
            }
        }
        return false;
    }

    protected static function fetchUrlMetadata($url)
    {
        $fullUrl = static::unfoldShortLink($url);
        $uriParser = new Uri($fullUrl);
        if (static::isUrlLocal($uriParser))
        {
            if (Router::dispatch($uriParser))
            {
                $metadata = array(
                    'URL' => $url,
                    'TYPE' => UrlMetadataTable::TYPE_DYNAMIC,
                );
            }
        }
        else
        {
            $metadataRemote = static::getRemoteUrlMetadata($uriParser);
            if (is_array($metadataRemote) && !empty($metadataRemote))
            {
                $metadata = array(
                    'URL' => $url,
                    'TYPE' => $metadataRemote['TYPE'] ?? UrlMetadataTable::TYPE_STATIC,
                    'TITLE' => $metadataRemote['TITLE'] ?? '',
                    'DESCRIPTION' => $metadataRemote['DESCRIPTION'] ?? '',
                    'IMAGE_ID' => $metadataRemote['IMAGE_ID'] ?? null,
                    'IMAGE' => $metadataRemote['IMAGE'] ?? null,
                    'EMBED' => $metadataRemote['EMBED'] ?? null,
                    'EXTRA' => $metadataRemote['EXTRA'] ?? null,
                    'DATE_EXPIRE' => $metadataRemote['DATE_EXPIRE'] ?? null,
                );
            }
        }
 
        if (isset($metadata['TYPE']))
        {
            return $metadata;
        }
        return false;
    }

    protected static function isUrlLocal(Uri $uri)
    {
        if ($uri->getHost() == '')
        {
            return true;
        }
 
        $host = \Bitrix\Main\Context::getCurrent()->getRequest()->getHttpHost();
        return $uri->getHost() === $host;
    }

    protected static function getRemoteUrlMetadata(Uri $uri)
    {
        $httpClient = (new HttpClient())
            ->setPrivateIp(false) //prevents proxy to LAN
            ->setTimeout(5)
            ->setStreamTimeout(5)
            ->setHeader('User-Agent', self::USER_AGENT)
        ;
 
        $httpClient->shouldFetchBody(function (Response $response) {
            $contentType = $response->getHeadersCollection()->getContentType();
            return ($contentType === 'text/html' || MimeType::isImage($contentType));
        });
 
        try
        {
            if (!$httpClient->query('GET', $uri->getUri()))
            {
                return false;
            }
        }
        catch (\ErrorException)
        {
            return false;
        }
 
        if ($httpClient->getStatus() !== 200)
        {
            return false;
        }
 
        $peerIpAddress = $httpClient->getPeerAddress();
 
        if ($httpClient->getHeaders()->getContentType() !== 'text/html')
        {
            $metadata = static::getFileMetadata($httpClient);
            $metadata['EXTRA']['PEER_IP_ADDRESS'] = $peerIpAddress;
            $metadata['EXTRA']['PEER_IP_PRIVATE'] = (new IpAddress($peerIpAddress))->isPrivate();
 
            return $metadata;
        }
 
        $html = $httpClient->getResult();
 
        $htmlDocument = new HtmlDocument($html, $uri);
        $htmlDocument->setEncoding($httpClient->getCharset());
        ParserChain::extractMetadata($htmlDocument);
        $metadata = $htmlDocument->getMetadata();
 
        if (is_array($metadata) && static::validateRemoteMetadata($metadata))
        {
            if (isset($metadata['IMAGE']))
            {
                static::fetchImageMetadata($metadata['IMAGE'], $metadata);
            }
 
            if (isset($metadata['DESCRIPTION']) && mb_strlen($metadata['DESCRIPTION']) > static::MAX_DESCRIPTION)
            {
                $metadata['DESCRIPTION'] = mb_substr($metadata['DESCRIPTION'], 0, static::MAX_DESCRIPTION);
            }
 
            if (!isset($metadata['EXTRA']) || !is_array($metadata['EXTRA']))
            {
                $metadata['EXTRA'] = array();
            }
 
            $metadata['EXTRA'] = array_merge($metadata['EXTRA'], array(
                'PEER_IP_ADDRESS' => $peerIpAddress,
                'PEER_IP_PRIVATE' => (new IpAddress($peerIpAddress))->isPrivate(),
                'X_FRAME_OPTIONS' => $httpClient->getHeaders()->get('X-Frame-Options', true),
                'EFFECTIVE_URL' => $httpClient->getEffectiveUrl(),
            ));
 
            return $metadata;
        }
 
        return false;
    }
 
    protected static function getTempPath(string $fileName): string
    {
        $tempFileName = Random::getString(32) . '.' . GetFileExtension($fileName);
        $tempPath = \CFile::GetTempName('', $tempFileName);
 
        return $tempPath;
    }
 
    protected static function downloadFile(string $url, ?string &$fileName = null, ?int $range = null): ?string
    {
        $httpClient = (new HttpClient())
            ->setPrivateIp(false)
            ->setTimeout(5)
            ->setStreamTimeout(5)
            ->setBodyLengthMax(self::MAX_FILE_SIZE)
        ;
 
        if ($range !== null)
        {
            $httpClient->setHeader('Range', 'bytes=0-' . $range);
        }
 
        $urlComponents = parse_url($url);
        $fileName = ($urlComponents && $urlComponents["path"] <> '')
            ? bx_basename($urlComponents["path"])
            : bx_basename($url)
        ;
 
        $tempPath = static::getTempPath($fileName);
 
        try
        {
            if (!$httpClient->download($url, $tempPath))
            {
                return null;
            }
        }
        catch (\ErrorException)
        {
            return null;
        }
 
        if (($name = $httpClient->getHeaders()->getFilename()) !== null)
        {
            $fileName = $name;
        }
 
        return $tempPath;
    }

    protected static function saveImage(string $tempPath, ?string $fileName)
    {
        $fileId = false;
 
        $localFile = \CFile::MakeFileArray($tempPath);
 
        if (is_array($localFile))
        {
            $localFile['MODULE_ID'] = 'main';
 
            if ($fileName <> '')
            {
                $localFile['name'] = $fileName;
            }
            if (\CFile::CheckImageFile($localFile, 0, 0, 0, array("IMAGE")) === null)
            {
                $fileId = \CFile::SaveFile($localFile, 'urlpreview', true);
            }
        }
 
        return ($fileId === false ? null : $fileId);
    }
 
    protected static function fetchImageMetadata(string $imageUrl, array &$metadata): void
    {
        $saveImage = static::getOptionSaveImages();
 
        $tempPath = static::downloadFile($imageUrl, $fileName, ($saveImage ? null : self::FILE_RANGE));
 
        if ($tempPath !== null)
        {
            $info = (new Image($tempPath))->getInfo();
            if ($info)
            {
                $metadata['EXTRA']['IMAGE_INFO'] = [
                    'WIDTH' => $info->getWidth(),
                    'HEIGHT' => $info->getHeight(),
                ];
            }
 
            if ($saveImage)
            {
                $metadata['IMAGE_ID'] = static::saveImage($tempPath, $fileName);
                $metadata['IMAGE'] = null;
            }
            else
            {
                $metadata['IMAGE'] = $imageUrl;
                $metadata['IMAGE_ID'] = null;
            }
        }
    }

    protected static function normalizeUrl($url)
    {
        if (str_starts_with($url, 'https://') || str_starts_with($url, 'http://'))
        {
            //nop
        }
        elseif (str_starts_with($url, '//'))
        {
            $url = 'http:'.$url;
        }
        elseif (str_starts_with($url, '/'))
        {
            //nop
        }
        else
        {
            $url = 'http://'.$url;
        }
 
        $parsedUrl = new Uri($url);
        $parsedUrl->setHost(mb_strtolower($parsedUrl->getHost()));
 
        return $parsedUrl->getUri();
    }

    protected static function getOptionSaveImages()
    {
        static $result = null;
        if (is_null($result))
        {
            $result = Option::get('main', 'url_preview_save_images', 'N') === 'Y';
        }
        return $result;
    }

    protected static function validateRemoteMetadata(array $metadata)
    {
        $result = ((isset($metadata['TITLE']) && isset($metadata['IMAGE'])) || (isset($metadata['TITLE']) && isset($metadata['DESCRIPTION'])) || isset($metadata['EMBED']));
        return $result;
    }

    public static function getCurrentUserId()
    {
        return ($GLOBALS['USER'] instanceof \CUser) ? (int)$GLOBALS['USER']->getId() : 0;
    }

    protected static function unfoldShortLink($shortUrl)
    {
        static $cache = [];
        if (isset($cache[$shortUrl]))
        {
            return $cache[$shortUrl];
        }
 
        $result = $shortUrl;
        if ($shortUri = \CBXShortUri::GetUri($shortUrl))
        {
            $result = $shortUri['URI'];
        }
        $cache[$shortUrl] = $result;
        return $result;
    }

    protected static function getFileMetadata(HttpClient $client)
    {
        $url = $client->getEffectiveUrl();
        $httpHeaders = $client->getHeaders();
 
        $mimeType = $httpHeaders->getContentType();
        $filename = $httpHeaders->getFilename() ?: bx_basename($url);
        $result = false;
        if ($mimeType && $filename)
        {
            $result = array(
                'TYPE' => UrlMetadataTable::TYPE_FILE,
                'EXTRA' => array(
                    'ATTACHMENT' => strtolower($httpHeaders->getContentDisposition()) === 'attachment' ? 'Y' : 'N',
                    'MIME_TYPE' => $mimeType,
                    'FILENAME' => $filename,
                    'SIZE' => $httpHeaders->get('Content-Length')
                )
            );
 
            if (MimeType::isImage($mimeType))
            {
                // download image to temp file to detect dimensions
                $tempPath = static::getTempPath($filename);
 
                $client->saveFile($tempPath);
 
                $info = (new Image($tempPath))->getInfo();
                if ($info)
                {
                    $result['EXTRA']['IMAGE_INFO'] = [
                        'WIDTH' => $info->getWidth(),
                        'HEIGHT' => $info->getHeight(),
                    ];
                }
            }
        }
        return $result;
    }

    public static function isIpAddressPrivate($ipAddress)
    {
        return (new IpAddress($ipAddress))->isPrivate();
    }

    public static function isHostTrusted(Uri $uri)
    {
        $result = false;
        $domainNameParts = explode('.', $uri->getHost());
        if (is_array($domainNameParts) && ($partsCount = count($domainNameParts)) >= 2)
        {
            $domainName = $domainNameParts[$partsCount-2] . '.' . $domainNameParts[$partsCount-1];
            $result = isset(static::$trustedHosts[$domainName]);
        }
        return $result;
    }

    public static function fetchVideoMetaData($url)
    {
        $url = static::unfoldShortLink($url);
        $uri = new Uri($url);
        if (static::isHostTrusted($uri) || static::isEnabled())
        {
            $url = static::normalizeUrl($url);
            $metadataId = static::reserveIdForUrl($url);
            $metadata = static::fetchUrlMetadata($url);
            if (is_array($metadata) && !empty($metadata))
            {
                $result = UrlMetadataTable::update($metadataId, $metadata);
                $metadata['ID'] = $result->getId();
            }
            else
            {
                return false;
            }
            if (!empty($metadata['EMBED']) && !str_contains($metadata['EMBED'], '<iframe'))
            {
                $url = static::getInnerFrameUrl($metadata['ID'], $metadata['EXTRA']['PROVIDER_NAME']);
                if (intval($metadata['EXTRA']['VIDEO_WIDTH']) <= 0)
                {
                    $metadata['EXTRA']['VIDEO_WIDTH'] = self::IFRAME_MAX_WIDTH;
                }
                if (intval($metadata['EXTRA']['VIDEO_HEIGHT']) <= 0)
                {
                    $metadata['EXTRA']['VIDEO_HEIGHT'] = self::IFRAME_MAX_HEIGHT;
                }
                $metadata['EMBED'] = '<iframe src="'.$url.'" allowfullscreen="" width="'.$metadata['EXTRA']['VIDEO_WIDTH'].'" height="'.$metadata['EXTRA']['VIDEO_HEIGHT'].'" frameborder="0"></iframe>';
            }
 
            if ($metadata['EMBED'] || !empty($metadata['EXTRA']['VIDEO']))
            {
                return $metadata;
            }
        }
 
        return false;
    }

    public static function getInnerFrameUrl($id, $provider = '')
    {
        $result = false;
 
        $componentPath = \CComponentEngine::makeComponentPath('bitrix:main.urlpreview');
        if (!empty($componentPath))
        {
            $componentPath = getLocalPath('components'.$componentPath.'/frame.php');
            $uri = new Uri($componentPath);
            $uri->addParams(array('id' => $id, 'provider' => $provider));
            $result = static::normalizeUrl($uri->getLocator());
        }
 
        return $result;
    }
}