grid.php

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

<?php
 
namespace Bitrix\Main\Grid;
 
use Bitrix\Main\Context;
use Bitrix\Main\Filter\Filter;
use Bitrix\Main\Grid\Action\Action;
use Bitrix\Main\Grid\Action\PaginationAction;
use Bitrix\Main\Grid\Column\Column;
use Bitrix\Main\Grid\Column\Columns;
use Bitrix\Main\Grid\Pagination\PageNavigationStorage;
use Bitrix\Main\Grid\Pagination\Storage\StorageSupporter;
use Bitrix\Main\Grid\Panel\Panel;
use Bitrix\Main\Grid\Row\Assembler\EmptyRowAssembler;
use Bitrix\Main\Grid\Row\Rows;
use Bitrix\Main\Grid\UI\GridResponse;
use Bitrix\Main\Grid\UI\Request\GridRequestFactory;
use Bitrix\Main\Grid\UI\Response\GridResponseFactory;
use Bitrix\Main\HttpRequest;
use Bitrix\Main\UI\PageNavigation;

abstract class Grid
{
    use StorageSupporter;
    use DeprecatedMethods;
 
    private array $rawRows;
    private Options $options;
    private Settings $settings;
    private Columns $columns;
    private Rows $rows;
 
    // optional
    private ?Panel $panel = null;
    private ?Filter $filter = null;
    private ?PageNavigation $pagination = null;
 
    // internal
    private array $actionsMap;
    protected GridRequestFactory $gridRequestFactory;
    protected GridResponseFactory $gridResponseFactory;

    public function __construct(Settings $settings)
    {
        $this->settings = $settings;
        $this->gridRequestFactory = new GridRequestFactory;
        $this->gridResponseFactory = new GridResponseFactory;
    }
 
    #region public api

    final public function getId(): string
    {
        return $this->getSettings()->getId();
    }

    final public function getSettings(): Settings
    {
        return $this->settings;
    }

    final public function getOptions(): Options
    {
        $this->options ??= new Options($this->getId());
 
        return $this->options;
    }

    final public function getColumns(): Columns
    {
        $this->columns ??= $this->createColumns();
 
        return $this->columns;
    }

    final public function getRows(): Rows
    {
        $this->rows ??= $this->createRows();
 
        return $this->rows;
    }

    final public function getPanel(): ?Panel
    {
        $this->panel ??= $this->createPanel();
 
        return $this->panel;
    }

    final public function getFilter(): ?Filter
    {
        $this->filter ??= $this->createFilter();
 
        return $this->filter;
    }

    final public function getPagination(): ?PageNavigation
    {
        $this->pagination ??= $this->createPagination();
 
        return $this->pagination;
    }

    public function setRawRows(iterable $rawValue): void
    {
        $this->rawRows = [];
 
        foreach ($rawValue as $item)
        {
            $this->rawRows[] = $item;
        }
    }

    final protected function getRawRows(): array
    {
        return $this->rawRows;
    }

    public function prepareRows(): array
    {
        return $this->getRows()->prepareRows($this->getRawRows());
    }

    public function prepareColumns(): array
    {
        $result = [];
 
        foreach ($this->getColumns() as $column)
        {
            $result[] = $column;
        }
 
        return $result;
    }

    public function processRequest(?HttpRequest $request = null): void
    {
        $request ??= Context::getCurrent()->getRequest();
        $gridRequest = $this->gridRequestFactory->createFromRequest($request);
 
        $response = $this->processGridActionsRequest($gridRequest);
        if ($response instanceof GridResponse)
        {
            if ($response->isSendable())
            {
                $response->send();
            }
 
            return;
        }
 
        $panel = $this->getPanel();
        if (isset($panel))
        {
            $response = $panel->processRequest($gridRequest, $this->getFilter());
            if ($response instanceof GridResponse)
            {
                if ($response->isSendable())
                {
                    $response->send();
                }
 
                return;
            }
        }
 
        $response = $this->getRows()->processRequest($gridRequest);
        if ($response instanceof GridResponse)
        {
            if ($response->isSendable())
            {
                $response->send();
            }
 
            return;
        }
    }
 
    #region orm

    public function getOrmParams(): array
    {
        $params = [
            'select' => $this->getOrmSelect(),
            'order' => $this->getOrmOrder(),
        ];
 
        $filter = $this->getOrmFilter();
        if (isset($filter))
        {
            $params['filter'] = $filter;
        }
 
        $pagination = $this->getPagination();
        if (isset($pagination))
        {
            $params['limit'] = $pagination->getLimit();
            $params['offset'] = $pagination->getOffset();
        }
 
        return $params;
    }

    public function getOrmSelect(): array
    {
        return $this->getColumns()->getSelect(
            $this->getVisibleColumnsIds()
        );
    }

    public function getOrmFilter(): ?array
    {
        $filter = $this->getFilter();
        if (isset($filter))
        {
            return $filter->getValue();
        }
 
        return null;
    }

    public function getOrmOrder(): array
    {
        $sorting = $this->getOptions()->getSorting(
            $this->getDefaultSorting()
        );
 
        return $sorting['sort'];
    }
 
    #endregion orm
    #endregion public api

    protected function getActions(): array
    {
        $actions = [];
 
        $pagination = $this->getPagination();
        if (isset($pagination))
        {
            $actions[] = new PaginationAction($pagination, $this->getPaginationStorage());
        }
 
        return $actions;
    }

    final protected function getActionById(string $id): ?Action
    {
        if (empty($id))
        {
            return null;
        }
 
        if (!isset($this->actionsMap))
        {
            $this->actionsMap = [];
 
            foreach ($this->getActions() as $action)
            {
                $this->actionsMap[$action::getId()] = $action;
            }
        }
 
        return $this->actionsMap[$id] ?? null;
    }

    protected function processGridActionsRequest(GridRequest $request): ?GridResponse
    {
        $result = null;
 
        if (!check_bitrix_sessid())
        {
            return null;
        }
 
        $requestGridId = $request->getGridId();
        if ($requestGridId !== $this->getId())
        {
            return null;
        }
 
        $action = $this->getActionById(
            $request->getGridActionId() ?? ''
        );
        if ($action)
        {
            $result = $action->processRequest($request->getHttpRequest());
        }
        else
        {
            return null;
        }
 
        return
            isset($result)
                ? $this->gridResponseFactory->createFromResult($result)
                : null
        ;
    }

    public function getVisibleColumnsIds(): array
    {
        $visibleColumns = $this->getOptions()->GetVisibleColumns();
        if (empty($visibleColumns))
        {
            $visibleColumns = [];
 
            foreach ($this->getColumns() as $column)
            {
                if ($column->isDefault())
                {
                    $visibleColumns[] = $column->getId();
                }
            }
        }
 
        return $visibleColumns;
    }

    protected function getDefaultSorting(): array
    {
        return [
            'ID' => 'ASC',
        ];
    }

    abstract protected function createColumns(): Columns;

    protected function createRows(): Rows
    {
        $emptyRowAssembler = new EmptyRowAssembler(
            $this->getVisibleColumnsIds()
        );
 
        return new Rows(
            $emptyRowAssembler
        );
    }

    protected function createPanel(): ?Panel
    {
        return null;
    }

    protected function createFilter(): ?Filter
    {
        return null;
    }

    protected function createPagination(): ?PageNavigation
    {
        return null;
    }
}
 
trait DeprecatedMethods
{
    public function initPagination(int $totalRowsCount, ?string $navId = null): void
    {
        $navParams = $this->getOptions()->GetNavParams();
        if (empty($navId))
        {
            $navId = $this->getId() . '_nav';
        }
 
        $this->pagination = new PageNavigation($navId);
        $this->pagination->allowAllRecords(false);
        $this->pagination->setPageSize($navParams['nPageSize']);
        $this->pagination->setPageSizes($this->getPageSizes());
        $this->pagination->setRecordCount($totalRowsCount);
        $this->pagination->setCurrentPage(1);
 
        $storage = $this->getPaginationStorage();
        if ($storage instanceof PageNavigationStorage)
        {
            $storage->fill($this->pagination);
        }
    }

    protected function getPageSizes(): array
    {
        return [
            5,
            10,
            20,
            50,
            100,
        ];
    }
}