manager.php

<?php
namespace Bitrix\Iblock\PropertyIndex;
 
use Bitrix\Main\ModuleManager;
use Bitrix\Main\Loader;
use Bitrix\Main\Localization\Loc;
use Bitrix\Iblock;
 
class Manager
{
    private static $catalog = null;
 
    private static $deferredIndexing = -1;
 
    private static $elementQueue = array();
 
    private static $indexerInstances = array();
 
    public static function resolveIblock($iblockId)
    {
        if (self::$catalog === null)
        {
            self::$catalog = Loader::includeModule("catalog");
        }
 
        if (self::$catalog)
        {
            $catalog = \CCatalogSKU::getInfoByOfferIBlock($iblockId);
            if (!empty($catalog) && is_array($catalog))
            {
                return $catalog["PRODUCT_IBLOCK_ID"];
            }
        }
 
        return $iblockId;
    }
 
    public static function resolveElement($iblockId, $elementId)
    {
        if (self::$catalog === null)
        {
            self::$catalog = Loader::includeModule("catalog");
        }
 
        if (self::$catalog)
        {
            $catalog = \CCatalogSKU::getProductInfo($elementId, $iblockId);
            if (!empty($catalog) && is_array($catalog))
            {
                return $catalog["ID"];
            }
        }
 
        return $elementId;
    }
 
    public static function dropIfExists($iblockId)
    {
        $storage = new Storage($iblockId);
        if ($storage->isExists())
            $storage->drop();
 
        $dictionary = new Dictionary($iblockId);
        if ($dictionary->isExists())
            $dictionary->drop();
    }
 
    public static function createIndexer($iblockId)
    {
        $iblockId = (int)$iblockId;
        $productIblock = self::resolveIblock($iblockId);
        if (!isset(self::$indexerInstances[$productIblock]))
        {
            $indexer = new Indexer($productIblock);
            $indexer->init();
            self::$indexerInstances[$productIblock] = $indexer;
            unset($indexer);
        }
        return self::$indexerInstances[$productIblock];
    }
 
    public static function markAsInvalid($iblockId)
    {
        Iblock\IblockTable::update($iblockId, array(
            "PROPERTY_INDEX" => "I",
        ));
 
        $productIblock = self::resolveIblock($iblockId);
        if ($iblockId != $productIblock)
        {
            Iblock\IblockTable::update($productIblock, array(
                "PROPERTY_INDEX" => "I",
            ));
        }
 
        self::checkAdminNotification(true);
    }
 
    public static function onPropertyUpdate($iblockId, $propertyOld, $propertyNew)
    {
        if (array_key_exists("USER_TYPE", $propertyNew))
        {
            $storageOld = Iblock\PropertyIndex\Indexer::getPropertyStorageType($propertyOld);
            $storageNew = Iblock\PropertyIndex\Indexer::getPropertyStorageType($propertyNew);
            if ($storageOld !== $storageNew)
            {
                self::markAsInvalid($iblockId);
            }
        }
    }
 
    public static function checkAdminNotification($force = false)
    {
        if ($force)
        {
            $add = true;
        }
        else
        {
            $iblockList = Iblock\IblockTable::getList(array(
                'select' => array('ID'),
                'filter' => array('=PROPERTY_INDEX' => 'I'),
            ));
            $add = (bool)$iblockList->fetch();
        }
 
        if (ModuleManager::isModuleInstalled('bitrix24'))
        {
            $add = false;
        }
 
        if ($add)
        {
            $notifyList = \CAdminNotify::getList(array(), array(
                "TAG" => "iblock_property_reindex",
            ));
            if (!$notifyList->fetch())
            {
                \CAdminNotify::add(array(
                    "MESSAGE" => Loc::getMessage("IBLOCK_NOTIFY_PROPERTY_REINDEX", array(
                        "#LINK#" => "/bitrix/admin/iblock_reindex.php?lang=".\Bitrix\Main\Application::getInstance()->getContext()->getLanguage(),
                    )),
                    "TAG" => "iblock_property_reindex",
                    "MODULE_ID" => "iblock",
                    "ENABLE_CLOSE" => "Y",
                    "PUBLIC_SECTION" => "N",
                ));
            }
        }
        else
        {
            \CAdminNotify::deleteByTag("iblock_property_reindex");
        }
    }
    public static function deleteIndex($iblockId)
    {
        self::dropIfExists($iblockId);
        Iblock\IblockTable::update($iblockId, array(
            "PROPERTY_INDEX" => "N",
        ));
    }
 
    public static function deleteElementIndex($iblockId, $elementId)
    {
        $elementId = (int)$elementId;
        $productIblock = self::resolveIblock($iblockId);
        $indexer = self::createIndexer($productIblock);
 
        if ($indexer->isExists())
        {
            if ($iblockId != $productIblock)
            {
                self::updateElementIndex($iblockId, $elementId);
            }
            else
            {
                $indexer->deleteElement($elementId);
            }
        }
    }
 
    public static function updateElementIndex($iblockId, $elementId)
    {
        $elementId = (int)$elementId;
        $productIblock = self::resolveIblock($iblockId);
        if ($iblockId != $productIblock)
            $elementId = self::resolveElement($iblockId, $elementId);
        if (self::usedDeferredIndexing())
        {
            self::pushToQueue($productIblock, $elementId);
        }
        else
        {
            $indexer = self::createIndexer($productIblock);
            if ($indexer->isExists())
            {
                self::elementIndexing($indexer, $elementId);
            }
            unset($indexer);
        }
    }
 
    public static function enableDeferredIndexing()
    {
        self::$deferredIndexing++;
    }
 
    public static function disableDeferredIndexing()
    {
        self::$deferredIndexing--;
    }
 
    public static function usedDeferredIndexing()
    {
        return (self::$deferredIndexing >= 0);
    }
 
    public static function runDeferredIndexing($iblockId)
    {
        $iblockId = (int)$iblockId;
        $productIblock = self::resolveIblock($iblockId);
        if (empty(self::$elementQueue[$productIblock]))
            return;
        $indexer = self::createIndexer($productIblock);
        if ($indexer->isExists())
        {
            sort(self::$elementQueue[$productIblock]);
 
            foreach (self::$elementQueue[$productIblock] as $elementId)
                self::elementIndexing($indexer, $elementId);
            unset($elementId);
        }
        unset($indexer);
        unset(self::$elementQueue[$productIblock]);
    }
 
    private static function pushToQueue($iblockId, $elementId)
    {
        if (!isset(self::$elementQueue[$iblockId]))
            self::$elementQueue[$iblockId] = [];
        self::$elementQueue[$iblockId][$elementId] = $elementId;
    }
 
    private static function elementIndexing(Iblock\PropertyIndex\Indexer $indexer, $elementId)
    {
        $indexer->deleteElement($elementId);
        $connection = \Bitrix\Main\Application::getConnection();
        $elementCheck = $connection->query("
                SELECT BE.ID
                FROM b_iblock_element BE
                WHERE BE.ACTIVE = 'Y' AND BE.ID = ".$elementId.
                \CIBlockElement::wf_getSqlLimit("BE.", "N")
        );
        if ($elementCheck->fetch())
        {
            $indexer->indexElement($elementId);
        }
        unset($elementCheck, $connection);
    }
}