blockrepo.php

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

<?php
 
namespace Bitrix\Landing\Block;
 
use Bitrix\Landing\Site;
use Bitrix\Landing\Block;
use Bitrix\Landing\Config;
use Bitrix\Landing\File;
use Bitrix\Landing\Landing;
use Bitrix\Landing\Manager;
use Bitrix\Landing\Repo;
use Bitrix\Landing\Internals;
use Bitrix\Landing\Site\Type;
use Bitrix\Main\Application;
use Bitrix\Main\Event;
use Bitrix\Main\EventResult;
use Bitrix\Main\Loader;
use Bitrix\Main\Localization\Loc;

class BlockRepo
{
    public const BLOCKS_DIR = 'blocks';

    public const FAVOURITE_BLOCKS_LIMIT = 5000;

    public const FAVOURITE_BLOCKS_LIMIT_WITH_PREVIEW = 1000;

    public const NEW_BLOCK_LT = 1209600;//86400 * 14

    private const SECTION_LAST = 'last';

    private const TYPE_STORE = 'STORE';

    private const SITE_TYPE_DEFAULT = 'PAGE';

    private const BLOCKS_TAG = 'landing_blocks';

    public const FILTER_DEFAULTS = 'default';
    public const FILTER_SKIP_COMMON_BLOCKS = 'skip_common_blocks';
    public const FILTER_SKIP_SYSTEM_BLOCKS = 'skip_system_blocks';
    public const FILTER_SKIP_HIDDEN_BLOCKS = 'skip_hidden_blocks';
    private const AVAILABLE_FILTERS = [
        self::FILTER_SKIP_COMMON_BLOCKS,
        self::FILTER_SKIP_SYSTEM_BLOCKS,
        self::FILTER_SKIP_HIDDEN_BLOCKS,
    ];
    private const DEFAULT_ACTIVE_FILTERS = [
        self::FILTER_SKIP_SYSTEM_BLOCKS,
        self::FILTER_SKIP_HIDDEN_BLOCKS,
    ];

    private array $filters = self::DEFAULT_ACTIVE_FILTERS;

    private array $repository = [];
 
    private ?string $siteType;
 
    public function __construct()
    {
        if (Type::getCurrentScopeId())
        {
            $this->siteType = Type::getCurrentScopeId();
        }
        else
        {
            $this->setSiteType(Landing::getSiteType() ?: self::SITE_TYPE_DEFAULT);
        }
 
        $this->sendSetFiltersEvent();
    }

    public function setSiteType(string $type): static
    {
        $this->siteType = $type;
        if (!in_array($this->siteType, array_keys(Site::getTypes())))
        {
            $this->siteType = self::SITE_TYPE_DEFAULT;
        }
 
        Type::setScope($this->siteType);
 
        return $this;
    }
 
    private function sendSetFiltersEvent(): void
    {
        $event = new Event('landing', 'onBlockRepoSetFilters');
        $event->send();
 
        $enable = [];
        $disable = [];
 
        foreach ($event->getResults() as $result)
        {
            if ($result->getType() !== EventResult::ERROR)
            {
                $modified = $result->getModified();
 
                $enable = array_merge($enable, (array)($modified['ENABLE'] ?? []));
                $disable = array_merge($disable, (array)($modified['DISABLE'] ?? []));
            }
        }
 
        foreach (array_unique($enable) as $filter)
        {
            $this->enableFilter($filter);
        }
        foreach (array_unique($disable) as $filter)
        {
            $this->disableFilter($filter);
        }
    }

    public function enableFilter(string $filter): BlockRepo
    {
        if ($filter === self::FILTER_DEFAULTS)
        {
            $this->filters = self::DEFAULT_ACTIVE_FILTERS;
        }
        elseif (in_array($filter, self::AVAILABLE_FILTERS))
        {
            $this->filters[] = $filter;
            $this->filters = array_unique($this->filters);
        }
 
        return $this;
    }

    public function disableFilter(string $filter): BlockRepo
    {
        if (in_array($filter, self::AVAILABLE_FILTERS))
        {
            $this->filters = array_filter(
                $this->filters,
                function ($currentFilter) use ($filter) {
                    return $currentFilter !== $filter;
                }
            );
        }
 
        return $this;
    }

    public function isFilterActive(string $filter): bool
    {
        return in_array($filter, $this->filters);
    }

    public function isBlockInRepo(string $code): bool
    {
        $repo = $this->getRepository();
        foreach ($repo as $sectionCode => $category)
        {
            if ($sectionCode === self::SECTION_LAST)
            {
                continue;
            }
 
            $blocks = array_keys(($category['items'] ?? []));
            if (in_array($code, $blocks, true))
            {
                return true;
            }
        }
 
        return false;
    }

    public function getRepository(): array
    {
        // static cache
        if (!empty($this->repository))
        {
            return $this->getPreparedRepository();
        }
 
        return $this->loadRepositoryData()->getPreparedRepository();
    }
 
    private function loadRepositoryData(): static
    {
        // config
        $disableNamespace = (array)Config::get('disable_namespace');
        $enableNamespace = Config::get('enable_namespace');
        $enableNamespace = $enableNamespace ? (array)$enableNamespace : [];
 
        // system cache begin
        $cache = new \CPHPCache();
        $cacheTime = 86400;
        $cacheStarted = false;
        $cacheId = LANGUAGE_ID;
        $cacheId .= 'user:' . Manager::getUserId();
        $cacheId .= 'version:2';
        $cacheId .= 'disable:' . implode(',', $disableNamespace);
        $cacheId .= 'enable:' . implode(',', $enableNamespace);
        $cacheId .= 'specType:' . ($this->siteType ?? '');
        $cachePath = 'landing/blocks';
        if ($cache->initCache($cacheTime, $cacheId, $cachePath))
        {
            $this->repository = $cache->getVars();
            if (is_array($this->repository) && !empty($this->repository))
            {
                return $this->fillLastUsedBlocks();
            }
        }
        if ($cache->startDataCache($cacheTime, $cacheId, $cachePath))
        {
            $cacheStarted = true;
            if (Cache::isCaching())
            {
                Manager::getCacheManager()->startTagCache($cachePath);
                Manager::getCacheManager()->registerTag(self::BLOCKS_TAG);
            }
        }
 
        // not in cache - init
        $blocks = [];
        $sections = [];
 
        // general paths and namespaces
        $paths = self::getGeneralPaths();
        $namespaces = self::getNamespaces();
 
        //get all blocks with description-file
        sort($namespaces);
        foreach ($namespaces as $subdir)
        {
            foreach ($paths as $path)
            {
                $path = Manager::getDocRoot() . $path;
                if (
                    is_dir($path . '/' . $subdir)
                    && ($handle = opendir($path . '/' . $subdir))
                )
                {
                    // sections
                    $sectionsPath = $path . '/' . $subdir . '/.sections.php';
                    if (file_exists($sectionsPath))
                    {
                        $sections = array_merge(
                            $sections,
                            (array)include $sectionsPath
                        );
                    }
                    if (!isset($sections[self::SECTION_LAST]))
                    {
                        $sections[self::SECTION_LAST] = [
                            'name' => Loc::getMessage('LD_BLOCK_SECTION_LAST'),
                        ];
                    }
                    // blocks
                    while ((($entry = readdir($handle)) !== false))
                    {
                        $descriptionPath = $path . '/' . $subdir . '/' . $entry . '/.description.php';
                        $previewPathJpg = $path . '/' . $subdir . '/' . $entry . '/' . Block::PREVIEW_FILE_NAME;
                        if ($entry !== '.' && $entry !== '..' && file_exists($descriptionPath))
                        {
                            Loc::loadLanguageFile($descriptionPath);
                            $description = include $descriptionPath;
                            if (isset($description['block']['name']))
                            {
                                $previewFileName = Manager::getUrlFromFile(
                                    \getLocalPath(
                                        self::BLOCKS_DIR . '/' . $subdir . '/' . $entry . '/' . Block::PREVIEW_FILE_NAME
                                    )
                                );
                                $blocks[$entry] = [
                                    'id' => isset($description['block']['id'])
                                        ? (string)$description['block']['id']
                                        : null,
                                    'name' => $description['block']['name'],
                                    'namespace' => $subdir,
                                    'new' => self::isNewBlock($entry),
                                    'version' => $description['block']['version'] ?? null,
                                    'type' => $description['block']['type'] ?? [],
                                    'section' => $description['block']['section'] ?? 'other',
                                    'system' => (bool)($description['block']['system'] ?? false),
                                    'description' => $description['block']['description'] ?? '',
                                    'preview' => file_exists($previewPathJpg)
                                        ? $previewFileName
                                        : '',
                                    'restricted' => false,
                                    'repo_id' => false,
                                    'app_code' => false,
                                    'only_for_license' => $description['block']['only_for_license'] ?? '',
                                ];
                            }
                        }
                    }
                }
            }
        }
 
        // rest repo
        $blocksRepo = Repo::getRepository();
        // get apps by blocks
        $apps = [];
        foreach ($blocksRepo as $block)
        {
            if ($block['app_code'])
            {
                $apps[] = $block['app_code'];
            }
        }
        if ($apps)
        {
            $apps = array_unique($apps);
            $apps = Repo::getAppByCode($apps);
            // mark repo blocks expired
            foreach ($blocksRepo as &$block)
            {
                if (
                    $block['app_code']
                    && isset($apps[$block['app_code']])
                    && $apps[$block['app_code']]['PAYMENT_ALLOW'] == 'N'
                )
                {
                    $block['app_expired'] = true;
                }
            }
            unset($block);
        }
        $blocks += $blocksRepo;
 
        // favorites block
        $currentUser = Manager::getUserId();
        $favoriteBlocks = [];
        $favoriteMyBlocks = [];
        $res = Internals\BlockTable::getList([
            'select' => [
                'ID', 'CODE', 'FAVORITE_META', 'CREATED_BY_ID',
            ],
            'filter' => [
                'LID' => 0,
                '=DELETED' => 'N',
            ],
            'order' => [
                'ID' => 'desc',
            ],
            'limit' => self::FAVOURITE_BLOCKS_LIMIT,
        ]);
        $countFavoriteBlocks = 0;
        while ($row = $res->fetch())
        {
            $countFavoriteBlocks++;
            if (isset($blocks[$row['CODE']]))
            {
                if (!is_array($row['FAVORITE_META']))
                {
                    continue;
                }
                $meta = $row['FAVORITE_META'];
                $meta['preview'] = $meta['preview'] ?? 0;
                $meta['favorite'] = true;
                $meta['favoriteMy'] = ((int)$row['CREATED_BY_ID'] === $currentUser);
                if ($meta['preview'] > 0 && $countFavoriteBlocks < self::FAVOURITE_BLOCKS_LIMIT_WITH_PREVIEW)
                {
                    $meta['preview'] = File::getFilePath($meta['preview']);
                }
                else
                {
                    unset($meta['preview']);
                }
                if (isset($meta['section']))
                {
                    $meta['section'] = (array)$meta['section'];
                }
 
                $item = array_merge(
                    $blocks[$row['CODE']],
                    $meta
                );
                $code = $row['CODE'] . '@' . $row['ID'];
                if ($item['type'] === 'null')
                {
                    $item['type'] = [];
                }
 
                $meta['favoriteMy']
                    ? ($favoriteMyBlocks[$code] = $item)
                    : ($favoriteBlocks[$code] = $item);
            }
        }
        $blocks = $favoriteMyBlocks + $blocks + $favoriteBlocks;
 
        // create new section in repo
        $createNewSection = function ($item)
        {
            // todo: filter here?
            return [
                'name' => isset($item['name'])
                    ? (string)$item['name']
                    : (string)$item,
                'meta' => $item['meta'] ?? [],
                'new' => false,
                'type' => $item['type'] ?? null,
                'specialType' => $item['specialType'] ?? null,
                'separator' => false,
                'app_code' => false,
                'items' => [],
            ];
        };
 
        // set by sections
        $createdSects = [];
        foreach ($sections as $code => $item)
        {
            $title = $item['name'] ?? $item;
            $title = (string)$title;
            $title = trim($title);
            $this->repository[$code] = $createNewSection($item);
            $createdSects[$title] = $code;
        }
        foreach ($blocks as $key => $block)
        {
            if (!is_array($block['section']))
            {
                $block['section'] = [$block['section']];
            }
            foreach ($block['section'] as $section)
            {
                $section = trim($section);
                if (!$section)
                {
                    $section = 'other';
                }
                // adding new sections (actual for repo blocks)
                // todo: not add new section if can't
                if (!isset($this->repository[$section]))
                {
                    if (isset($createdSects[$section]))
                    {
                        $section = $createdSects[$section];
                    }
                    else
                    {
                        $this->repository[$section] = $createNewSection($section);
                    }
                }
                $this->repository[$section]['items'][$key] = $block;
                if ($block['new'])
                {
                    $this->repository[$section]['new'] = true;
                }
            }
        }
 
        // add apps sections
        if (!empty($blocksRepo) && !empty($apps))
        {
            $this->repository['separator_apps'] = [
                'name' => Loc::getMessage('LANDING_BLOCK_SEPARATOR_PARTNER_2_MSGVER_1'),
                'separator' => true,
                'items' => [],
            ];
            foreach ($apps as $app)
            {
                $this->repository[$app['CODE']] = [
                    'name' => $app['APP_NAME'],
                    'new' => false,
                    'separator' => false,
                    'app_code' => $app['CODE'],
                    'items' => [],
                ];
            }
            // add blocks to the app sections
            foreach ($blocksRepo as $key => $block)
            {
                if ($block['app_code'])
                {
                    $this->repository[$block['app_code']]['items'][$key] = $block;
                }
            }
        }
 
        // sort by id
        foreach ($this->repository as $codeCat => &$blocksCat)
        {
            $codeCat = mb_strtoupper($codeCat);
            uasort($blocksCat['items'], function ($item1, $item2) use ($codeCat)
            {
                if ($item1['repo_id'])
                {
                    return 1;
                }
                if ($item2['repo_id'])
                {
                    return 0;
                }
                if (
                    ($item1['id'] && $item2['id'])
                    && mb_strpos($item1['id'], 'BX_' . $codeCat . '_') === 0
                    && mb_strpos($item2['id'], 'BX_' . $codeCat . '_') === 0
                )
                {
                    return ($item1['id'] > $item2['id']) ? 1 : -1;
                }
 
                return 0;
            });
        }
        unset($blocksCat);
 
        // system cache end
        if ($cacheStarted)
        {
            $cache->endDataCache($this->repository);
            if (Cache::isCaching())
            {
                Manager::getCacheManager()->endTagCache();
            }
        }
 
        return $this->fillLastUsedBlocks();
    }
 
    private function fillLastUsedBlocks(): static
    {
        $request = Application::getInstance()->getContext()->getRequest();
        if ($request->get('landing_mode') !== 'edit')
        {
            return $this;
        }
 
        static $lastUsedItems = null;
        if ($lastUsedItems !== null)
        {
            $this->repository[self::SECTION_LAST]['items'] = $lastUsedItems;
 
            return $this;
        }
 
        $this->repository[self::SECTION_LAST]['items'] = [];
        $lastUsed = Block::getLastUsed();
        if (count($lastUsed) > 0)
        {
            foreach ($lastUsed as $code)
            {
                $this->repository[self::SECTION_LAST]['items'][$code] = [];
            }
            foreach ($this->repository as $catCode => &$cat)
            {
                foreach ($cat['items'] as $code => &$block)
                {
                    if (
                        in_array($code, $lastUsed)
                        && $catCode != self::SECTION_LAST
                        && !empty($block)
                    )
                    {
                        $block['section'][] = self::SECTION_LAST;
                        $this->repository[self::SECTION_LAST]['items'][$code] = $block;
                    }
                }
                unset($block);
            }
            unset($cat);
 
            // clear last-section
            foreach ($this->repository[self::SECTION_LAST]['items'] as $code => $block)
            {
                if (!$block)
                {
                    unset($this->repository[self::SECTION_LAST]['items'][$code]);
                }
            }
        }
 
        $lastUsedItems = $this->repository[self::SECTION_LAST]['items'];
 
        return $this;
    }
 
    private function getPreparedRepository(): array
    {
        $prepared = $this->filterRepository($this->repository);
 
        $event = new Event('landing', 'onBlockGetRepository', [
            'blocks' => $prepared,
        ]);
        $event->send();
        foreach ($event->getResults() as $result)
        {
            if ($result->getResultType() != EventResult::ERROR)
            {
                if (($modified = $result->getModified()))
                {
                    if (isset($modified['blocks']))
                    {
                        $prepared = array_merge($prepared, $modified['blocks']);
                    }
                }
            }
        }
 
        return $prepared;
    }

    private function filterRepository(array $repository): array
    {
        $prepareType = function (string|array $item): ?array
        {
            $type = (array)$item;
            $type = array_map('strtoupper', $type);
            if (in_array('PAGE', $type))
            {
                $type[] = 'SMN';
            }
            if (
                in_array('NULL', $type)
                || in_array('', $type)
            )
            {
                return null;
            }
 
            return $type;
        };
 
        $filtered = [];
 
        $isStoreEnabled = Manager::isStoreEnabled();
        $version = Manager::getVersion();
        $license = Loader::includeModule('bitrix24') ? \CBitrix24::getLicenseType() : null;
 
        foreach ($repository as $sectionCode => $section)
        {
            $sectionTypes = $prepareType($section['type'] ?? []);
 
            if (
                $this->isFilterActive(self::FILTER_SKIP_COMMON_BLOCKS)
                && empty($sectionTypes)
                && $sectionCode !== self::SECTION_LAST
            )
            {
                continue;
            }
 
            if (
                $this->isFilterActive(self::FILTER_SKIP_HIDDEN_BLOCKS)
                && $sectionTypes === null
            )
            {
                continue;
            }
 
            if (
                is_array($sectionTypes)
                && !empty($sectionTypes)
                && !in_array($this->siteType, $sectionTypes, true))
            {
                continue;
            }
 
            if ($sectionTypes === [self::TYPE_STORE] && !$isStoreEnabled)
            {
                continue;
            }
 
            $filtered[$sectionCode] = $section;
            $filtered[$sectionCode]['items'] = [];
 
            foreach ($section["items"] ?? [] as $blockCode => $block)
            {
                $blockTypes = $prepareType($block['type'] ?? []);
 
                if (
                    $this->isFilterActive(self::FILTER_SKIP_COMMON_BLOCKS)
                    && empty($blockTypes)
                )
                {
                    continue;
                }
 
                if (
                    $this->isFilterActive(self::FILTER_SKIP_HIDDEN_BLOCKS)
                    && $blockTypes === null
                )
                {
                    continue;
                }
 
                if (
                    is_array($blockTypes)
                    && !empty($blockTypes)
                    && !in_array($this->siteType, $blockTypes, true)
                )
                {
                    continue;
                }
 
                if (!empty($block['only_for_license']) && $block['only_for_license'] !== $license)
                {
                    continue;
                }
 
                if (
                    $this->isFilterActive(self::FILTER_SKIP_SYSTEM_BLOCKS)
                    && isset($block['system'])
                    && $block['system'] === true
                )
                {
                    continue;
                }
 
                $block['requires_updates'] =
                    ($block['version'] ?? null)
                    && version_compare($version, $block['version']) < 0;
 
                $filtered[$sectionCode]['items'][$blockCode] = $block;
            }
 
            if (empty($filtered[$sectionCode]['items']))
            {
                unset($filtered[$sectionCode]);
            }
        }
 
        return $filtered;
    }

    public function clearCache(): static
    {
        if (Cache::isCaching())
        {
            Manager::getCacheManager()->clearByTag(self::BLOCKS_TAG);
        }
 
        return $this;
    }

    public static function getGeneralPaths(): ?array
    {
        static $paths = null;
 
        if (!$paths)
        {
            $paths = [
                BX_ROOT . '/' . self::BLOCKS_DIR,
                \getLocalPath(self::BLOCKS_DIR),
            ];
            if ($paths[0] == $paths[1])
            {
                unset($paths[1]);
            }
        }
 
        return $paths;
    }

    public static function getNamespaces(): array
    {
        static $namespaces = [];
 
        if ($namespaces)
        {
            return $namespaces;
        }
 
        $paths = self::getGeneralPaths();
        $disableNamespace = (array)Config::get('disable_namespace');
        $enableNamespace = Config::get('enable_namespace');
        $enableNamespace = $enableNamespace ? (array)$enableNamespace : [];
 
        $namespaces = [];
        foreach ($paths as $path)
        {
            if ($path !== false)
            {
                $path = Manager::getDocRoot() . $path;
                // read all subdirs ($namespaces) in block dir
                if (($handle = opendir($path)))
                {
                    while ((($entry = readdir($handle)) !== false))
                    {
                        if (!empty($enableNamespace))
                        {
                            if (in_array($entry, $enableNamespace))
                            {
                                $namespaces[] = $entry;
                            }
                        }
                        elseif (
                            $entry != '.' && $entry != '..'
                            && is_dir($path . '/' . $entry)
                            && !in_array($entry, $disableNamespace)
                        )
                        {
                            $namespaces[] = $entry;
                        }
                    }
                }
            }
        }
        $namespaces = array_unique($namespaces);
 
        return $namespaces;
    }

    protected static function isNewBlock(string $block): bool
    {
        static $newBlocks = null;
 
        if ($newBlocks === null)
        {
            $newBlocks = unserialize(Manager::getOption('new_blocks'), ['allowed_classes' => false]);
            if (!is_array($newBlocks))
            {
                $newBlocks = [];
            }
            if (
                !isset($newBlocks['date'])
                || ((time() - $newBlocks['date']) > self::NEW_BLOCK_LT)
            )
            {
                $newBlocks = [];
            }
            if (isset($newBlocks['items']))
            {
                $newBlocks = $newBlocks['items'];
            }
        }
 
        return in_array($block, $newBlocks);
    }
}