Your IP : 3.147.49.19
<?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\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;
use Bitrix\Main\Web\PostDecodeFilter;
/**
* Grid object.
*
* Contains all the necessary information to work with the grid: columns, settings, actions.
* There is no work with the filter here, there is a separate `Filter` class for this.
*
* @see \Bitrix\Main\Filter\Filter
*
* Usage example:
* ```php
//
// create instances for grid and filter
//
$settings = new \Bitrix\Main\Grid\Settings([
'ID' => 'test-grid',
]);
$grid = new Grid($settings);
//
// init pagination (if using)
//
$totalCount = Entity::getCount(
$grid->getOrmFilter() ?? []
);
$grid->initPagination($totalCount);
//
// processing grid actions from current request
//
$grid->processRequest();
//
// fill grid rows with raw data
// It is important to do this AFTER processing the request, because the handlers could change the data.
//
$grid->setRawRows(
Entity::getList($grid->getOrmParams())
);
//
// render component
//
$APPLICATION->IncludeComponent(
'bitrix:main.ui.grid',
'',
\Bitrix\Main\Grid\Component\ComponentParams::get($grid, [
// additional params
])
);
* ```
*/
abstract class Grid
{
use StorageSupporter;
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;
/**
* @param Settings $settings required for all childs!
*/
public function __construct(Settings $settings)
{
$this->settings = $settings;
$this->gridRequestFactory = new GridRequestFactory;
$this->gridResponseFactory = new GridResponseFactory;
}
#region public api
/**
* Grid id.
*
* @return string
*/
final public function getId(): string
{
return $this->getSettings()->getId();
}
/**
* Configuration settings.
*
* @return Settings
*/
final public function getSettings(): Settings
{
return $this->settings;
}
/**
* User options.
*
* @return Options
*/
final public function getOptions(): Options
{
$this->options ??= new Options($this->getId());
return $this->options;
}
/**
* Grid columns.
*
* @return Columns
*/
final public function getColumns(): Columns
{
$this->columns ??= $this->createColumns();
return $this->columns;
}
/**
* Grid rows.
*
* @return Rows
*/
final public function getRows(): Rows
{
$this->rows ??= $this->createRows();
return $this->rows;
}
/**
* Grid footer actions panel.
*
* @return Panel|null
*/
final public function getPanel(): ?Panel
{
$this->panel ??= $this->createPanel();
return $this->panel;
}
/**
* Grid filter.
*
* @return Filter|null
*/
final public function getFilter(): ?Filter
{
$this->filter ??= $this->createFilter();
return $this->filter;
}
/**
* Grid pagination.
*
* @return PageNavigation|null
*/
final public function getPagination(): ?PageNavigation
{
return $this->pagination;
}
/**
* Init pagination.
*
* If you use pagination, you need to call this method before processing the request (`processRequest` method)
* and getting the ORM parameters (`getOrmParams` method).
*
* Ideally, call it immediately after creating the grid instance.
*
* @param int $totalRowsCount
* @param string|null $navId
*
* @return void
*/
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);
$storage = $this->getPaginationStorage();
if (isset($storage))
{
$storage->fill($this->pagination);
}
}
/**
* Set raw rows (only data after ORM calling).
*
* @param iterable $rawValue
*
* @return void
*/
public function setRawRows(iterable $rawValue): void
{
$this->rawRows = [];
foreach ($rawValue as $item)
{
$this->rawRows[] = $item;
}
}
/**
* Get raw rows.
*
* @return array
*/
final protected function getRawRows(): array
{
return $this->rawRows;
}
/**
* Gets rows prepared for output.
*
* @return array[]
*/
public function prepareRows(): array
{
return $this->getRows()->prepareRows($this->getRawRows());
}
/**
* Gets columns prepared for output.
*
* @return Column[]
*/
public function prepareColumns(): array
{
$result = [];
foreach ($this->getColumns() as $column)
{
$result[] = $column;
}
return $result;
}
/**
* Processing all actions of the grid.
*
* Handles actions of the grid, panel, and rows.
*
* @param HttpRequest|null $request
*
* @return void
*/
public function processRequest(?HttpRequest $request = null): void
{
$request ??= Context::getCurrent()->getRequest();
$request->addFilter(new PostDecodeFilter);
$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
/**
* Params for ORM and `getList` method.
*
* @see \Bitrix\Main\ORM\Data\DataManager method `getList`
*
* @return array
*/
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;
}
/**
* Select for ORM and `getList` method.
*
* @see \Bitrix\Main\ORM\Data\DataManager method `getList`
*
* @return array
*/
public function getOrmSelect(): array
{
return $this->getColumns()->getSelect(
$this->getVisibleColumnsIds()
);
}
/**
* Filter for ORM and `getList` method.
*
* @see \Bitrix\Main\ORM\Data\DataManager method `getList`
*
* @return array|null is filter not setted, returns `null`
*/
public function getOrmFilter(): ?array
{
$filter = $this->getFilter();
if (isset($filter))
{
return $filter->getValue();
}
return null;
}
/**
* Order for ORM and `getList` method.
*
* @see \Bitrix\Main\ORM\Data\DataManager method `getList`
*
* @return array
*/
public function getOrmOrder(): array
{
$sorting = $this->getOptions()->getSorting(
$this->getDefaultSorting()
);
return $sorting['sort'];
}
#endregion orm
#endregion public api
/**
* Grid actions.
*
* These are the actions of the grid itself, and not its component parts (rows, panel, ...).
*
* @return Action[]
*/
protected function getActions(): array
{
$result = [];
$pagination = $this->getPagination();
if (isset($pagination))
{
$result[] = new PaginationAction($pagination, $this->getPaginationStorage());
}
return $result;
}
/**
* Grid action.
*
* @param string $id
*
* @return Action|null
*/
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;
}
/**
* Processing only grid actions.
*
* @see `::processRequest` for processing all actions (grid, rows and panel).
*
* @param GridRequest $request
*
* @return GridResponse|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
;
}
/**
* Ids of visible columns.
*
* If the user's display options are filled in, they are used.
* Otherwise, used default columns.
*
* @return string[] columns ids
*/
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;
}
/**
* Available page sizes.
*
* @return int[]
*/
protected function getPageSizes(): array
{
return [
5,
10,
20,
50,
100,
];
}
/**
* Default sorting.
*
* @return array
*/
protected function getDefaultSorting(): array
{
return [
'ID' => 'ASC',
];
}
/**
* Create columns collection.
*
* @return Columns
*/
abstract protected function createColumns(): Columns;
/**
* Create rows collection.
*
* @return Rows
*/
protected function createRows(): Rows
{
$emptyRowAssembler = new EmptyRowAssembler(
$this->getVisibleColumnsIds()
);
return new Rows(
$emptyRowAssembler
);
}
/**
* Create panel.
*
* @return Panel|null
*/
protected function createPanel(): ?Panel
{
return null;
}
/**
* Create filter.
*
* @return Filter|null
*/
protected function createFilter(): ?Filter
{
return null;
}
}