/**
* {@inheritDoc}
*/
public function process(DatagridInterface $grid, array $config)
{
$this->datagrid = $grid;
if (isset($config['query'])) {
$queryConfig = array_intersect_key($config, array_flip(['query']));
$converter = new YamlConverter();
$this->qb = $converter->parse($queryConfig, $this->em->createQueryBuilder());
} elseif (isset($config['entity']) && isset($config['repository_method'])) {
$entity = $config['entity'];
$method = $config['repository_method'];
$repository = $this->em->getRepository($entity);
if (method_exists($repository, $method)) {
$qb = $repository->{$method}();
if ($qb instanceof QueryBuilder) {
$this->qb = $qb;
} else {
throw new DatasourceException(sprintf('%s::%s() must return an instance of Doctrine\\ORM\\QueryBuilder, %s given', get_class($repository), $method, is_object($qb) ? get_class($qb) : gettype($qb)));
}
} else {
throw new DatasourceException(sprintf('%s has no method %s', get_class($repository), $method));
}
} else {
throw new DatasourceException(get_class($this) . ' expects to be configured with query or repository method');
}
if (isset($config['hints'])) {
$this->queryHints = $config['hints'];
}
$grid->setDatasource(clone $this);
}
/**
* @param DatagridInterface $dataGrid
* @return bool
*/
public function isDatagridApplicable(DatagridInterface $dataGrid)
{
if (!$dataGrid->getDatasource() instanceof OrmDatasource) {
return false;
}
return $dataGrid->getConfig()->offsetGetByPath(EntityPaginationExtension::ENTITY_PAGINATION_PATH) === true;
}
/**
* {@inheritDoc}
*/
public function process(DatagridInterface $grid, array $config)
{
$queryConfig = array_intersect_key($config, array_flip(['query']));
$converter = new YamlConverter();
$this->qb = $converter->parse($queryConfig, $this->em->createQueryBuilder());
$grid->setDatasource(clone $this);
}
/**
* {@inheritdoc}
*/
public function toArray()
{
if (null === $this->data) {
$resultData = $this->datagrid->getData();
$this->data = $resultData['data'];
}
return $this->data;
}
function it_processes_a_datasource_with_default_query_builder($manager, DatagridInterface $grid, ProductRepository $repository)
{
$config = ['entity' => 'Product'];
$manager->getRepository('Product')->willReturn($repository);
$repository->createQueryBuilder([])->shouldBeCalled();
$grid->setDatasource($this)->shouldBeCalled();
$this->process($grid, $config);
}
/**
* @param DatagridInterface $dataGrid
* @return string
*/
protected function getEntityName(DatagridInterface $dataGrid)
{
/** @var OrmDatasource $dataSource */
$dataSource = $dataGrid->getDatasource();
$queryBuilder = $dataSource->getQueryBuilder();
$entityName = $queryBuilder->getRootEntities()[0];
return $this->doctrineHelper->getEntityMetadata($entityName)->getName();
}
/**
* Get grid mass action by name
*
* @param string $name
* @param DatagridInterface $datagrid
*
* @return bool|ActionInterface
*/
public function getMassAction($name, DatagridInterface $datagrid)
{
$config = $datagrid->getAcceptor()->getConfig();
$action = false;
if (isset($config[static::ACTION_KEY][$name])) {
$action = $this->getActionObject($name, $config[static::ACTION_KEY][$name]);
}
return $action;
}
function let(MassActionHandlerRegistry $handlerRegistry, ManagerInterface $manager, RequestParameters $requestParams, MassActionParametersParser $parametersParser, DatagridInterface $grid, Acceptor $acceptor, DatasourceInterface $acceptedDatasource, DatasourceInterface $datasource, QueryBuilder $queryBuilder)
{
$this->beConstructedWith($handlerRegistry, $manager, $requestParams, $parametersParser);
$acceptedDatasource->getQueryBuilder()->willReturn($queryBuilder);
$grid->getAcceptor()->willReturn($acceptor);
$grid->getAcceptedDatasource()->willReturn($acceptedDatasource);
$grid->getDatasource()->willReturn($datasource);
$manager->getDatagrid('grid')->willReturn($grid);
}
function it_gives_the_label_of_a_filter($manager, $configurator, DatagridInterface $datagrid, Acceptor $acceptor, DatagridConfiguration $configuration)
{
$acceptor->getConfig()->willReturn($configuration);
$datagrid->getAcceptor()->willReturn($acceptor);
$manager->getDatagrid('product-grid')->willReturn($datagrid);
$configurator->configure($configuration)->shouldBeCalled();
$configuration->offsetGetByPath('[filters][columns][foo][label]')->willReturn('Foo');
$this->filterLabel('foo')->shouldReturn('Foo');
}
/**
* @test
*/
public function testProcess()
{
$this->doctrineRegistry->expects($this->any())->method('getManager')->will($this->returnValue($this->manager));
$this->manager->expects($this->once())->method('createQueryBuilder')->will($this->returnValue($this->queryBuilder))->with($this->equalTo('a'));
$this->grid->expects($this->once())->method('getParameters')->will($this->returnValue($this->parameterBag));
$this->parameterBag->expects($this->once())->method('get')->will($this->returnValue(1));
$this->grid->expects($this->once())->method('setDatasource');
$this->combinedAuditDatasource->process($this->grid, []);
}
/**
* @param DatagridInterface $datagrid
*
* @return array
*/
protected function getEntityNameWithAlias(DatagridInterface $datagrid)
{
$fromItems = $datagrid->getConfig()->offsetGetByPath('[source][query][from]', false);
if (empty($fromItems[0]['table'])) {
return [$datagrid->getParameters()->get('class_name'), null];
} else {
$alias = empty($fromItems[0]['alias']) ? null : $fromItems[0]['alias'];
return [$fromItems[0]['table'], $alias];
}
}
function it_handles_export_mass_action($eventDispatcher, $hydrator, DatagridInterface $datagrid, DatasourceInterface $datasource, EditMassAction $massAction)
{
$objectIds = array('foo', 'bar', 'baz');
$eventDispatcher->dispatch(MassActionEvents::MASS_EXPORT_PRE_HANDLER, Argument::type('Pim\\Bundle\\DataGridBundle\\Extension\\MassAction\\Event\\MassActionEvent'))->shouldBeCalled();
$eventDispatcher->dispatch(MassActionEvents::MASS_EXPORT_POST_HANDLER, Argument::type('Pim\\Bundle\\DataGridBundle\\Extension\\MassAction\\Event\\MassActionEvent'))->shouldBeCalled();
$datagrid->getDatasource()->willReturn($datasource);
$datasource->setHydrator($hydrator)->shouldBeCalled();
$datasource->getResults()->willReturn($objectIds);
$this->handle($datagrid, $massAction)->shouldReturn($objectIds);
}
function it_configure_choices_and_skip_disallowed($manager, $configurator, DatagridInterface $datagrid, Acceptor $acceptor, DatagridConfiguration $configuration, OptionsResolver $resolver)
{
$acceptor->getConfig()->willReturn($configuration);
$datagrid->getAcceptor()->willReturn($acceptor);
$manager->getDatagrid('foo-grid')->willReturn($datagrid);
$configurator->configure($configuration)->shouldBeCalled();
$configuration->offsetGetByPath('[filters][columns]')->willReturn(['foobar' => ['label' => 'FooBar'], 'foo-1' => ['label' => 'Foo 1'], 'foo-2' => ['label' => 'Foo 2'], 'bar-1' => ['label' => 'Bar 1'], 'scope' => ['label' => 'Scope'], 'locale' => ['label' => 'Locale']]);
$configuration->offsetGetByPath('[source][attributes_configuration]')->willReturn(['foo-1' => ['group' => 'foo'], 'foo-2' => ['group' => 'foo'], 'bar-1' => ['group' => 'bar']]);
$resolver->setDefaults(['choices' => ['System' => ['foobar' => 'FooBar'], 'foo' => ['foo-1' => 'Foo 1', 'foo-2' => 'Foo 2'], 'bar' => ['bar-1' => 'Bar 1']]])->shouldBeCalled();
$this->configureOptions($resolver);
}
function let(HydratorInterface $hydrator, TranslatorInterface $translator, EventDispatcherInterface $eventDispatcher, ProductManager $productManager, DatagridInterface $datagrid, DatasourceInterface $datasource, DeleteMassAction $massAction, ActionConfiguration $options, ProductMassActionRepository $massActionRepo)
{
$this->beConstructedWith($hydrator, $translator, $eventDispatcher, $productManager);
$translator->trans('qux')->willReturn('qux');
$datagrid->getDatasource()->willReturn($datasource);
$datasource->setHydrator($hydrator)->shouldBeCalled();
$datasource->getMassActionRepository()->willReturn($massActionRepo);
// prepare mass action response
$massAction->getOptions()->willReturn($options);
$options->offsetGetByPath(Argument::cetera())->willReturn('qux');
}
/**
* @param DatagridInterface $datagrid
*
* @return string|null
*/
public function getEntityName(DatagridInterface $datagrid)
{
/** @var OrmDatasource $dataSource */
$dataSource = $datagrid->getDatasource();
if (!$dataSource) {
return null;
}
/** @var QueryBuilder $queryBuilder */
$queryBuilder = $dataSource->getQueryBuilder();
$rootEntities = $queryBuilder->getRootEntities();
return reset($rootEntities);
}
/**
* @param array $rows
*
* @return array
*/
protected function applyPagination(array $rows)
{
$originalTotals = count($rows);
$this->grid->getConfig()->offsetAddToArrayByPath(static::PATH_PAGER_ORIGINAL_TOTALS, [$originalTotals]);
if (count($rows) > $this->requestPagerParameters['_per_page']) {
$offset = ($this->requestPagerParameters['_page'] - 1) * $this->requestPagerParameters['_per_page'];
if ($offset < 0) {
$offset = 0;
}
$rows = array_slice($rows, $offset, $this->requestPagerParameters['_per_page']);
}
return $rows;
}
/**
* {@inheritdoc}
*/
public function handle(DatagridInterface $datagrid, MassActionInterface $massAction)
{
// dispatch pre handler event
$massActionEvent = new MassActionEvent($datagrid, $massAction, []);
$this->eventDispatcher->dispatch(MassActionEvents::MASS_EXPORT_PRE_HANDLER, $massActionEvent);
$datasource = $datagrid->getDatasource();
$datasource->setHydrator($this->hydrator);
$results = $datasource->getResults();
// dispatch post handler event
$massActionEvent = new MassActionEvent($datagrid, $massAction, $results);
$this->eventDispatcher->dispatch(MassActionEvents::MASS_EXPORT_POST_HANDLER, $massActionEvent);
return $results;
}
/**
* {@inheritdoc}
*/
public function handle(DatagridInterface $datagrid, MassActionInterface $massAction)
{
// dispatch pre handler event
$massActionEvent = new MassActionEvent($datagrid, $massAction, array());
$this->eventDispatcher->dispatch(MassActionEvents::MASS_EDIT_PRE_HANDLER, $massActionEvent);
$datasource = $datagrid->getDatasource();
$datasource->setHydrator($this->hydrator);
// hydrator uses index by id
$objectIds = $datasource->getResults();
// dispatch post handler event
$massActionEvent = new MassActionEvent($datagrid, $massAction, array());
$this->eventDispatcher->dispatch(MassActionEvents::MASS_EDIT_POST_HANDLER, $massActionEvent);
return $objectIds;
}
/**
* {@inheritdoc}
*/
public function process(DatagridInterface $grid, array $config)
{
$this->configuration = $config;
if (isset($config['repository_method']) && ($method = $config['repository_method'])) {
if (isset($config[ContextConfigurator::REPOSITORY_PARAMETERS_KEY])) {
$this->qb = $this->getRepository()->{$method}($config[ContextConfigurator::REPOSITORY_PARAMETERS_KEY]);
} else {
$this->qb = $this->getRepository()->{$method}();
}
} else {
$this->qb = $this->getRepository()->createQueryBuilder('o');
}
$grid->setDatasource(clone $this);
}
/**
* {@inheritdoc}
*/
public function process(DatagridInterface $grid, array $config)
{
$this->configuration = $config;
$queryBuilderConfig = [];
if (isset($config['repository_method']) && ($method = $config['repository_method'])) {
if (isset($config[ContextConfigurator::REPOSITORY_PARAMETERS_KEY])) {
$queryBuilderConfig = $config[ContextConfigurator::REPOSITORY_PARAMETERS_KEY];
}
} else {
$method = 'createQueryBuilder';
}
$this->initializeQueryBuilder($method, $queryBuilderConfig);
$grid->setDatasource(clone $this);
}
function it_applies_when_user_preference_is_filled_and_skip_disallowed($context, UserInterface $user, DatagridInterface $datagrid, Acceptor $acceptor, DatagridConfiguration $config, BuildAfter $event)
{
$config->offsetGet('filters')->willReturn(['columns' => ['foo' => [], 'baz' => [], 'scope' => [], 'locale' => []]]);
$config->offsetSetByPath('[filters][columns][foo][enabled]', true)->shouldBeCalled();
$config->offsetSetByPath('[filters][columns][baz][enabled]', false)->shouldBeCalled();
$config->offsetSetByPath('[filters][columns][bar][enabled]', Argument::any())->shouldNotBeCalled();
$config->offsetSetByPath('[filters][columns][scope][enabled]', Argument::any())->shouldNotBeCalled();
$config->offsetSetByPath('[filters][columns][locale][enabled]', Argument::any())->shouldNotBeCalled();
$user->getProductGridFilters()->willReturn(['foo', 'bar']);
$context->getUser()->willReturn($user);
$acceptor->getConfig()->willReturn($config);
$datagrid->getAcceptor()->willReturn($acceptor);
$event->getDatagrid()->willReturn($datagrid);
$this->onBuildAfter($event);
}
/**
* @return ResultsObject
*/
protected function getGridData()
{
if (null !== $this->gridDataSource) {
$this->grid->setDatasource(clone $this->gridDataSource);
} else {
$this->gridDataSource = clone $this->grid->getDatasource();
}
$this->grid->getParameters()->set(PagerInterface::PAGER_ROOT_PARAM, [PagerInterface::PAGE_PARAM => $this->page, PagerInterface::PER_PAGE_PARAM => $this->pageSize]);
return $this->grid->getData();
}
/**
* {@inheritdoc}
*/
public function handle(DatagridInterface $datagrid, MassActionInterface $massAction)
{
// dispatch pre handler event
$massActionEvent = new MassActionEvent($datagrid, $massAction, []);
$this->eventDispatcher->dispatch(MassActionEvents::MASS_DELETE_PRE_HANDLER, $massActionEvent);
$datasource = $datagrid->getDatasource();
$datasource->setHydrator($this->hydrator);
// hydrator uses index by id
$objectIds = $datasource->getResults();
try {
$countRemoved = $datasource->getMassActionRepository()->deleteFromIds($objectIds);
} catch (\Exception $e) {
$errorMessage = $e->getMessage();
return new MassActionResponse(false, $this->translator->trans($errorMessage));
}
// dispatch post handler event
$massActionEvent = new MassActionEvent($datagrid, $massAction, $objectIds);
$this->eventDispatcher->dispatch(MassActionEvents::MASS_DELETE_POST_HANDLER, $massActionEvent);
return $this->getResponse($massAction, $countRemoved);
}
/**
* Binds datagrid parameters to datasource query.
*
* Example of usage:
* <code>
* // get parameter "name" from datagrid parameter bag and add it to datasource query
* $queryParameterBinder->bindParameters($datagrid, ['name']);
*
* // get parameter "id" from datagrid parameter bag and add it to datasource query as parameter "client_id"
* $queryParameterBinder->bindParameters($datagrid, ['client_id' => 'id']);
*
* // get parameter "email" from datagrid parameter bag and add it to datasource query, all other existing query
* // parameters will be cleared
* $queryParameterBinder->bindParameters($datagrid, ['email'], false);
*
* // get parameter with path "_parameters.data_in" from datagrid parameter
* // and add it to datasource query as parameter "data_in"
* $queryParameterBinder->bindParameters($datagrid, ['data_in' => '_parameters.data_in']);
*
* // get parameter with path "_parameters.data_in" from datagrid parameter
* // and add it to datasource query as parameter "data_in",
* // if parameter is not exist, set default value - empty array,
* // and do the same for data_not_in
* $queryParameterBinder->bindParameters(
* $datagrid,
* [
* 'data_in' => [
* 'path' => '_parameters.data_in',
* 'default' => [],
* ],
* [
* 'name' => 'data_not_in'
* 'path' => '_parameters.data_not_in',
* 'default' => [],
* ]
* ]
* );
* </code>
*
* @param DatagridInterface $datagrid
* @param array $datasourceToDatagridParameters
* @param bool $append
* @throws InvalidArgumentException When datasource of grid is not ORM
* @throws NoSuchPropertyException When datagrid has no parameter with specified name or path
*/
public function bindParameters(DatagridInterface $datagrid, array $datasourceToDatagridParameters, $append = true)
{
if (!$datasourceToDatagridParameters) {
return;
}
$datasource = $datagrid->getDatasource();
if (!$datasource instanceof OrmDatasource) {
throw new InvalidArgumentException(sprintf('Datagrid datasource has unexpected type "%s", "%s" is expected.', get_class($datasource), 'Oro\\Bundle\\DataGridBundle\\Datasource\\Orm\\OrmDatasource'));
}
/** @var QueryBuilder $queryBuilder */
$queryBuilder = $datasource->getQueryBuilder();
$queryParameters = $queryBuilder->getParameters();
if (!$append) {
$queryParameters->clear();
}
$datagridParameters = $datagrid->getParameters()->all();
foreach ($datasourceToDatagridParameters as $index => $value) {
$config = $this->parseArrayParameterConfig($index, $value);
$value = $this->getParameterValue($datagridParameters, $config);
$type = isset($config['type']) ? $config['type'] : null;
$this->addOrReplaceParameter($queryParameters, new Parameter($config['name'], $value, $type));
}
}
/**
* {@inheritDoc}
*/
public function process(DatagridInterface $grid, array $config)
{
$this->query = new IndexerQuery($this->indexer, $this->indexer->select());
$grid->setDatasource(clone $this);
}
/**
* @param string $massActionName
* @param DatagridInterface $datagrid
*
* @return \Oro\Bundle\DataGridBundle\Extension\MassAction\Actions\MassActionInterface
* @throws LogicException
*/
protected function getMassActionByName($massActionName, DatagridInterface $datagrid)
{
$massAction = null;
$extensions = array_filter($datagrid->getAcceptor()->getExtensions(), function (ExtensionVisitorInterface $extension) {
return $extension instanceof MassActionExtension;
});
/** @var MassActionExtension|bool $extension */
$extension = reset($extensions);
if ($extension === false) {
throw new LogicException("MassAction extension is not applied to datagrid.");
}
$massAction = $extension->getMassAction($massActionName, $datagrid);
if (!$massAction) {
throw new LogicException(sprintf('Can\'t find mass action "%s"', $massActionName));
}
return $massAction;
}
/**
* @param DatagridInterface $grid
* @param array $config
*/
public function process(DatagridInterface $grid, array $config)
{
$grid->setDatasource(clone $this);
}
/**
* {@inheritDoc}
*/
public function process(DatagridInterface $grid, array $config)
{
$parameters = $grid->getParameters();
$this->object = $this->routingHelper->getEntity($parameters->get('entityClass'), $parameters->get('entityId'));
$grid->setDatasource(clone $this);
}
/**
* @param DatagridInterface $grid
* @param array $params
* @return string
*/
protected function generateUrl(DatagridInterface $grid, $params)
{
$gridFullName = $this->nameStrategy->buildGridFullName($grid->getName(), $grid->getScope());
return $this->router->generate(self::ROUTE, ['gridName' => $gridFullName, $gridFullName => $params]);
}
/**
* @param DatagridInterface $dataGrid
* @return string
*/
protected function generateStateHash(DatagridInterface $dataGrid)
{
$state = $dataGrid->getMetadata()->offsetGetByPath('[state]');
$data = ['filters' => !empty($state['filters']) ? $state['filters'] : [], 'sorters' => !empty($state['sorters']) ? $state['sorters'] : []];
return md5(json_encode($data));
}