/**
* {@inheritdoc}
*/
public function visitMetadata(DatagridConfiguration $config, MetadataObject $data)
{
$currentViewId = $this->getCurrentViewId($config->getName());
$this->setDefaultParams($config->getName());
$data->offsetAddToArray('initialState', ['gridView' => self::DEFAULT_VIEW_ID]);
$data->offsetAddToArray('state', ['gridView' => $currentViewId]);
$allLabel = null;
if (isset($config['options'], $config['options']['gridViews'], $config['options']['gridViews']['allLabel'])) {
$allLabel = $this->translator->trans($config['options']['gridViews']['allLabel']);
}
/** @var AbstractViewsList $list */
$list = $config->offsetGetOr(self::VIEWS_LIST_KEY, false);
$systemGridView = new View(self::DEFAULT_VIEW_ID);
$systemGridView->setDefault($this->getDefaultViewId($config->getName()) === null);
$gridViews = ['choices' => [['label' => $allLabel, 'value' => self::DEFAULT_VIEW_ID]], 'views' => [$systemGridView->getMetadata()]];
if ($list !== false) {
$configuredGridViews = $list->getMetadata();
$configuredGridViews['views'] = array_merge($gridViews['views'], $configuredGridViews['views']);
$configuredGridViews['choices'] = array_merge($gridViews['choices'], $configuredGridViews['choices']);
$gridViews = $configuredGridViews;
}
if ($this->eventDispatcher->hasListeners(GridViewsLoadEvent::EVENT_NAME)) {
$event = new GridViewsLoadEvent($config->getName(), $gridViews);
$this->eventDispatcher->dispatch(GridViewsLoadEvent::EVENT_NAME, $event);
$gridViews = $event->getGridViews();
}
$gridViews['gridName'] = $config->getName();
$gridViews['permissions'] = $this->getPermissions();
$data->offsetAddToArray('gridViews', $gridViews);
}
/**
* {@inheritdoc}
*/
public function configure(DatagridConfiguration $configuration)
{
$attributes = $configuration->offsetGet(self::SOURCE_KEY)[self::USEABLE_ATTRIBUTES_KEY];
$attributes = $attributes === null ? [] : $attributes;
$displayedFilters = [];
foreach ($attributes as $attributeCode => $attribute) {
if (!$attribute['useableAsGridFilter']) {
continue;
}
$attributeType = $attribute['attributeType'];
$attributeTypeConf = $this->registry->getConfiguration($attributeType);
if (!$attributeTypeConf || !isset($attributeTypeConf['filter'])) {
throw new \LogicException(sprintf('Attribute type %s must be configured to allow grid filter on attribute %s', $attributeType, $attributeCode));
}
$filterConfig = $attributeTypeConf['filter'];
$filterConfig = $filterConfig + [ProductFilterUtility::DATA_NAME_KEY => $attributeCode, 'label' => $attribute['label'], 'enabled' => AttributeTypes::IDENTIFIER === $attributeType, 'order' => $attribute['sortOrder'], 'group' => $attribute['group'], 'groupOrder' => $attribute['groupOrder']];
if (AttributeTypes::METRIC === $attributeType) {
$filterConfig['family'] = $attribute['metricFamily'];
}
$displayedFilters[$attributeCode] = $filterConfig;
}
$this->sortFilters($displayedFilters);
$filters = $configuration->offsetGet(FilterConfiguration::FILTERS_KEY);
foreach ($displayedFilters as $attributeCode => $filterConfig) {
$filters['columns'][$attributeCode] = $filterConfig;
}
$configuration->offsetSet(FilterConfiguration::FILTERS_KEY, $filters);
}
/**
* {@inheritDoc}
*/
public function visitMetadata(DatagridConfiguration $config, MetadataObject $data)
{
$params = $this->getParameters()->get(ParameterBag::ADDITIONAL_PARAMETERS, []);
$currentView = isset($params[self::VIEWS_PARAM_KEY]) ? $params[self::VIEWS_PARAM_KEY] : null;
$data->offsetAddToArray('initialState', ['gridView' => '__all__']);
$data->offsetAddToArray('state', ['gridView' => $currentView]);
$allLabel = null;
if (isset($config['options']) && isset($config['options']['gridViews']) && isset($config['options']['gridViews']['allLabel'])) {
$allLabel = $this->translator->trans($config['options']['gridViews']['allLabel']);
}
/** @var AbstractViewsList $list */
$list = $config->offsetGetOr(self::VIEWS_LIST_KEY, false);
$gridViews = ['choices' => [['label' => $allLabel, 'value' => '__all__']], 'views' => [(new View('__all__'))->getMetadata()]];
if ($list !== false) {
$configuredGridViews = $list->getMetadata();
$configuredGridViews['views'] = array_merge($gridViews['views'], $configuredGridViews['views']);
$configuredGridViews['choices'] = array_merge($gridViews['choices'], $configuredGridViews['choices']);
$gridViews = $configuredGridViews;
}
if ($this->eventDispatcher->hasListeners(GridViewsLoadEvent::EVENT_NAME)) {
$event = new GridViewsLoadEvent($config->getName(), $gridViews);
$this->eventDispatcher->dispatch(GridViewsLoadEvent::EVENT_NAME, $event);
$gridViews = $event->getGridViews();
}
$gridViews['gridName'] = $config->getName();
$gridViews['permissions'] = $this->getPermissions();
$data->offsetSet('gridViews', $gridViews);
}
/**
* {@inheritDoc}
*/
public function visitDatasource(DatagridConfiguration $config, DatasourceInterface $datasource)
{
$entityName = $config->offsetGetByPath(self::EXTEND_ENTITY_CONFIG_PATH);
$fields = $this->getDynamicFields($entityName);
if ($datasource instanceof OrmDatasource && !empty($fields)) {
/** @var QueryBuilder $qb */
$qb = $datasource->getQueryBuilder();
$fromParts = $qb->getDQLPart('from');
$alias = false;
foreach ($fromParts as $fromPart) {
if ($fromPart->getFrom() == $entityName) {
$alias = $fromPart->getAlias();
}
}
if ($alias === false) {
// add entity if it not exists in from clause
$alias = ExtendConfigDumper::FIELD_PREFIX . 'o';
$qb->from($entityName, $alias);
}
foreach ($fields as $field) {
$fn = ExtendConfigDumper::FIELD_PREFIX . $field->getFieldName();
$qb->addSelect(sprintf('%s.%s', $alias, $fn));
// set real "data name" for filters and sorters
$config->offsetSetByPath(sprintf('%s[%s][%s]', OrmSorterConfiguration::COLUMNS_PATH, $fn, PropertyInterface::DATA_NAME_KEY), sprintf('%s.%s', $alias, $fn));
$config->offsetSetByPath(sprintf('%s[%s][%s]', FilterConfiguration::COLUMNS_PATH, $fn, FilterUtility::DATA_NAME_KEY), sprintf('%s.%s', $alias, $fn));
}
}
}
function let(DatagridConfiguration $configuration, ConfigurationRegistry $registry)
{
$registry->getConfiguration('pim_catalog_identifier')->willReturn(['column' => ['identifier_config']]);
$registry->getConfiguration('pim_catalog_text')->willReturn(['column' => ['text_config']]);
$configuration->offsetGetByPath(sprintf('[%s]', FormatterConfiguration::COLUMNS_KEY))->willReturn(['family' => ['family_config']]);
$this->beConstructedWith($registry);
}
/**
* Add user limitation
*
* @param DatagridConfiguration $config
* @param string $accessLevel
* @param User $user
* @param Organization $organization
*
* @throws \Exception
*/
protected function applyACL(DatagridConfiguration $config, $accessLevel, User $user, Organization $organization)
{
$where = $config->offsetGetByPath('[source][query][where][and]', []);
/** todo: refactor this check usages */
if ($accessLevel == AccessLevel::BASIC_LEVEL) {
$where = array_merge($where, ['u.id = ' . $user->getId()]);
} elseif ($accessLevel == AccessLevel::GLOBAL_LEVEL) {
$leftJoins = $config->offsetGetByPath('[source][query][join][inner]', []);
$leftJoins[] = ['join' => 'u.organizations', 'alias' => 'org'];
$config->offsetSetByPath('[source][query][join][inner]', $leftJoins);
$where = array_merge($where, ['org.id in (' . $organization->getId() . ')']);
} elseif ($accessLevel !== AccessLevel::SYSTEM_LEVEL) {
$resultBuIds = [];
if ($accessLevel == AccessLevel::LOCAL_LEVEL) {
$resultBuIds = $this->treeProvider->getTree()->getUserBusinessUnitIds($user->getId(), $organization->getId());
} elseif ($accessLevel == AccessLevel::DEEP_LEVEL) {
$resultBuIds = $this->treeProvider->getTree()->getUserSubordinateBusinessUnitIds($user->getId(), $organization->getId());
}
$leftJoins = $config->offsetGetByPath('[source][query][join][inner]', []);
$leftJoins[] = ['join' => 'u.businessUnits', 'alias' => 'bu'];
$config->offsetSetByPath('[source][query][join][inner]', $leftJoins);
$where = array_merge($where, ['bu.id in (' . implode(', ', $resultBuIds) . ')']);
}
if (count($where)) {
$config->offsetSetByPath('[source][query][where][and]', $where);
}
}
/**
* @param DatagridConfiguration $config
*
* @return bool
*/
public function isApplicable(DatagridConfiguration $config)
{
$columns = $config->offsetGetByPath(Configuration::COLUMNS_PATH);
$type = $config->offsetGetByPath(Builder::DATASOURCE_TYPE_PATH);
$isApplicable = ($type == CombinedAuditDatasource::TYPE || $type == CombinedUsersDatasource::TYPE) && is_array($columns);
return $isApplicable;
}
/**
* {@inheritdoc}
*/
public function visitDatasource(DatagridConfiguration $config, DatasourceInterface $datasource)
{
/** @var QueryBuilder $qb */
$qb = $datasource->getQueryBuilder();
$ds = new GroupingOrmFilterDatasourceAdapter($qb);
$filters = $config->offsetGetByPath('[source][query_config][filters]');
$this->restrictionBuilder->buildRestrictions($filters, $ds);
}
/**
* Build references data
*
* @param DatasourceInterface $dataSource
* @param DatagridConfiguration $configuration
*/
protected function buildReferenceData(DatasourceInterface $dataSource, DatagridConfiguration $configuration)
{
$source = $configuration->offsetGet('source');
$qb = $dataSource->getQueryBuilder();
foreach ($configuration->offsetGet('columns') as $column => $config) {
$this->buildQueryBuilder($qb, $source, $column);
}
}
/**
* @param DatagridConfiguration $config
*
* @return null
*/
public function getEntityRootAlias(DatagridConfiguration $config)
{
$from = $config->offsetGetByPath('[source][query][from]');
if ($from) {
return $from[0]['alias'];
}
return null;
}
/**
* {@inheritDoc}
*/
public function visitDatasource(DatagridConfiguration $config, DatasourceInterface $datasource)
{
$defaultPerPage = $config->offsetGetByPath(ToolbarExtension::PAGER_DEFAULT_PER_PAGE_OPTION_PATH, 10);
$this->pager->setQuery($datasource->getQuery());
$this->pager->setPage($this->getOr(self::PAGE_PARAM, 1));
$this->pager->setMaxPerPage($this->getOr(self::PER_PAGE_PARAM, $defaultPerPage));
$this->pager->init();
}
function let(DatagridConfiguration $configuration, ConfigurationRegistry $registry, ProductManager $manager)
{
$attributes = ['sku' => ['code' => 'sku', 'attributeType' => 'pim_catalog_identifier'], 'name' => ['code' => 'name', 'attributeType' => 'pim_catalog_text']];
$configuration->offsetGetByPath(sprintf('[source][%s]', ContextConfigurator::USEABLE_ATTRIBUTES_KEY))->willReturn($attributes);
$configuration->offsetGetByPath(sprintf('[%s]', FormatterConfiguration::COLUMNS_KEY))->willReturn(['family' => ['family_config'], 'sku' => [], 'name' => []]);
$registry->getConfiguration('pim_catalog_identifier')->willReturn(['column' => ['identifier_config'], 'sorter' => 'flexible_field']);
$this->beConstructedWith($registry, $manager);
}
/**
* {@inheritdoc}
*/
public function processConfigs(DatagridConfiguration $config)
{
$pagination = $config->offsetGetByPath(self::ENTITY_PAGINATION_PATH);
if ($pagination !== null && !is_bool($pagination)) {
throw new \LogicException('Entity pagination is not boolean');
}
$config->offsetSetByPath(self::ENTITY_PAGINATION_PATH, (bool) $pagination);
}
/**
* {@inheritdoc}
*
* Gets stored SQL and parameters prepared by
* Oro\Bundle\DataGridBundle\EventListener\StoreSqlListener
* and puts them into metadata of ResultsObject
*/
public function visitResult(DatagridConfiguration $config, ResultsObject $result)
{
$value = $config->offsetGetByPath(self::STORED_SQL_PATH);
if ($value) {
$result->offsetAddToArray('metadata', [self::DISPLAY_SQL_QUERY => true]);
$result->offsetAddToArrayByPath(self::STORED_SQL_PATH, $value);
}
}
function it_cannot_handle_misconfigured_attribute_type(DatagridConfiguration $configuration, $registry)
{
$attributes = ['sku' => ['code' => 'sku', 'label' => 'Sku', 'useableAsGridFilter' => 1, 'attributeType' => 'pim_catalog_identifier', 'sortOrder' => 2, 'group' => 'Foo', 'groupOrder' => 3], 'name' => ['code' => 'name', 'label' => 'Name', 'useableAsGridFilter' => 1, 'attributeType' => 'pim_catalog_text', 'sortOrder' => 4, 'group' => 'Bar', 'groupOrder' => 5]];
$attributesConf = [ContextConfigurator::USEABLE_ATTRIBUTES_KEY => $attributes];
$configuration->offsetGet(ContextConfigurator::SOURCE_KEY)->willReturn($attributesConf);
$registry->getConfiguration('pim_catalog_identifier')->willReturn(['filter' => ['identifier_config']]);
$registry->getConfiguration('pim_catalog_text')->willReturn([]);
$this->shouldThrow('\\LogicException')->duringConfigure($configuration);
}
/**
* {@inheritDoc}
*/
public function isApplicable(DatagridConfiguration $config)
{
$filters = $config->offsetGetByPath(Configuration::COLUMNS_PATH);
if ($filters === null) {
return false;
}
$type = $config->offsetGetByPath(Builder::DATASOURCE_TYPE_PATH);
return $type == CombinedUsersDatasource::TYPE || $type == CombinedAuditDatasource::TYPE;
}
/**
* {@inheritDoc}
*/
public function visitMetadata(DatagridConfiguration $config, MetadataObject $data)
{
$defaultPage = 1;
$defaultPerPage = $config->offsetGetByPath(ToolbarExtension::PAGER_DEFAULT_PER_PAGE_OPTION_PATH, 10);
$initialState = ['currentPage' => $defaultPage, 'pageSize' => $defaultPerPage];
$state = ['currentPage' => $this->getOr(PagerInterface::PAGE_PARAM, $defaultPage), 'pageSize' => $this->getOr(PagerInterface::PER_PAGE_PARAM, $defaultPerPage)];
$data->offsetAddToArray('initialState', $initialState);
$data->offsetAddToArray('state', $state);
}
/**
* {@inheritdoc}
*/
public function apply(DatasourceInterface $datasource, DatagridConfiguration $configuration)
{
$qb = $datasource->getQueryBuilder();
$joinAlias = 'selectCompleteness';
$util = new CompletenessJoin($qb);
$locale = $configuration->offsetGetByPath('[source][locale_code]');
$scope = $configuration->offsetGetByPath('[source][scope_code]');
$util->addJoins($joinAlias, $locale, $scope);
$qb->addSelect($joinAlias . '.ratio AS ratio');
}
/**
* {@inheritdoc}
*/
public function apply(DatasourceInterface $datasource, DatagridConfiguration $configuration)
{
if ($this->applied === false) {
$rootAlias = $datasource->getQueryBuilder()->getRootAlias();
$path = sprintf('[source][%s]', ContextConfigurator::DISPLAYED_ATTRIBUTES_KEY);
$attributeIds = $configuration->offsetGetByPath($path);
$datasource->getQueryBuilder()->leftJoin($rootAlias . '.values', 'values', 'WITH', 'values.attribute IN (:attributeIds) ' . 'AND (values.locale = :dataLocale OR values.locale IS NULL) ' . 'AND (values.scope = :scopeCode OR values.scope IS NULL)')->addSelect('values')->leftJoin('values.attribute', 'attribute')->addSelect('attribute')->setParameter('attributeIds', $attributeIds);
}
$this->applied = true;
}
/**
* @param DatagridConfiguration $config
* @param string $path
* @param mixed $element
* @param mixed $key
*/
protected function addConfigElement(DatagridConfiguration $config, $path, $element, $key = null)
{
$select = $config->offsetGetByPath($path);
if ($key) {
$select[$key] = $element;
} else {
$select[] = $element;
}
$config->offsetSetByPath($path, $select);
}
/**
* {@inheritDoc}
*/
public function visitMetadata(DatagridConfiguration $config, MetadataObject $data)
{
$params = $this->getRequestParams()->get(RequestParameters::ADDITIONAL_PARAMETERS);
$currentView = isset($params[self::VIEWS_PARAM_KEY]) ? $params[self::VIEWS_PARAM_KEY] : null;
$data->offsetAddToArray('state', ['gridView' => $currentView]);
/** @var AbstractViewsList $list */
$list = $config->offsetGetOr(self::VIEWS_LIST_KEY, false);
if ($list !== false) {
$data->offsetSet('gridViews', $list->getMetadata());
}
}
public function testRemoveColumn()
{
$this->configuration->addColumn('testColumn', ['param' => 123], null, ['param' => 123], ['param' => 123]);
$configArray = $this->configuration->toArray();
$this->assertTrue(isset($configArray['columns']['testColumn']));
$this->configuration->removeColumn('testColumn');
$configArray = $this->configuration->toArray();
$this->assertEmpty($configArray['columns']);
$this->assertEmpty($configArray['sorters']['columns']);
$this->assertEmpty($configArray['filters']['columns']);
}
/**
* {@inheritdoc}
*/
public function processConfigs(DatagridConfiguration $config)
{
$columns = $config->offsetGetByPath('[columns]', []);
$column = [self::COLUMN_NAME => $this->getColumnDefinition($config)];
$config->offsetSetByPath('[columns]', array_merge($columns, $column));
// do not add tag filter if $filters are empty(case when they are disabled).
$filters = $config->offsetGetByPath(self::GRID_FILTERS_PATH, []);
if (!empty($filters)) {
$filters[self::FILTER_COLUMN_NAME] = $this->getColumnFilterDefinition($config);
$config->offsetSetByPath(self::GRID_FILTERS_PATH, $filters);
}
}
/**
* {@inheritdoc}
*/
public function visitDatasource(DatagridConfiguration $config, DatasourceInterface $datasource)
{
$path = $config->offsetGetByPath(self::CHANNEL_RELATION_OPTION_PATH);
list($mainEntity, $relationName) = explode('.', $path);
/** @var OrmDatasource $datasource */
$queryBuilder = $datasource->getQueryBuilder();
$mainEntity = $this->ensureJoined($queryBuilder, $mainEntity);
$relationName = $this->ensureJoined($queryBuilder, $relationName, $mainEntity);
$channelIds = explode(',', $this->getParameters()->get('channelIds'));
$queryBuilder->andWhere($relationName . '.id in (:channelIds)');
$queryBuilder->setParameter('channelIds', $channelIds);
}
/**
* {@inheritDoc}
*/
public function isApplicable(DatagridConfiguration $config)
{
// validate configuration and fill default values
$options = $this->validateConfiguration(new Configuration(), ['export' => $config->offsetGetByPath(self::EXPORT_OPTION_PATH, false)]);
// translate labels
foreach ($options as &$option) {
$option['label'] = $this->translator->trans($option['label']);
}
// push options back to config
$config->offsetSetByPath(self::EXPORT_OPTION_PATH, $options);
return !empty($options);
}
function it_applies_join_on_datasource_query(Datasource $datasource, DatagridConfiguration $configuration, QueryBuilder $queryBuilder)
{
$datasource->getQueryBuilder()->willReturn($queryBuilder);
$configuration->offsetGetByPath('[source][displayed_attribute_ids]')->willReturn([1, 2]);
$queryBuilder->getRootAlias()->willReturn('p');
$queryBuilder->leftJoin('p.values', 'values', 'WITH', sprintf('%s AND %s AND %s', 'values.attribute IN (:attributeIds)', '(values.locale = :dataLocale OR values.locale IS NULL)', '(values.scope = :scopeCode OR values.scope IS NULL)'))->willReturn($queryBuilder);
$queryBuilder->addSelect('values')->willReturn($queryBuilder);
$queryBuilder->leftJoin('values.attribute', 'attribute')->willReturn($queryBuilder);
$queryBuilder->addSelect('attribute')->willReturn($queryBuilder);
$queryBuilder->setParameter('attributeIds', [1, 2])->willReturn($queryBuilder);
$this->apply($datasource, $configuration);
}
/**
* @param DatagridConfiguration $config
*
* @return null|string
*/
protected function getEntity(DatagridConfiguration $config)
{
$entityClassName = $config->offsetGetByPath(self::GRID_EXTEND_ENTITY_PATH);
if (!$entityClassName) {
$from = $config->offsetGetByPath(self::GRID_FROM_PATH);
if (!$from) {
return null;
}
$entityClassName = $this->entityClassResolver->getEntityClass($from[0]['table']);
}
return $entityClassName;
}
/**
* {@inheritDoc}
*/
public function visitMetadata(DatagridConfiguration $config, MetadataObject $data)
{
$actionsMetadata = [];
$actions = $config->offsetGetOr(static::ACTION_KEY, []);
foreach ($actions as $name => $action) {
$action = $this->getActionObject($name, $action);
if ($action !== false) {
$metadata = $action->getOptions()->toArray([], static::$excludeParams);
$metadata['label'] = isset($metadata['label']) ? $this->translator->trans($metadata['label']) : null;
$actionsMetadata[$action->getName()] = $metadata;
}
}
$data->offsetAddToArray(static::METADATA_ACTION_KEY, $actionsMetadata);
}
/**
* {@inheritdoc}
*/
public function visitDatasource(DatagridConfiguration $config, DatasourceInterface $datasource)
{
$gridName = $config->offsetGetByPath(self::NAME_PATH);
$parametersKey = md5(json_encode($this->parameters->all()));
if (!empty($this->appliedFor[$gridName . $parametersKey])) {
return;
}
/** @var QueryBuilder $qb */
$qb = $datasource->getQueryBuilder();
$ds = new GroupingOrmFilterDatasourceAdapter($qb);
$filters = $config->offsetGetByPath('[source][query_config][filters]');
$this->restrictionBuilder->buildRestrictions($filters, $ds);
$this->appliedFor[$gridName . $parametersKey] = true;
}
/**
* {@inheritDoc}
*/
public function visitMetadata(DatagridConfiguration $config, MetadataObject $data)
{
// get only columns here because columns will be represented on frontend
$columns = $config->offsetGetOr(Configuration::COLUMNS_KEY, []);
$propertiesMetadata = [];
foreach ($columns as $name => $fieldConfig) {
$fieldConfig = PropertyConfiguration::createNamed($name, $fieldConfig);
$metadata = $this->getPropertyObject($fieldConfig)->getMetadata();
// translate label on backend
$metadata['label'] = $this->translator->trans($metadata['label']);
$propertiesMetadata[] = $metadata;
}
$data->offsetAddToArray('columns', $propertiesMetadata);
}
