/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var Context $context */ $entityClass = $context->getClassName(); if (!$this->doctrineHelper->isManageableEntityClass($entityClass)) { // only manageable entities are supported return; } $filters = $context->getFilters(); if ($filters->has(self::FILTER_KEY)) { // filters have been already set return; } $fieldFilter = new FieldsFilter(DataType::STRING, self::FILTER_KEY_DESCRIPTION); $fieldFilter->setArrayAllowed(true); $filters->add(sprintf(self::FILTER_KEY_TEMPLATE, $this->entityClassTransformer->transform($entityClass)), $fieldFilter); $associations = $this->doctrineHelper->getEntityMetadata($entityClass)->getAssociationMappings(); if (!$associations) { // no associations - no sense to add associations fields filters return; } $associationKeys = array_keys($associations); foreach ($associationKeys as $association) { $filters->add(sprintf(self::FILTER_KEY_TEMPLATE, $association), $fieldFilter); } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var GetListContext $context */ if ($context->hasQuery()) { // a query is already built return; } $entityClass = $context->getClassName(); if (!$this->doctrineHelper->isManageableEntityClass($entityClass)) { // only manageable entities are supported return; } $filters = $context->getFilters(); if (!$filters->has(self::SORT_FILTER_KEY)) { $filters->add(self::SORT_FILTER_KEY, new SortFilter(DataType::ORDER_BY, 'Result sorting. One or several fields separated by comma, for example \'field1,-field2\'.', function () use($entityClass) { return $this->doctrineHelper->getOrderByIdentifier($entityClass); }, function ($value) { $result = []; if (null !== $value) { foreach ($value as $field => $order) { $result[] = (Criteria::DESC === $order ? '-' : '') . $field; } } return implode(RestRequest::ARRAY_DELIMITER, $result); })); } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var GetListContext $context */ $filterCollection = $context->getFilters(); $filters = $filterCollection->all(); foreach ($filters as $filterKey => $filter) { $filterCollection->remove($filterKey); $filterCollection->add(sprintf(self::FILTER_KEY_TEMPLATE, $filterKey), $filter); } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var GetListContext $context */ if ($context->hasQuery()) { // a query is already built return; } $filters = $context->getFilters(); $this->addPageSizeFilter($filters); $this->addPageNumberFilter($filters); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var ConfigContext $context */ $filters = $context->getFilters(); if (empty($filters) || empty($filters[ConfigUtil::FIELDS])) { // a configuration of filters does not exist return; } foreach ($filters[ConfigUtil::FIELDS] as &$filterConfig) { $this->normalizeAttribute($filterConfig, ConfigUtil::DESCRIPTION); } $context->setFilters($filters); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var GetListContext $context */ if ($context->hasQuery()) { // a query is already built return; } $entityClass = $context->getClassName(); if (!$this->doctrineHelper->isManageableEntityClass($entityClass)) { // only manageable entities are supported return; } $this->addSortFilter($context->getFilters(), $entityClass); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var Context $context */ if ($context->hasQuery()) { // a query is already built return; } $filterValues = $context->getFilterValues(); $filters = $context->getFilters(); foreach ($filters as $filterKey => $filter) { if ($filter instanceof SortFilter) { $this->validateSortValue($this->getSortFilterValue($filterValues, $filterKey), $context->hasConfigOfSorters() ? $context->getConfigOfSorters() : null); } } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var ConfigContext $context */ $filters = $context->getFilters(); if (null === $filters) { // a filters' configuration does not exist return; } $entityClass = $context->getClassName(); if (!$this->doctrineHelper->isManageableEntityClass($entityClass)) { // only manageable entities are supported return; } $context->setFilters($this->removeDuplicates($filters, $entityClass)); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var GetListContext $context */ if ($context->hasQuery()) { // a query is already built return; } $criteria = $context->getCriteria(); $filterValues = $context->getFilterValues(); $filters = $context->getFilters(); foreach ($filters as $filterKey => $filter) { $filterValue = $filterValues->has($filterKey) ? $filterValues->get($filterKey) : null; $filter->apply($criteria, $filterValue); } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var ConfigContext $context */ $filters = $context->getFilters(); if (null === $filters) { // a filters' configuration does not exist return; } $definition = $context->getResult(); if (null === $definition) { // an entity configuration does not exist return; } $this->collect($filters, ConfigUtil::FILTERS, $definition); $context->setFilters($filters); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var GetListContext $context */ $criteria = $context->getCriteria(); $filters = $context->getFilters(); foreach ($filters as $filter) { if ($filter instanceof ComparisonFilter) { $field = $filter->getField(); $lastDelimiter = strrpos($field, ConfigUtil::PATH_DELIMITER); if (false !== $lastDelimiter) { $join = $criteria->getJoin(substr($field, 0, $lastDelimiter)); if (null !== $join && $join->getJoinType() === Join::LEFT_JOIN) { $join->setJoinType(Join::INNER_JOIN); } } } } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var ConfigContext $context */ $filters = $context->getFilters(); if (empty($filters)) { // nothing to normalize return; } $fields = ConfigUtil::getArrayValue($filters, ConfigUtil::FIELDS); if (ConfigUtil::isExcludeAll($filters)) { $fields = ConfigUtil::removeExclusions($fields); } else { $entityClass = $context->getClassName(); if ($this->doctrineHelper->isManageableEntityClass($entityClass)) { $fields = ConfigUtil::removeExclusions($this->completeFilters($fields, $entityClass, $context->getResult())); } } $context->setFilters([ConfigUtil::EXCLUSION_POLICY => ConfigUtil::EXCLUSION_POLICY_ALL, ConfigUtil::FIELDS => $fields]); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var GetListContext $context */ if ($context->hasQuery()) { // a query is already built return; } $filterValues = $context->getFilterValues(); $filters = $context->getFilters(); foreach ($filters as $filterKey => $filter) { $filterValue = null; if ($filterValues->has($filterKey)) { $filterValue = $filterValues->get($filterKey); if ($filter instanceof StandaloneFilter) { $value = $this->valueNormalizer->normalizeValue($filterValue->getValue(), $filter->getDataType(), $context->getRequestType(), $filter->isArrayAllowed($filterValue->getOperator())); $filterValue->setValue($value); } } } }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var Context $context */ $entityClass = $context->getClassName(); if (!$this->doctrineHelper->isManageableEntityClass($entityClass)) { // only manageable entities are supported return; } $indexedAssociations = $this->doctrineHelper->getIndexedAssociations($this->doctrineHelper->getEntityMetadata($entityClass)); if (!$indexedAssociations) { // no associations - no sense to add include filters return; } $filters = $context->getFilters(); if ($filters->has(self::FILTER_KEY)) { // filters have been already set return; } $includeFilter = new IncludeFilter(DataType::STRING, 'Inclusion of related resources. Comma-separated paths, e.g. "articles,comments,author"'); $includeFilter->setArrayAllowed(true); $filters->add(self::FILTER_KEY, $includeFilter); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var ConfigContext $context */ $filters = $context->getFilters(); if (empty($filters) || empty($filters[ConfigUtil::FIELDS])) { // a configuration of filters does not exist return; } $entityClass = $context->getClassName(); if (!$this->entityConfigProvider->hasConfig($entityClass)) { // only configurable entities are supported return; } foreach ($filters[ConfigUtil::FIELDS] as $filterKey => &$filterConfig) { if (!isset($filterConfig[ConfigUtil::DESCRIPTION])) { $config = $this->findFieldConfig($entityClass, $filterKey, $filterConfig); if (null !== $config) { $filterConfig[ConfigUtil::DESCRIPTION] = new Label($config->get('label')); } } } $context->setFilters($filters); }
/** * {@inheritdoc} */ public function process(ContextInterface $context) { /** @var GetListContext $context */ $configOfFilters = $context->getConfigOfFilters(); if (empty($configOfFilters)) { // a filters' configuration does not contains any data return; } if (!ConfigUtil::isExcludeAll($configOfFilters)) { // it seems that filters' configuration was not normalized throw new \RuntimeException(sprintf('Expected "all" exclusion policy for filters. Got: %s.', ConfigUtil::getExclusionPolicy($configOfFilters))); } $fields = ConfigUtil::getArrayValue($configOfFilters, ConfigUtil::FIELDS); $filters = $context->getFilters(); foreach ($fields as $field => $fieldConfig) { if ($filters->has($field)) { continue; } $filter = $this->createFilter(ConfigUtil::getPropertyPath($fieldConfig, $field), $fieldConfig); if (null !== $filter) { $filters->add($field, $filter); } } }