Operator.php

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

<?php
declare(strict_types=1);
 
namespace Bitrix\Landing\Copilot\Data\Block;
 
use Bitrix\Landing\Block;
use Bitrix\Landing\Copilot\Data;
use Bitrix\Landing;

class Operator
{
    private const ZONES_WHERE_NEED_CHECK_RESPONSE = ['ru'];
    private const DEFAULT_ASPECT_RATIO = '3by2';
    private const DEFAULT_WIDTH = 720;
 
    public static function getTitleStyleClass(): string
    {
        $titleStyleClasses = [
            'u-heading-v2-0',
            'u-heading-v2-3--bottom',
            'u-heading-v2-8--bottom',
            'u-heading-v2-3--top',
            'u-heading-v2-8--top',
            'u-heading-v2-13-2--left',
            'u-heading-v2-13-2--right',
        ];
 
        return $titleStyleClasses[array_rand($titleStyleClasses)];
    }

    public static function checkBlocksAmount(Data\Site $siteData, array $json): bool
    {
        if (
            !isset($json['blocks'])
            || !is_array($json['blocks'])
        )
        {
            return false;
        }
 
        $blocksData = $siteData->getBlocks();
 
        $countBlocksFromResponse = count($json['blocks']);
        $countBlocksForRequest = 0;
        foreach ($blocksData as $blockData)
        {
            if (!$blockData->isSeparator() && !$blockData->isMenu())
            {
                $countBlocksForRequest++;
            }
        }
 
        return $countBlocksFromResponse === $countBlocksForRequest;
    }

    public static function isNeedCheckDataFromResponse(): bool
    {
        $zone = Landing\Manager::getZone();
 
        return in_array($zone, self::ZONES_WHERE_NEED_CHECK_RESPONSE, true);
    }

    public static function prepareDataFromResponse(array $nodeDataFromResponse): array
    {
        $preparedData = [];
        foreach ($nodeDataFromResponse as $dataItem)
        {
            if (is_string($dataItem))
            {
                $preparedData[] = self::replaceWordsForZone($dataItem);
            }
            if (is_array($dataItem))
            {
                $preparedData[] = $dataItem;
            }
        }
 
        return $preparedData;
    }
 

    public static function getSizeDataImagesBySelector(string $selector, string $blockContent): array
    {
        $tagsWithClass = self::findTagsWithClass(substr($selector, 1), $blockContent);
        $defaultImageLinks = self::findImageLinks($tagsWithClass);
 
        return self::getSizeDataImages($defaultImageLinks);
    }

    public static function getDefaultSrc(array $dataImages): array
    {
        $defaultSrc = [
            'src' => [],
            'src2x' => [],
        ];
 
        $baseUrl = 'https://cdn.bitrix24.site/bitrix/images/landing/default/';
 
        foreach ($dataImages as $dataImage)
        {
            if (!isset($dataImage['aspectRatio'], $dataImage['width']))
            {
                continue;
            }
 
            $aspectRatio = $dataImage['aspectRatio'];
            $width = (int)$dataImage['width'];
 
            $defaultSrc['src'][] = "{$baseUrl}{$aspectRatio}/{$width}.png";
            $defaultSrc['src2x'][] = "{$baseUrl}{$aspectRatio}/" . ($width * 2) . '.png';
        }
 
        return $defaultSrc;
    }

    public static function extractNodeClasses(string $nodeCode, string $blockContent): string
    {
        if (str_starts_with($nodeCode, '.'))
        {
            $nodeCode = substr($nodeCode, 1);
        }
        $pattern = '/class="([^"]*' . $nodeCode . '(\s|")(?:|")[^"]*)"/';
        if (preg_match($pattern, $blockContent, $matches))
        {
            return $matches[1];
        }
 
        return '';
    }

    public static function extractWrapperClasses(string $blockContent): string
    {
        if (preg_match('/class="([^"]*landing-block[^"]*)"/', $blockContent, $matches))
        {
            return $matches[1];
        }
 
        return '';
    }

    public static function getAllowedAspectRatios(): array
    {
        return [
            '9by16' => 0.56,
            '2by3' => 0.67,
            '1by1' => 1,
            '3by2' => 1.5,
            '16by9' => 1.78,
        ];
    }
 
    public static function isBlockAvailableForScenarioChangeBlock(int $blockId): bool
    {
        $blockInstance = new Block($blockId);
        if ($blockInstance->getId() <= 0)
        {
            return false;
        }
 
        $blockManifest = $blockInstance->getManifest();
        $blockContent = $blockInstance->getContent();
 
        $notAllowedSections = [
            'countdowns',
            'separator',
            'menu',
            'sidebar',
            'store',
            'other',
            'video',
        ];
        $blockSection = (array)($blockManifest['block']['section'] ?? null);
        $sectionIntersect = array_intersect($notAllowedSections, $blockSection);
        if (!empty($sectionIntersect))
        {
            return false;
        }
 
        $notAllowedNodeTypes = ['embed'];
        $imageElements = 0;
        foreach ($blockManifest['nodes'] as $node)
        {
            if (isset($node['type']) && in_array($node['type'], $notAllowedNodeTypes, true))
            {
                return false;
            }
 
            if (isset($node['type']) && $node['type'] === 'img')
            {
                $nodeCode = ltrim($node['code'], '.');
                $imageElements += substr_count($blockContent, $nodeCode . ' ');
                $imageElements += substr_count($blockContent, $nodeCode . '"');
            }
        }
 
        if ($imageElements > 4)
        {
            return false;
        }
 
        if (self::hasNotAllowedTagInBlockContent($blockContent))
        {
            return false;
        }
 
        if ($blockInstance->getRepoId())
        {
            return false;
        }
 
        return true;
    }
 
    private static function hasNotAllowedTagInBlockContent(string $blockContent): bool
    {
        $notAllowedTags = ['table'];
 
        foreach ($notAllowedTags as $tag)
        {
            if (preg_match('/<\s*' . preg_quote($tag, '/') . '\b/i', $blockContent))
            {
                return true;
            }
        }
 
        return false;
    }

    private static function replaceWordsForZone(string $dataItem): string
    {
        $zone = Landing\Manager::getZone();
 
        $replacementMap = [
            'ru' => [
                'fa-square-instagram' => 'fa-pinterest',
                'fa-instagram' => 'fa-pinterest',
                'fa-meta' => 'fa-vk',
                'fa-square-facebook' => 'fa-vk',
                'fa-facebook-messenger' => 'fa-vk',
                'fa-facebook-f' => 'fa-vk',
                'fa-facebook' => 'fa-vk',
                'Instagram' => 'Pinterest',
                'Facebook' => 'VK',
            ],
        ];
 
        if (isset($replacementMap[$zone]))
        {
            foreach ($replacementMap[$zone] as $search => $replace)
            {
                $dataItem = preg_replace_callback(
                    '/' . preg_quote($search, '/') . '/i',
                    static function() use ($replace) {
                        return $replace;
                    },
                    $dataItem
                );
            }
        }
 
        return $dataItem;
    }

    private static function findTagsWithClass(string $class, string $contentBlock): array
    {
        $patternPart1 = '/<([a-z]+)\b[^>]*class=["][^"]*\b';
        $patternPart2 = '\b(?:["\s][^"]*)?["][^>]*>/i';
        $pattern = $patternPart1 . $class . $patternPart2;
 
        preg_match_all($pattern, $contentBlock, $matches, PREG_SET_ORDER);
 
        $tags = [];
        foreach ($matches as $match)
        {
            $tags[] = $match[0];
        }
 
        return $tags;
    }

    private static function findImageLinks(array $tags): array
    {
        $links = [];
 
        foreach ($tags as $tag)
        {
            $pattern = '/\b(?:https?:\/\/|www\.)\S+\.(?:jpg|jpeg|png)(?=\b|[^a-z0-9])/i';
            if (preg_match($pattern, $tag, $match))
            {
                $links[] = $match[0];
            }
            else
            {
                $links[] = '';
            }
        }
 
        return $links;
    }

    private static function getSizeDataImages(array $defaultImageLinks): array
    {
        $imagesData = [];
 
        foreach ($defaultImageLinks as $defaultImageLink)
        {
            [$width, $height, $aspectRatio] = Images::getImageData($defaultImageLink);
 
            $closestAspectRatioKey = self::getClosestAspectRatioKey($aspectRatio);
 
            $closestWidth = self::getClosestWidth((int)$width, $closestAspectRatioKey);
 
            $imagesData[] = [
                'width' => $closestWidth, // value from default copilot image
                'height' => $height, // todo: value from default url in block
                'aspectRatio' => $closestAspectRatioKey, // value from default copilot image
            ];
        }
 
        return $imagesData;
    }

    private static function getAllowedWidths(): array
    {
        return [
            '9by16' => ['180', '270', '360', '450', '540', '720'],
            '2by3' => ['240', '320', '360', '480', '600', '720', '880'],
            '1by1' => ['180', '256', '512', '720', '1024', '1280', '1440', '1920'],
            '3by2' => ['360', '480', '540', '720', '900', '1080', '1320', '1620', '1920'],
            '16by9' => ['320', '450', '480', '640', '800', '960', '1280', '1440', '1600', '1920'],
        ];
    }

    public static function getClosestAspectRatioKey(float $aspectRatio): ?string
    {
        $allowedAspectRatios = self::getAllowedAspectRatios();
        $closestAspectRatioKey = null;
        $closestAspectRatioDiff = PHP_FLOAT_MAX;
 
        foreach ($allowedAspectRatios as $key => $value)
        {
            $diff = abs($aspectRatio - $value);
            if ($diff < $closestAspectRatioDiff)
            {
                $closestAspectRatioDiff = $diff;
                $closestAspectRatioKey = $key;
            }
        }
 
        return $closestAspectRatioKey;
    }

    public static function getAvatarLinks(array $gendersData): array
    {
        $genderMaxValues = [
            'male'   => 50,
            'female' => 52,
            'unisex' => 18,
        ];
 
        $links = [];
 
        foreach ($gendersData as $gender)
        {
            $gender = in_array($gender, ['male', 'female']) ? $gender : 'unisex';
 
            if (!isset($usedRandInt[$gender]))
            {
                $usedRandInt[$gender] = [];
            }
 
            do
            {
                $randInt = rand(1, $genderMaxValues[$gender]);
            }
            while (in_array($randInt, $usedRandInt[$gender], true));
 
            $usedRandInt[$gender][] = $randInt;
 
            $links[] = 'https://cdn.bitrix24.site/bitrix/images/landing/default/' . $gender . '/' . $randInt . '.png';
        }
 
        return $links;
    }
 
    public static function getDefaultAspectRatio(): string
    {
        return self::DEFAULT_ASPECT_RATIO;
    }
 
    public static function getDefaultWidth(string $aspectRatio): int
    {
        $allowedWidths = self::getAllowedWidths();
 
        if (!isset($allowedWidths[$aspectRatio]))
        {
            return self::DEFAULT_WIDTH;
        }
 
        $widths = $allowedWidths[$aspectRatio];
        $middleIndex = (int)(count($widths) / 2);
 
        return (int)$widths[$middleIndex];
    }
 
    public static function getDefaultAvatarLinks(array $gendersData): array
    {
        $defaultAvatarLink = 'https://cdn.bitrix24.site/bitrix/images/landing/default/1by1/512.png';
        $defaultAvatarLink2x = 'https://cdn.bitrix24.site/bitrix/images/landing/default/1by1/1024.png';
        $links = [];
        $countLinks = count($gendersData);
        for ($i = 0; $i < $countLinks; $i++)
        {
            $links[] = [
                'src' => $defaultAvatarLink,
                'src2x' => $defaultAvatarLink2x,
            ];
        }
 
        return $links;
    }

    public static function getClosestWidth(int $width, ?string $closestAspectRatioKey): ?int
    {
        $allowedWidths = self::getAllowedWidths();
 
        if ($closestAspectRatioKey === null)
        {
            return null;
        }
 
        $closest = $allowedWidths[$closestAspectRatioKey][0] ?? null;
        $smallestDifference = abs($width - $closest);
 
        foreach ($allowedWidths[$closestAspectRatioKey] as $allowedWidth)
        {
            $difference = abs($width - $allowedWidth);
            if ($difference < $smallestDifference)
            {
                $smallestDifference = $difference;
                $closest = $allowedWidth;
            }
        }
 
        return (int)$closest;
    }
}