function it_uses_data_provider_to_create_a_view_with_data_and_definition(DataProviderInterface $dataProvider, Grid $grid)
{
$parameters = new Parameters();
$expectedGridView = new GridView(['foo', 'bar'], $grid->getWrappedObject(), $parameters);
$dataProvider->getData($grid, $parameters)->willReturn(['foo', 'bar']);
$this->create($grid, $parameters)->shouldBeLike($expectedGridView);
}
/**
* {@inheritdoc}
*/
public function create(Grid $grid, Parameters $parameters, MetadataInterface $metadata, RequestConfiguration $requestConfiguration)
{
$driverConfiguration = $grid->getDriverConfiguration();
$request = $requestConfiguration->getRequest();
$grid->setDriverConfiguration($this->parametersParser->parseRequestValues($driverConfiguration, $request));
return new ResourceGridView($this->dataProvider->getData($grid, $parameters), $grid, $parameters, $metadata, $requestConfiguration);
}
function it_throws_an_exception_if_driver_is_not_supported(Grid $grid, ServiceRegistryInterface $driversRegistry)
{
$parameters = new Parameters();
$grid->getDriver()->willReturn('doctrine/banana');
$driversRegistry->has('doctrine/banana')->willReturn(false);
$this->shouldThrow(new UnsupportedDriverException('doctrine/banana'))->during('getDataSource', [$grid, $parameters]);
}
/**
* {@inheritdoc}
*/
public function getDataSource(Grid $grid, Parameters $parameters)
{
$driver = $grid->getDriver();
if (!$this->driversRegistry->has($driver)) {
throw new UnsupportedDriverException($driver);
}
return $this->driversRegistry->get($driver)->getDataSource($grid->getDriverConfiguration(), $parameters);
}
/**
* {@inheritdoc}
*/
public function sort(DataSourceInterface $dataSource, Grid $grid, Parameters $parameters)
{
$expressionBuilder = $dataSource->getExpressionBuilder();
$sorting = $parameters->has('sorting') ? $parameters->get('sorting') : $grid->getSorting();
foreach ($sorting as $field => $direction) {
$expressionBuilder->addOrderBy($field, $direction);
}
}
function it_sorts_the_data_source_via_expression_builder_based_on_sorting_parameter(Grid $grid, DataSourceInterface $dataSource, ExpressionBuilderInterface $expressionBuilder)
{
$parameters = new Parameters(['sorting' => ['name' => ['direction' => 'asc']]]);
$dataSource->getExpressionBuilder()->willReturn($expressionBuilder);
$grid->getSorting()->willReturn(['name' => ['path' => 'translation.name', 'direction' => 'desc']]);
$expressionBuilder->addOrderBy('translation.name', 'asc')->shouldBeCalled();
$this->sort($dataSource, $grid, $parameters);
}
function it_throws_exception_when_trying_to_sort_by_a_non_sortable_field(Grid $gridDefinition)
{
$gridDefinition->hasField('code')->willReturn(true);
$gridDefinition->hasField('name')->willReturn(true);
$gridDefinition->getSorting()->willReturn(['code' => ['path' => 'code', 'direction' => 'asc']]);
$gridDefinition->isSortableBy('name')->willThrow(\InvalidArgumentException::class);
$this->shouldThrow(\InvalidArgumentException::class)->during('isSortedBy', ['name']);
$this->shouldThrow(\InvalidArgumentException::class)->during('getSortingOrder', ['name']);
}
function it_sorts_the_data_source_via_expression_builder_based_on_sorting_parameter(Grid $grid, Parameters $parameters, DataSourceInterface $dataSource, ExpressionBuilderInterface $expressionBuilder)
{
$parameters->has('sorting')->willReturn(true);
$parameters->get('sorting')->willReturn(['name' => 'asc']);
$dataSource->getExpressionBuilder()->willReturn($expressionBuilder);
$grid->getSorting()->willReturn(['name' => 'desc']);
$expressionBuilder->addOrderBy('name', 'asc')->shouldBeCalled();
$this->sort($dataSource, $grid, $parameters);
}
/**
* {@inheritdoc}
*/
public function getDataSource(Grid $grid, Parameters $parameters)
{
$driverName = $grid->getDriver();
if (!$this->driversRegistry->has($driverName)) {
throw new UnsupportedDriverException($driverName);
}
/** @var DriverInterface $driver */
$driver = $this->driversRegistry->get($driverName);
return $driver->getDataSource($grid->getDriverConfiguration(), $parameters);
}
/**
* {@inheritdoc}
*/
public function sort(DataSourceInterface $dataSource, Grid $grid, Parameters $parameters)
{
$expressionBuilder = $dataSource->getExpressionBuilder();
$sorting = $parameters->get('sorting', $grid->getSorting());
foreach ($sorting as $field => $order) {
$gridField = $grid->getField($field);
$property = $gridField->getSortable();
$expressionBuilder->addOrderBy($property, $order);
}
}
function it_uses_data_provider_to_create_a_view_with_data_and_definition(DataProviderInterface $dataProvider, ParametersParserInterface $parametersParser, Grid $grid, Parameters $parameters, MetadataInterface $resourceMetadata, Request $request, RequestConfiguration $requestConfiguration)
{
$expectedResourceGridView = new ResourceGridView(['foo', 'bar'], $grid->getWrappedObject(), $parameters->getWrappedObject(), $resourceMetadata->getWrappedObject(), $requestConfiguration->getWrappedObject());
$requestConfiguration->getRequest()->willReturn($request);
$parametersParser->parseRequestValues(['repository' => ['method' => 'createByCustomerQueryBuilder', 'arguments' => ['$customerId']]], $request)->willReturn(['repository' => ['method' => 'createByCustomerQueryBuilder', 'arguments' => [5]]]);
$grid->getDriverConfiguration()->willReturn(['repository' => ['method' => 'createByCustomerQueryBuilder', 'arguments' => ['$customerId']]]);
$grid->setDriverConfiguration(['repository' => ['method' => 'createByCustomerQueryBuilder', 'arguments' => [5]]])->shouldBeCalled();
$dataProvider->getData($grid, $parameters)->willReturn(['foo', 'bar']);
$this->create($grid, $parameters, $resourceMetadata, $requestConfiguration)->shouldBeSameResourceGridViewAs($expectedResourceGridView);
}
/**
* {@inheritdoc}
*/
public function sort(DataSourceInterface $dataSource, Grid $grid, Parameters $parameters)
{
$expressionBuilder = $dataSource->getExpressionBuilder();
$sorting = $parameters->has('sorting') ? $parameters->get('sorting') : $grid->getSorting();
foreach ($sorting as $field => $options) {
if (!isset($options['direction'])) {
$options['direction'] = 'desc';
}
$expressionBuilder->addOrderBy($options['path'], $options['direction']);
}
}
function it_filters_data_source_based_on_criteria_parameter(ServiceRegistryInterface $filtersRegistry, FilterInterface $stringFilter, Grid $grid, Filter $filter, DataSourceInterface $dataSource)
{
$parameters = new Parameters(['criteria' => ['keywords' => 'Banana', 'enabled' => true]]);
$grid->hasFilter('keywords')->willReturn(true);
$grid->hasFilter('enabled')->willReturn(false);
$grid->getFilter('keywords')->willReturn($filter);
$filter->getType()->willReturn('string');
$filter->getOptions()->willReturn(['fields' => ['firstName', 'lastName']]);
$filtersRegistry->get('string')->willReturn($stringFilter);
$stringFilter->apply($dataSource, 'keywords', 'Banana', ['fields' => ['firstName', 'lastName']])->shouldBeCalled();
$this->apply($dataSource, $grid, $parameters);
}
function it_sorts_the_data_source_via_expression_builder_based_on_sorting_parameter(Grid $grid, Field $nameField, DataSourceInterface $dataSource, ExpressionBuilderInterface $expressionBuilder)
{
$parameters = new Parameters(['sorting' => ['name' => 'asc']]);
$dataSource->getExpressionBuilder()->willReturn($expressionBuilder);
$grid->getSorting()->willReturn(['code' => 'desc']);
$grid->hasField('name')->willReturn(true);
$grid->getField('name')->willReturn($nameField);
$nameField->isSortable()->willReturn(true);
$nameField->getSortable()->willReturn('translation.name');
$expressionBuilder->addOrderBy('translation.name', 'asc')->shouldBeCalled();
$this->sort($dataSource, $grid, $parameters);
}
/**
* {@inheritdoc}
*/
public function apply(DataSourceInterface $dataSource, Grid $grid, Parameters $parameters)
{
if (!$parameters->has('criteria')) {
return;
}
$criteria = $parameters->get('criteria');
foreach ($criteria as $name => $data) {
if (!$grid->hasFilter($name)) {
continue;
}
$filter = $grid->getFilter($name);
$this->filtersRegistry->get($filter->getType())->apply($dataSource, $name, $data, $filter->getOptions());
}
}
function it_converts_an_array_to_grid_definition()
{
$grid = Grid::fromCodeAndDriverConfiguration('sylius_admin_tax_category', 'doctrine/orm', ['resource' => 'sylius.tax_category']);
$grid->setSorting(['name' => 'desc']);
$codeField = Field::fromNameAndType('code', 'string');
$codeField->setLabel('System Code');
$codeField->setPath('method.code');
$codeField->setOptions(['template' => 'bar.html.twig']);
$grid->addField($codeField);
$viewAction = Action::fromNameAndType('view', 'link');
$viewAction->setLabel('Display Tax Category');
$viewAction->setOptions(['foo' => 'bar']);
$defaultActionGroup = ActionGroup::named('default');
$defaultActionGroup->addAction($viewAction);
$grid->addActionGroup($defaultActionGroup);
$filter = Filter::fromNameAndType('enabled', 'boolean');
$grid->addFilter($filter);
$definitionArray = ['driver' => ['name' => 'doctrine/orm', 'options' => ['resource' => 'sylius.tax_category']], 'sorting' => ['name' => 'desc'], 'fields' => ['code' => ['type' => 'string', 'label' => 'System Code', 'path' => 'method.code', 'options' => ['template' => 'bar.html.twig']]], 'filters' => ['enabled' => ['type' => 'boolean']], 'actions' => ['default' => ['view' => ['type' => 'link', 'label' => 'Display Tax Category', 'options' => ['foo' => 'bar']]]]];
$this->convert('sylius_admin_tax_category', $definitionArray)->shouldBeSameGridAs($grid);
}
function it_uses_data_provider_to_create_a_view_with_data_and_definition(DataProviderInterface $dataProvider, Grid $grid, Parameters $parameters, MetadataInterface $resourceMetadata, RequestConfiguration $requestConfiguration)
{
$expectedResourceGridView = new ResourceGridView(['foo', 'bar'], $grid->getWrappedObject(), $parameters->getWrappedObject(), $resourceMetadata->getWrappedObject(), $requestConfiguration->getWrappedObject());
$dataProvider->getData($grid, $parameters)->willReturn(['foo', 'bar']);
$this->create($grid, $parameters, $resourceMetadata, $requestConfiguration)->shouldBeSameResourceGridViewAs($expectedResourceGridView);
}
/**
* @param string $fieldName
*
* @throws \InvalidArgumentException
*/
private function assertFieldExists($fieldName)
{
if (!$this->definition->hasField($fieldName)) {
throw new \InvalidArgumentException(sprintf('Field "%s" does not exist.', $fieldName));
}
}
/**
* @param string $fieldName
*
* @throws \InvalidArgumentException
*/
private function assertFieldExists($fieldName)
{
Assert::true($this->definition->hasField($fieldName), sprintf('Field "%s" does not exist.', $fieldName));
}
/**
* @param string $fieldName
*
* @throws \InvalidArgumentException
*/
private function assertFieldIsSortable($fieldName)
{
Assert::true($this->definition->hasField($fieldName), sprintf('Field "%s" does not exist.', $fieldName));
Assert::true($this->definition->getField($fieldName)->isSortable(), sprintf('Field "%s" is not sortable.', $fieldName));
}
function it_throws_exception_when_checking_sorting_of_non_existent_field(Grid $gridDefinition)
{
$gridDefinition->hasField('code')->willReturn(false);
$this->shouldThrow(new \InvalidArgumentException('Field "code" does not exist.'))->during('isSortedby', ['code']);
$this->shouldThrow(new \InvalidArgumentException('Field "code" does not exist.'))->during('getSortingOrder', ['code']);
}
