/** * @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); }