gridcomponent.php

<?php
 
namespace Bitrix\Iblock\Component\Grid;
 
use Bitrix\Iblock\Integration\UI\Grid\General\BaseProvider;
use Bitrix\Main\AccessDeniedException;
use Bitrix\Main\Context;
use Bitrix\Main\Filter\Filter;
use Bitrix\Main\Grid\MessageType;
use Bitrix\Main\Grid\Options;
use Bitrix\Main\HttpRequest;
use Bitrix\Main\Localization\Loc;
use Bitrix\Main\Result;
use Bitrix\Main\UI\PageNavigation;
use Bitrix\Main\Web\Json;
use Bitrix\Main\Web\PostDecodeFilter;
use CBitrixComponent;
use CMain;
use Iterator;
use Throwable;
 
abstract class GridComponent extends CBitrixComponent
{
    private array $rowsFilter;
    private Options $gridOptions;
 
    protected PageNavigation $pagination;
 
    abstract protected function getRawRows(array $params);
 
    abstract protected function getFilter(): ?Filter;
 
    abstract protected function getTotalCount(): int;
 
    abstract protected function getGridProvider(): BaseProvider;
 
    protected function getGridOptions(): Options
    {
        $this->gridOptions ??= new Options($this->getGridProvider()->getId());
 
        return $this->gridOptions;
    }
 
    protected function init(): void
    {
    }
 
    protected function initRows(): void
    {
        $params = [
            'select' => $this->getRowsSelect(),
            'filter' => $this->getRowsFilter(),
            'order' => $this->getRowsSorting(),
        ];
 
        $pagination = $this->getRowsPagination();
        if ($pagination)
        {
            $params['limit'] = $pagination->getLimit();
            $params['offset'] = $pagination->getOffset();
        }
 
        $rows = [];
        foreach ($this->getRawRows($params) as $row)
        {
            $rows[] = $this->prepareRow($row);
        }
 
        $this->getGridProvider()->setRows($rows);
 
        if ($pagination)
        {
            $this->getGridProvider()->setNavObject($pagination);
        }
    }
 
    protected function prepareRow(array $row): array
    {
        return $this->getGridProvider()->prepareRow($row);
    }
 
    protected function initResult(): void
    {
        $this->arResult['GRID'] = $this->getGridProvider()->toArray();
    }
 
    protected function initToolbar(): void
    {
    }
 
    public function executeComponent()
    {
        try
        {
            $this->init();
 
            if (!$this->checkReadPermissions())
            {
                throw new AccessDeniedException();
            }
 
            $this->processActionsGrid();
 
            $this->initRows();
            $this->initResult();
            $this->initToolbar();
 
            $this->includeComponentTemplate();
        }
        catch (AccessDeniedException $e)
        {
            $this->arResult['ERROR'] = Loc::getMessage('IBLOCK_GRID_COMPONENT_ERROR_ACCESS_DENIED');
            $this->includeComponentTemplate('error');
        }
    }
 
    protected function checkReadPermissions(): bool
    {
        return true;
    }
 
    final protected function getRowsFilter(): array
    {
        if (isset($this->rowsFilter))
        {
            return $this->rowsFilter;
        }
 
        $filterObject = $this->getFilter();
        if ($filterObject)
        {
            $this->rowsFilter = $filterObject->getValue();
        }
        else
        {
            $this->rowsFilter = [];
        }
 
        $additionalFilter = $this->getAdditionalRowsFilter();
        if (isset($additionalFilter))
        {
            $this->rowsFilter[] = $additionalFilter;
        }
 
        return $this->rowsFilter;
    }
 
    protected function getAdditionalRowsFilter(): ?array
    {
        return null;
    }
 
    protected function getRowsSelect(): array
    {
        $columns = array_column($this->getGridProvider()->getColumns(), 'id');
 
        return array_filter($columns);
    }
 
    protected function getRowsSorting(): array
    {
        return $this->getGridOptions()->getSorting()['sort'];
    }
 
    protected function getRowsPagination(): ?PageNavigation
    {
        if (!isset($this->pagination))
        {
            $this->pagination = new PageNavigation('page');
            $this->pagination->setPageSizes(
                $this->getPageSizes()
            );
            $this->pagination->setRecordCount(
                $this->getTotalCount()
            );
 
            $this->initFromGrid($this->pagination);
            $this->pagination->initFromUri();
        }
 
        return $this->pagination;
    }
 
    protected function getPageSizes(): array
    {
        $gridSizes = $this->getGridProvider()->getPageSizes();
        $gridSizes = array_column($gridSizes, 'VALUE');
 
        \Bitrix\Main\Type\Collection::normalizeArrayValuesByInt($gridSizes);
 
        return $gridSizes;
    }
 
    private function initFromGrid(PageNavigation $pagination): void
    {
        $params = $this->getGridOptions()->GetNavParams();
        $pagination->setPageSize((int)$params['nPageSize']);
    }
 
    protected function processActionsGrid(): void
    {
        $request = Context::getCurrent()->getRequest();
        $request->addFilter(new PostDecodeFilter);
 
        $actionName = 'action_button_' . $this->getGridProvider()->getId();
        $action = $request->getPost($actionName);
 
        if (isset($action))
        {
            try
            {
                $result = $this->processActionGrid($action, $request);
                if (isset($result) && !$result->isSuccess())
                {
                    $this->sendErrorsResponse(
                        $result->getErrorMessages()
                    );
                }
            }
            catch (AccessDeniedException $e)
            {
                $this->sendErrorsResponse([
                    Loc::getMessage('IBLOCK_GRID_COMPONENT_ERROR_ACCESS_DENIED')
                ]);
            }
            catch (Throwable $e)
            {
                $this->sendErrorsResponse([
                    $e->getMessage()
                ]);
            }
        }
    }
 
    protected function sendErrorsResponse(array $messages): void
    {
        global $APPLICATION;
 
        $APPLICATION->RestartBuffer();
 
        foreach ($messages as &$message)
        {
            if (is_array($message) && isset($message['TEXT']))
            {
                $message = [
                    'TYPE' => $message['TYPE'] ?? MessageType::ERROR,
                    'TEXT' => $message['TEXT'],
                ];
            }
            else
            {
                $message = [
                    'TYPE' => MessageType::ERROR,
                    'TEXT' => (string)$message,
                ];
            }
        }
        unset($message);
 
        CMain::FinalActions(
            Json::encode([
                'messages' => $messages,
            ])
        );
    }
 
    protected function processActionGrid(string $actionName, HttpRequest $request): ?Result
    {
        return null;
    }
}