/**
* @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;
}
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 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 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');
}
public function testVisitMetadata()
{
$metadata = MetadataObject::create([]);
$this->extension->visitMetadata($this->config, $metadata);
$totalsData = $metadata->offsetGet('state');
$initialTotalsData = $metadata->offsetGet('initialState');
$this->assertEquals($totalsData, $initialTotalsData);
$this->assertEquals($this->config->offsetGetByPath(Configuration::TOTALS_PATH), $totalsData['totals']);
$this->assertEquals('orodatagrid/js/totals-builder', $metadata->offsetGet('requireJSModules')[0]);
}
/**
* @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 isApplicable(DatagridConfiguration $config)
{
if ($config->offsetGetByPath(Builder::DATASOURCE_TYPE_PATH) !== OrmDatasource::TYPE) {
return false;
}
if (!$config->offsetGetByPath(self::OPTIONS_MIXIN_PATH, false)) {
return false;
}
$segmentId = $this->segmentHelper->getSegmentIdByGridName($config->offsetGetByPath('[name]'));
if (!$segmentId) {
return false;
}
return (bool) $this->segmentHelper->getMarketingListBySegment($segmentId);
}
/**
* {@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;
}
/**
* Remove extra sorters, ie, sorters defined in datagrid.yml but columns are not displayed
*/
protected function removeExtraSorters()
{
$displayedColumns = $this->configuration->offsetGetByPath(sprintf('[%s]', FormatterConfiguration::COLUMNS_KEY));
$columnsCodes = array_keys($displayedColumns);
$sorters = $this->configuration->offsetGetByPath(sprintf('%s', OrmSorterConfiguration::COLUMNS_PATH));
if (!empty($sorters)) {
$sortersCodes = array_keys($sorters);
foreach ($sortersCodes as $sorterCode) {
if (!in_array($sorterCode, $columnsCodes)) {
unset($sorters[$sorterCode]);
}
}
$this->configuration->offsetSetByPath(sprintf('%s', OrmSorterConfiguration::COLUMNS_PATH), $sorters);
}
}
/**
* 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);
}
}
/**
* {@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);
}
/**
* {@inheritdoc}
*/
public function configure(DatagridConfiguration $configuration)
{
$path = sprintf(self::SOURCE_PATH, self::USEABLE_ATTRIBUTES_KEY);
$attributes = $configuration->offsetGetByPath($path);
$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);
foreach ($displayedFilters as $attributeCode => $filterConfig) {
$configuration->offsetSetByPath(sprintf('%s[%s]', FilterConfiguration::COLUMNS_PATH, $attributeCode), $filterConfig);
}
}
/**
* {@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);
}
/**
* @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}
*
* 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);
}
}
/**
* @param DatagridConfiguration $config
*/
protected function showAllAccountItems(DatagridConfiguration $config)
{
$config->offsetSetByPath(Builder::DATASOURCE_SKIP_ACL_CHECK, true);
$user = $this->getUser();
$where = $config->offsetGetByPath('[source][query][where]', ['and' => []]);
$where['and'][] = sprintf('(%s.account = %d OR %s.accountUser = %d)', $this->entityAlias, $user->getAccount()->getId(), $this->entityAlias, $user->getId());
$config->offsetSetByPath('[source][query][where]', $where);
}
/**
* {@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);
}
/**
* {@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();
}
/**
* {@inheritDoc}
*/
public function isApplicable(DatagridConfiguration $config)
{
$gridName = $config->offsetGetByPath(self::NAME_PATH);
if (!empty($this->appliedFor[$gridName])) {
return false;
}
if ($config->offsetGetByPath(Builder::DATASOURCE_TYPE_PATH) !== OrmDatasource::TYPE) {
return false;
}
$marketingListId = $this->marketingListHelper->getMarketingListIdByGridName($gridName);
if (!$marketingListId) {
return false;
}
$marketingList = $this->marketingListHelper->getMarketingList($marketingListId);
// Accept only segment based marketing lists
return $marketingList && !$marketingList->isManual();
}
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]];
$path = sprintf('[source][%s]', ContextConfigurator::USEABLE_ATTRIBUTES_KEY);
$configuration->offsetGetByPath($path)->willReturn($attributes);
$registry->getConfiguration('pim_catalog_identifier')->willReturn(['filter' => ['identifier_config']]);
$registry->getConfiguration('pim_catalog_text')->willReturn([]);
$this->shouldThrow('\\LogicException')->duringConfigure($configuration);
}
/**
* {@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)
{
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;
}
/**
* {@inheritDoc}
*/
public function visitMetadata(DatagridConfiguration $config, MetadataObject $data)
{
/**
* Default toolbar options
* [
* 'hide' => false,
* 'pageSize' => [
* 'hide' => false,
* 'items' => [10, 25, 50, 100],
* 'default_per_page' => 10
* ],
* 'pagination' => [
* 'hide' => false,
* 'onePage' => false,
* ]
* ];
*/
$perPageDefault = $config->offsetGetByPath(self::PAGER_DEFAULT_PER_PAGE_OPTION_PATH);
$pageSizeItems = $config->offsetGetByPath(self::PAGER_ITEMS_OPTION_PATH);
$exist = array_filter($pageSizeItems, function ($item) use($perPageDefault) {
if (is_array($item) && isset($item['size'])) {
return $perPageDefault == $item['size'];
} elseif (is_numeric($item)) {
return $perPageDefault == $item;
}
return false;
});
if (empty($exist)) {
throw new LogicException(sprintf('Default page size "%d" must present in size items array', $perPageDefault));
}
$options = $config->offsetGetByPath(ToolbarExtension::OPTIONS_PATH, []);
// get user specified require js modules from options
if (isset($options[MetadataObject::REQUIRED_MODULES_KEY])) {
$data->offsetAddToArray(MetadataObject::REQUIRED_MODULES_KEY, $options[MetadataObject::REQUIRED_MODULES_KEY]);
unset($options[MetadataObject::REQUIRED_MODULES_KEY]);
}
// in case of one page pagination page selector should be hidden
if ($config->offsetGetByPath(self::PAGER_ONE_PAGE_OPTION_PATH, false)) {
$options['toolbarOptions']['pageSize']['hide'] = true;
}
// grid options passed under "options" node
$data->offsetAddToArray(self::METADATA_KEY, $options);
}
/**
* @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 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);
}
/**
* {@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);
}
}
/**
* Inject requested repository parameters in the datagrid configuration
*/
protected function addRepositoryParameters()
{
$path = $this->getSourcePath(self::REPOSITORY_PARAMETERS_KEY);
$repositoryParams = $this->configuration->offsetGetByPath($path, null);
if ($repositoryParams) {
$params = [];
foreach ($repositoryParams as $paramName) {
$params[$paramName] = $this->requestParams->get($paramName, $this->request->get($paramName, null));
}
$this->configuration->offsetSetByPath($path, $params);
}
}
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);
}
