state.php

<?php
 
namespace Bitrix\Catalog\Config;
 
use Bitrix\Main;
use Bitrix\Main\Loader;
use Bitrix\Main\ModuleManager;
use Bitrix\Main\Localization\Loc;
use Bitrix\Iblock;
use Bitrix\Catalog;
use Bitrix\Landing;
use Bitrix\Crm;
 
final class State
{
    private static $landingSections;
    private static $iblockSections;
    private static $fullIblockSections;
    private static $elementCount;
    private static $iblockList = [];
    private static $crmIncluded;
 
    public static function isUsedInventoryManagement(): bool
    {
        if (!Feature::isInventoryManagementEnabled())
        {
            return false;
        }
 
        return self::isEnabledInventoryManagement();
    }
 
    public final static function isEnabledInventoryManagement(): bool
    {
        return (Main\Config\Option::get('catalog', 'default_use_store_control') === 'Y');
    }
 
    public static function isShowedStoreReserve(): bool
    {
        if (!self::isUsedInventoryManagement())
        {
            return false;
        }
        if (
            Main\Config\Option::get('catalog', 'enable_reservation') === 'Y'
            && Main\Config\Option::get('catalog', 'show_store_reserve') === 'Y'
        )
        {
            return true;
        }
        if (self::isCrmIncluded())
        {
            return (Main\Config\Option::get('crm', 'enable_order_deal_create') === 'Y');
        }
 
        return false;
    }
 
    public static function isExceededPriceTypeLimit(): bool
    {
        if (Feature::isMultiPriceTypesEnabled())
        {
            return false;
        }
 
        return Catalog\GroupTable::getCount([], ['ttl' => 86400]) > 1;
    }
 
    public static function isAllowedNewPriceType(): bool
    {
        if (Feature::isMultiPriceTypesEnabled())
        {
            return true;
        }
 
        return Catalog\GroupTable::getCount([], ['ttl' => 86400]) === 0;
    }
 
    public static function isExceededStoreLimit(): bool
    {
        if (Feature::isMultiStoresEnabled())
        {
            return false;
        }
 
        return Catalog\StoreTable::getCount([], ['ttl' => 86400]) > 1;
    }
 
    public static function isAllowedNewStore(): bool
    {
        if (Feature::isMultiStoresEnabled())
        {
            return true;
        }
 
        return Catalog\StoreTable::getCount([], ['ttl' => 86400]) === 0;
    }
 
    public static function getExceedingProductLimit(int $iblockId, ?int $sectionId = null): ?array
    {
        if ($iblockId <= 0)
        {
            return null;
        }
 
        if (!ModuleManager::isModuleInstalled('bitrix24'))
        {
            return null;
        }
 
        if ($iblockId !== self::getCrmCatalogId())
        {
            return null;
        }
 
        $result = self::checkIblockLimit($iblockId);
        if ($result !== null && $sectionId !== null)
        {
            self::loadIblockSections($iblockId);
            if (!isset(self::$fullIblockSections[$sectionId]))
            {
                $result = null;
            }
        }
        if ($result === null)
        {
            $result = self::getCrmCatalogLimit($iblockId);
        }
 
        return $result;
    }
 
    public static function getCrmExceedingProductLimit(): ?array
    {
        $crmCatalogId = self::getCrmCatalogId();
        if ($crmCatalogId > 0)
        {
            return self::getExceedingProductLimit($crmCatalogId);
        }
 
        return null;
    }
 
    public static function getProductLimitState(int $iblockId): ?array
    {
        if ($iblockId <= 0)
        {
            return null;
        }
 
        if (!ModuleManager::isModuleInstalled('bitrix24'))
        {
            return null;
        }
 
        if ($iblockId !== self::getCrmCatalogId())
        {
            return null;
        }
 
        $result = [];
        $variable = Feature::getLandingLimitVariable();
        $result[$variable] = [
            'LIMIT_NAME' => $variable,
            'LIMIT_VALUE' => Feature::getLandingProductLimit(),
            'CURRENT_VALUE' => self::getElementCount($iblockId),
        ];
 
        $crmLimit = self::getCrmCatalogLimitState($iblockId);
        if ($crmLimit !== null)
        {
            $result[$crmLimit['LIMIT_NAME']] = $crmLimit;
        }
 
        return $result;
    }
 
    public static function handlerBeforeIblockElementAdd(array &$fields): bool
    {
        if (!self::checkIblockId($fields))
        {
            return true;
        }
 
        $limit = self::checkIblockLimit((int)$fields['IBLOCK_ID']);
        if (empty($limit))
        {
            return true;
        }
 
        if (!isset($fields['IBLOCK_SECTION']) || !is_array($fields['IBLOCK_SECTION']))
        {
            return true;
        }
        $sections = $fields['IBLOCK_SECTION'];
        Main\Type\Collection::normalizeArrayValuesByInt($sections, true);
        if (empty($sections))
        {
            return true;
        }
        self::loadIblockSections((int)$fields['IBLOCK_ID']);
        $sections = array_intersect($sections, self::$fullIblockSections);
        if (empty($sections))
        {
            return true;
        }
        unset($sections);
 
        self::setProductLimitError($limit['MESSAGE']);
        unset($limit);
 
        return false;
    }
 
    public static function handlerAfterIblockElementAdd(array &$fields): void
    {
        if ($fields['RESULT'] === false)
            return;
 
        if (!self::checkIblockId($fields))
            return;
 
        $sections = $fields['IBLOCK_SECTION'] ?? null;
        Main\Type\Collection::normalizeArrayValuesByInt($sections, true);
        if (empty($sections))
            return;
        self::loadIblockSections((int)$fields['IBLOCK_ID']);
        $sections = array_intersect($sections, self::$fullIblockSections);
        if (empty($sections))
            return;
 
        self::$elementCount = null;
    }
 
    public static function handlerBeforeIblockElementUpdate(array &$fields): bool
    {
        if (!self::checkIblockId($fields))
        {
            return true;
        }
 
        $limit = self::checkIblockLimit((int)$fields['IBLOCK_ID']);
        if (empty($limit))
        {
            return true;
        }
 
        if (!isset($fields['IBLOCK_SECTION']) || !is_array($fields['IBLOCK_SECTION']))
        {
            return true;
        }
        $sections = $fields['IBLOCK_SECTION'];
        Main\Type\Collection::normalizeArrayValuesByInt($sections, true);
        if (empty($sections))
        {
            return true;
        }
        self::loadIblockSections((int)$fields['IBLOCK_ID']);
        $sections = array_intersect($sections, self::$fullIblockSections);
        if (empty($sections))
        {
            return true;
        }
        unset($sections);
 
        $notMove = false;
        $iterator = Iblock\SectionElementTable::getList([
            'select' => ['IBLOCK_SECTION_ID'],
            'filter' => [
                '=IBLOCK_ELEMENT_ID' => $fields['ID'],
                '=ADDITIONAL_PROPERTY_ID' => null,
            ],
        ]);
        while ($row = $iterator->fetch())
        {
            $row['ID'] = (int)$row['ID'];
            if (isset(self::$fullIblockSections[$row['ID']]))
            {
                $notMove = true;
                break;
            }
        }
        unset($row, $iterator);
        if ($notMove)
        {
            return true;
        }
 
        self::setProductLimitError($limit['MESSAGE']);
        unset($limit);
 
        return false;
    }
 
    public static function handlerAfterIblockElementUpdate(array &$fields): void
    {
        if ($fields['RESULT'] === false)
        {
            return;
        }
        if (!self::checkIblockId($fields))
        {
            return;
        }
        if (!array_key_exists('IBLOCK_SECTION', $fields))
        {
            return;
        }
 
        self::$elementCount = null;
    }
 
    public static function handlerAfterIblockElementDelete(array $fields): void
    {
        if (!self::checkIblockId($fields))
            return;
 
        self::$elementCount = null;
    }
 
    public static function handlerAfterIblockSectionAdd(array &$fields): void
    {
        if ($fields['RESULT'] === false)
            return;
        if (!self::checkIblockId($fields))
            return;
 
        self::$iblockSections = null;
        self::$fullIblockSections = null;
    }
 
    public static function handlerBeforeIblockSectionUpdate(array &$fields): bool
    {
        if (!self::checkIblockId($fields))
        {
            return true;
        }
 
        $limit = self::getIblockLimit((int)$fields['IBLOCK_ID']);
        if ($limit['LIMIT'] === 0)
        {
            return true;
        }
        if (!array_key_exists('IBLOCK_SECTION_ID', $fields))
        {
            return true;
        }
        $parentId = (int)$fields['IBLOCK_SECTION_ID'];
        self::loadIblockSections((int)$fields['IBLOCK_ID']);
        if (!isset(self::$fullIblockSections[$parentId]))
        {
            return true;
        }
        $iterator = Iblock\SectionTable::getList([
            'select' => ['IBLOCK_SECTION_ID'],
            'filter' => [
                '=ID' => $fields['ID'],
                '=IBLOCK_ID' => $fields['IBLOCK_ID'],
            ],
        ]);
        $row = $iterator->fetch();
        unset($iterator);
        if (empty($row))
        {
            return true;
        }
        $oldParentId = (int)$row['IBLOCK_SECTION_ID'];
        if (isset(self::$fullIblockSections[$oldParentId]))
        {
            return true;
        }
 
        $count = (int)\CIBlockElement::GetList(
            [],
            [
                'IBLOCK_ID' => $fields['IBLOCK_ID'],
                'SECTION_ID' => $fields['ID'],
                'INCLUDE_SUBSECTIONS' => 'Y',
                'CHECK_PERMISSIONS' => 'N',
            ],
            [],
            false,
            ['ID']
        );
        if ($count === 0)
        {
            return true;
        }
        $limit['COUNT'] += $count;
        if ($limit['COUNT'] <= $limit['LIMIT'])
        {
            return true;
        }
 
        $limit['MESSAGE_ID'] = 'CATALOG_STATE_ERR_PRODUCT_IN_SECTION_LIMIT';
 
        self::setProductLimitError(self::getProductLimitError($limit));
        unset($limit);
 
        return false;
    }
 
    public static function handlerAfterIblockSectionUpdate(array &$fields): void
    {
        if ($fields['RESULT'] === false)
        {
            return;
        }
        if (!self::checkIblockId($fields))
        {
            return;
        }
        if (!array_key_exists('IBLOCK_SECTION_ID', $fields))
        {
            return;
        }
 
        self::$iblockSections = null;
        self::$fullIblockSections = null;
        self::$elementCount = null;
    }
 
    public static function handlerAfterIblockSectionDelete(array $fields)
    {
        if (!self::checkIblockId($fields))
            return;
 
        self::$iblockSections = null;
        self::$fullIblockSections = null;
        self::$elementCount = null;
    }
 
    private static function getElementCount(int $iblockId): int
    {
        if (self::$elementCount === null)
        {
            self::$elementCount = 0;
 
            $iblockSectionIds = self::getIblockSections($iblockId);
            if (!empty($iblockSectionIds))
            {
                $filter = [
                    'IBLOCK_ID' => $iblockId,
                    'SECTION_ID' => $iblockSectionIds,
                    'INCLUDE_SUBSECTIONS' => 'Y',
                    'CHECK_PERMISSIONS' => 'N',
                ];
                $filter = Catalog\Product\SystemField\ProductMapping::getExtendedFilterByArea(
                    $filter,
                    Catalog\Product\SystemField\ProductMapping::MAP_LANDING
                );
                self::$elementCount = (int)\CIBlockElement::GetList(
                    [],
                    $filter,
                    [],
                    false,
                    ['ID']
                );
            }
            unset($iblockSectionIds);
        }
        return self::$elementCount;
    }
 
    private static function getIblockSections(int $iblockId): array
    {
        if (self::$iblockSections === null)
        {
            self::loadIblockSections($iblockId);
        }
        return self::$iblockSections;
    }
 
    private static function loadIblockSections(int $iblockId): void
    {
        if (self::$iblockSections === null)
        {
            self::$iblockSections = [];
            self::$fullIblockSections = [];
            $sections = self::getLandingSections();
            if (!empty($sections))
            {
                $iterator = Iblock\SectionTable::getList([
                    'select' => [
                        'ID',
                        'LEFT_MARGIN',
                        'RIGHT_MARGIN',
                    ],
                    'filter' => [
                        '=IBLOCK_ID' => $iblockId,
                        '@ID' => $sections,
                    ]
                ]);
                while ($row = $iterator->fetch())
                {
                    $row['ID'] = (int)$row['ID'];
                    self::$iblockSections[] = $row['ID'];
                    self::$fullIblockSections[$row['ID']] = $row['ID'];
                    $sublist = Iblock\SectionTable::getList([
                        'select' => ['ID'],
                        'filter' => [
                            '=IBLOCK_ID' => $iblockId,
                            '>LEFT_MARGIN' => $row['LEFT_MARGIN'],
                            '<RIGHT_MARGIN' => $row['RIGHT_MARGIN'],
                        ]
                    ]);
                    while ($sub = $sublist->fetch())
                    {
                        $sub['ID'] = (int)$sub['ID'];
                        self::$fullIblockSections[$sub['ID']] = $sub['ID'];
                    }
                }
                unset($sub, $sublist, $row, $iterator);
            }
            unset($sections);
        }
    }
 
    private static function getLandingSections(): array
    {
        if (self::$landingSections === null)
        {
            self::$landingSections = [];
 
            if (!Loader::includeModule('landing'))
            {
                return self::$landingSections;
            }
 
            $iterator = Landing\Internals\HookDataTable::getList([
                'runtime' => [
                    new Main\ORM\Fields\Relations\Reference(
                        'TMP_LANDING_SITE',
                        'Bitrix\Landing\Internals\SiteTable',
                        ['=this.ENTITY_ID' => 'ref.ID']
                    )
                ],
                'select' => ['VALUE'],
                'filter' => [
                    '=ENTITY_TYPE' => Landing\Hook::ENTITY_TYPE_SITE,
                    '=HOOK' => 'SETTINGS',
                    '=CODE' => 'SECTION_ID',
                    '=TMP_LANDING_SITE.DELETED' => 'N',
                ],
                'cache' => ['ttl' => 86400],
            ]);
            while ($row = $iterator->fetch())
            {
                $id = (int)$row['VALUE'];
                if ($id <= 0)
                {
                    continue;
                }
                self::$landingSections[$id] = $id;
            }
            unset($id, $row, $iterator);
 
            if (!empty(self::$landingSections))
            {
                self::$landingSections = array_values(self::$landingSections);
            }
        }
 
        return self::$landingSections;
    }
 
    private static function getCrmCatalogId(): ?int
    {
        $result = null;
        if (self::isCrmIncluded())
        {
            $result = Crm\Product\Catalog::getDefaultId();
        }
 
        return $result;
    }
 
    private static function getCrmCatalogLimit(int $iblockId): ?array
    {
        if (!self::isCrmIncluded())
        {
            return null;
        }
 
        return Crm\Config\State::getExceedingProductLimit($iblockId);
    }
 
    private static function getCrmCatalogLimitState(int $iblockId): ?array
    {
        if (!self::isCrmIncluded())
        {
            return null;
        }
 
        if (!method_exists('\Bitrix\Crm\Config\State', 'getProductLimitState'))
        {
            return null;
        }
 
        return Crm\Config\State::getProductLimitState($iblockId);
    }
 
    private static function isCrmIncluded(): bool
    {
        if (self::$crmIncluded === null)
        {
            self::$crmIncluded = Loader::includeModule('crm');
        }
 
        return self::$crmIncluded;
    }
 
    private static function checkIblockId(array $fields): bool
    {
        if (!isset($fields['IBLOCK_ID']))
        {
            return false;
        }
        $iblockId = (int)$fields['IBLOCK_ID'];
        if ($iblockId <= 0)
        {
            return false;
        }
        if (!isset(self::$iblockList[$iblockId]))
        {
            $result = true;
            if (!ModuleManager::isModuleInstalled('bitrix24'))
            {
                $result = false;
            }
            if ($iblockId !== self::getCrmCatalogId())
            {
                $result = false;
            }
            self::$iblockList[$iblockId] = $result;
        }
 
        return self::$iblockList[$iblockId];
    }
 
    private static function checkIblockLimit(int $iblockId): ?array
    {
        $result = self::getIblockLimit($iblockId);
        if (
            $result['LIMIT'] === 0
            || $result['COUNT'] < $result['LIMIT']
        )
        {
            return null;
        }
        $result['MESSAGE'] = self::getProductLimitError($result);
        unset($result['MESSAGE_ID']);
        $result['HELP_MESSAGE'] = Feature::getProductLimitHelpLink();
 
        return $result;
    }
 
    private static function getIblockLimit(int $iblockId): array
    {
        $result = [
            'COUNT' => 0,
            'LIMIT' => Feature::getLandingProductLimit(),
            'MESSAGE_ID' => 'CATALOG_STATE_ERR_PRODUCT_LIMIT_1'
        ];
        if ($result['LIMIT'] === 0)
        {
            return $result;
        }
        $result['COUNT'] = self::getElementCount($iblockId);
 
        return $result;
    }
 
    private static function getProductLimitError(array $limit): ?string
    {
        if (!isset($limit['COUNT']) || !isset($limit['LIMIT']) || !isset($limit['MESSAGE_ID']))
        {
            return null;
        }
 
        return Loc::getMessage(
            $limit['MESSAGE_ID'],
            [
                '#COUNT#' => $limit['COUNT'],
                '#LIMIT#' => $limit['LIMIT']
            ]
        );
    }
 
    private static function setProductLimitError(string $errorMessage): void
    {
        global $APPLICATION;
 
        $error = new \CAdminException([
            [
                'text' => $errorMessage,
            ]
        ]);
        $APPLICATION->ThrowException($error);
    }
 
    public static function isProductCardSliderEnabled(): bool
    {
        if (!Feature::isCommonProductProcessingEnabled())
        {
            return false;
        }
 
        return Main\Config\Option::get('catalog', 'product_card_slider_enabled') === 'Y';
    }
 
    public static function isProductBatchMethodSelected(): bool
    {
        if (!Feature::isStoreBatchEnabled())
        {
            return false;
        }
 
        return \Bitrix\Catalog\Product\Store\CostPriceCalculator::getMethod() !== '';
    }
}