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