/**
* @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);
}
/**
* 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);
}
}
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);
}
/**
* {@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)
{
$options = $config->offsetGetByPath(self::TOOLBAR_OPTION_PATH, []);
// validate configuration and pass default values back to config
$configuration = $this->validateConfiguration(new Configuration($this->cm), ['toolbarOptions' => $options]);
$config->offsetSetByPath(sprintf('%s[%s]', self::OPTIONS_PATH, 'toolbarOptions'), $configuration);
}
/**
* {@inheritDoc}
*/
public function processConfigs(DatagridConfiguration $config)
{
$filters = $config->offsetGetByPath(Configuration::FILTERS_PATH);
// validate extension configuration and pass default values back to config
$filtersNormalized = $this->validateConfiguration(new Configuration(array_keys($this->filters)), ['filters' => $filters]);
// replace config values by normalized, extra keys passed directly
$config->offsetSetByPath(Configuration::FILTERS_PATH, array_replace_recursive($filters, $filtersNormalized));
}
/**
* {@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}
*/
public function processConfigs(DatagridConfiguration $config)
{
$totalRows = $this->validateConfiguration(new Configuration(), ['totals' => $config->offsetGetByPath(Configuration::TOTALS_PATH)]);
if (!empty($totalRows)) {
foreach ($totalRows as $rowName => $rowConfig) {
$this->mergeTotals($totalRows, $rowName, $rowConfig, $config->getName());
}
$config->offsetSetByPath(Configuration::TOTALS_PATH, $totalRows);
}
}
/**
* @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 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);
}
public function it_configures_mass_actions(BuildBefore $event, DatagridConfiguration $datagridConfig, ActionInterface $indexAction, ActionFactory $actionFactory, ActionInterface $action1, ActionInterface $action2)
{
$action1->implement('Pim\\Bundle\\CustomEntityBundle\\Action\\GridActionInterface');
$action2->implement('Pim\\Bundle\\CustomEntityBundle\\Action\\GridActionInterface');
$actionFactory->getAction('entity', 'action1')->willReturn($action1);
$actionFactory->getAction('entity', 'action2')->willReturn($action2);
$action1->getGridActionOptions()->willReturn(['action1_key1' => 'action1_value1']);
$datagridConfig->getName()->willReturn('entity');
$indexAction->getMassActions()->willReturn(['action1', 'action2']);
$indexAction->getRowActions()->willReturn([]);
$indexAction->getOptions()->willReturn([]);
$datagridConfig->offsetGetByPath('[extends]')->willReturn('custom_entity');
$datagridConfig->offsetGetByPath('[properties]')->willReturn([]);
$datagridConfig->offsetGetByPath('[actions]')->willReturn([]);
$datagridConfig->offsetGetByPath('[source]')->willReturn([]);
$datagridConfig->offsetGetByPath('[mass_actions]')->willReturn(['action2' => []]);
$datagridConfig->offsetSetByPath("[source]", ["entity" => "entity_class", "type" => "pim_custom_entity"])->shouldBeCalled();
$datagridConfig->offsetSetByPath("[actions]", [])->shouldBeCalled();
$datagridConfig->offsetSetByPath("[properties]", ['id' => []])->shouldBeCalled();
$datagridConfig->offsetSetByPath("[mass_actions]", ["action2" => [], "action1" => ["action1_key1" => "action1_value1"]])->shouldBeCalled();
$this->buildBefore($event);
}
/**
* @param DatagridConfiguration $config
*/
protected function addNewsletterSubscribers(DatagridConfiguration $config)
{
$query = $config->offsetGetByPath('[source][query]', []);
foreach ($query['select'] as &$field) {
if ($field === 'c.id') {
$field = 'DISTINCT ' . $field;
break;
}
}
$query['select'][] = "CASE WHEN\n transport.isExtensionInstalled = true AND transport.extensionVersion IS NOT NULL\n THEN (CASE WHEN newsletterSubscriberStatus.id = '1' THEN 'yes' ELSE 'no' END)\n ELSE 'unknown'\n END as isSubscriber";
$query['join']['left'][] = ['join' => 'OroCRM\\Bundle\\MagentoBundle\\Entity\\MagentoSoapTransport', 'alias' => 'transport', 'conditionType' => 'WITH', 'condition' => 'channel.transport = transport'];
$query['join']['left'][] = ['join' => 'c.newsletterSubscribers', 'alias' => 'newsletterSubscribers'];
$query['join']['left'][] = ['join' => 'newsletterSubscribers.status', 'alias' => 'newsletterSubscriberStatus'];
$config->offsetSetByPath('[source][query]', $query);
}
/**
* @param DatagridConfiguration $configuration
* @param string $gridName
*
* @return DatagridConfiguration
*/
public function extendConfiguration(DatagridConfiguration $configuration, $gridName)
{
$gridConfiguration = $this->configurationProvider->getConfiguration($gridName);
$scopes = array_diff(array_keys($gridConfiguration->getIterator()->getArrayCopy()), ['name']);
foreach ($scopes as $scope) {
$path = sprintf('[%s]', $scope);
$additionalParams = $gridConfiguration->offsetGetByPath($path);
$baseParams = $configuration->offsetGetByPath($path, []);
if (!is_array($additionalParams) || !is_array($baseParams)) {
continue;
}
$configuration->offsetSetByPath($path, ArrayUtils::arrayMergeRecursiveDistinct($baseParams, $additionalParams));
}
return $configuration;
}
/**
* @param DatagridConfiguration $configuration
* @param string $gridName
*
* @return DatagridConfiguration
*/
public function extendConfiguration(DatagridConfiguration $configuration, $gridName)
{
$gridConfiguration = $this->configurationProvider->getConfiguration($gridName);
$basicAlias = $configuration->offsetGetByPath('[source][query][from][0][alias]');
foreach ($this->pathsToFix as $path) {
$forFix = $gridConfiguration->offsetGetByPath($path);
if ($forFix) {
$gridConfiguration->offsetSetByPath($path, $this->fixMixinAlias($basicAlias, $forFix));
}
}
$scopes = array_diff(array_keys($gridConfiguration->getIterator()->getArrayCopy()), ['name']);
foreach ($scopes as $scope) {
$path = sprintf('[%s]', $scope);
$additionalParams = $gridConfiguration->offsetGetByPath($path);
$baseParams = $configuration->offsetGetByPath($path, []);
if (!is_array($additionalParams) || !is_array($baseParams)) {
continue;
}
$configuration->offsetSetByPath($path, self::arrayMergeRecursiveAppendDistinct($baseParams, $additionalParams));
}
return $configuration;
}
/**
* Inject attributes configurations in the datagrid configuration
*/
protected function addAttributesConfig()
{
$attributes = $this->getAttributesConfig();
$path = $this->getSourcePath(self::USEABLE_ATTRIBUTES_KEY);
$this->configuration->offsetSetByPath($path, $attributes);
}
public function testIsApplicable()
{
$this->assertTrue($this->extension->isApplicable($this->config));
$this->config->offsetSetByPath(DatagridConfiguration::DATASOURCE_TYPE_PATH, 'non_orm');
$this->assertFalse($this->extension->isApplicable($this->config));
}
/**
* Saves column options to a grid configuration
*
* @param DatagridConfiguration $datagridConfig The grid configuration
* @param string $columnName The name of the column
* @param array $columnOptions The column options
*/
public function setColumnOptions(DatagridConfiguration $datagridConfig, $columnName, array &$columnOptions)
{
if (isset($columnOptions[DatagridGuesser::FORMATTER])) {
$datagridConfig->offsetSetByPath(sprintf('[columns][%s]', $columnName), $columnOptions[DatagridGuesser::FORMATTER]);
}
if (isset($columnOptions[DatagridGuesser::SORTER])) {
$datagridConfig->offsetSetByPath(sprintf('[sorters][columns][%s]', $columnName), $columnOptions[DatagridGuesser::SORTER]);
}
if (isset($columnOptions[DatagridGuesser::FILTER])) {
$datagridConfig->offsetSetByPath(sprintf('[filters][columns][%s]', $columnName), $columnOptions[DatagridGuesser::FILTER]);
}
}
/**
* Sets the mass actions
*
* @param \Oro\Bundle\DataGridBundle\Datagrid\Common\DatagridConfiguration $datagridConfig
* @param \Pim\Bundle\CustomEntityBundle\Action\ActionInterface $indexAction
*/
protected function setMassActions(DatagridConfiguration $datagridConfig, ActionInterface $indexAction)
{
$name = $indexAction->getConfiguration()->getName();
$massActions = $datagridConfig->offsetGetByPath('[mass_actions]') ?: [];
foreach ($indexAction->getMassActions() as $massActionType) {
if (isset($massActions[$massActionType])) {
continue;
}
$massAction = $this->actionFactory->getAction($name, $massActionType);
$massActions[$massActionType] = $massAction->getGridActionOptions();
}
$datagridConfig->offsetSetByPath('[mass_actions]', $massActions);
}
/**
* @param DatagridConfiguration $config
* @param array $workflowStepColumns
*/
protected function removeWorkflowStep(DatagridConfiguration $config, array $workflowStepColumns)
{
// remove columns
$columns = $config->offsetGetByPath('[columns]', array());
foreach ($workflowStepColumns as $column) {
if (!empty($columns[$column])) {
unset($columns[$column]);
}
}
$config->offsetSetByPath('[columns]', $columns);
// remove filters
$filters = $config->offsetGetByPath('[filters][columns]', array());
if ($filters) {
foreach ($workflowStepColumns as $column) {
if (!empty($filters[$column])) {
unset($filters[$column]);
}
}
$config->offsetSetByPath('[filters][columns]', $filters);
}
// remove sorters
$sorters = $config->offsetGetByPath('[sorters][columns]', array());
if ($sorters) {
foreach ($workflowStepColumns as $column) {
if (!empty($sorters[$column])) {
unset($sorters[$column]);
}
}
$config->offsetSetByPath('[sorters][columns]', $sorters);
}
}
/**
* {@inheritdoc}
*/
public function processConfigs(DatagridConfiguration $config)
{
$config->offsetSetByPath('[options][route]', self::ROUTE);
}
/**
* @param DatagridConfiguration $config
* @param string $path
* @param mixed $element
*/
protected function addConfigElement(DatagridConfiguration $config, $path, $element)
{
$select = $config->offsetGetByPath($path);
$select[] = $element;
$config->offsetSetByPath($path, $select);
}
/**
* 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));
}
}
}
/**
* Add columns to datagrid configuration
*/
protected function addColumns()
{
$this->configuration->offsetSetByPath(sprintf('[%s]', FormatterConfiguration::COLUMNS_KEY), $this->displayedColumns);
$this->configuration->offsetSetByPath(sprintf(self::SOURCE_PATH, self::AVAILABLE_COLUMNS_KEY), $this->availableColumns);
}
/**
* {@inheritdoc}
*/
protected function addOrderByColumn($columnAlias, $columnSorting)
{
$this->config->offsetSetByPath(sprintf('[sorters][default][%s]', $columnAlias), $columnSorting);
}
/**
* {@inheritdoc}
*/
public function processConfigs(DatagridConfiguration $config)
{
$options = $config->offsetGetByPath(self::CHANNEL_OPTIONS_PATH, []);
$optionsNormalized = $this->validateConfiguration(new ChannelLimitationExtensionConfiguration(), ['root' => $options]);
$config->offsetSetByPath(self::CHANNEL_OPTIONS_PATH, $optionsNormalized);
}
