#25089

pending completion

Build # #25089

Build Type

push

github

Committed by

web-flow

Commit Message

<a href="https://github.com/api-platform/core/commit/<a class=hub.com/api-platform/core/commit/cd44ca4b9978c774e599a06017175b48f9b8e5c8">cd44ca4b9<a href="https://github.com/api-platform/core/commit/cd44ca4b9978c774e599a06017175b48f9b8e5c8">">Merge </a><a class="double-link" href="https://github.com/api-platform/core/commit/<a class="double-link" href="https://github.com/api-platform/core/commit/c407e206520a641c6e5d0cf360ffef7a24abfbe2">c407e2065</a>">c407e2065</a><a href="https://github.com/api-platform/core/commit/cd44ca4b9978c774e599a06017175b48f9b8e5c8"> into cfc05d1ce">cfc05d1ce</a>

Run Details

36 of 36 new or added lines in 2 files covered. (100.0%)

9260 of 10162 relevant lines covered (91.12%)

16.68 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.04

/src/Bridge/Doctrine/Orm/Filter/SearchFilter.php

<?php

/*
 * This file is part of the API Platform project.
 *
 * (c) Kévin Dunglas <dunglas@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace ApiPlatform\Core\Bridge\Doctrine\Orm\Filter;

use ApiPlatform\Core\Api\IdentifiersExtractorInterface;
use ApiPlatform\Core\Api\IriConverterInterface;
use ApiPlatform\Core\Bridge\Doctrine\Common\Filter\SearchFilterInterface;
use ApiPlatform\Core\Bridge\Doctrine\Common\Filter\SearchFilterTrait;
use ApiPlatform\Core\Bridge\Doctrine\Orm\Util\QueryBuilderHelper;
use ApiPlatform\Core\Bridge\Doctrine\Orm\Util\QueryNameGeneratorInterface;
use ApiPlatform\Core\Exception\InvalidArgumentException;
use Doctrine\Common\Persistence\ManagerRegistry;
use Doctrine\DBAL\Types\Type as DBALType;
use Doctrine\ORM\QueryBuilder;
use Psr\Log\LoggerInterface;
use Symfony\Component\HttpFoundation\RequestStack;
use Symfony\Component\PropertyAccess\PropertyAccess;
use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
use Symfony\Component\Serializer\NameConverter\NameConverterInterface;

/**
 * Filter the collection by given properties.
 *
 * @author Kévin Dunglas <dunglas@gmail.com>
 */
class SearchFilter extends AbstractContextAwareFilter implements SearchFilterInterface
{
    use SearchFilterTrait;

    public const DOCTRINE_INTEGER_TYPE = DBALType::INTEGER;

    public function __construct(ManagerRegistry $managerRegistry, ?RequestStack $requestStack, IriConverterInterface $iriConverter, PropertyAccessorInterface $propertyAccessor = null, LoggerInterface $logger = null, array $properties = null, IdentifiersExtractorInterface $identifiersExtractor = null, NameConverterInterface $nameConverter = null)
    {
        parent::__construct($managerRegistry, $requestStack, $logger, $properties, $nameConverter);

        if (null === $identifiersExtractor) {
            @trigger_error('Not injecting ItemIdentifiersExtractor is deprecated since API Platform 2.5 and can lead to unexpected behaviors, it will not be possible anymore in API Platform 3.0.', E_USER_DEPRECATED);
        }

        $this->iriConverter = $iriConverter;
        $this->identifiersExtractor = $identifiersExtractor;
        $this->propertyAccessor = $propertyAccessor ?: PropertyAccess::createPropertyAccessor();
    }

    protected function getIriConverter(): IriConverterInterface
    {
        return $this->iriConverter;
    }

    protected function getPropertyAccessor(): PropertyAccessorInterface
    {
        return $this->propertyAccessor;
    }

    /**
     * {@inheritdoc}
     */
    protected function filterProperty(string $property, $value, QueryBuilder $queryBuilder, QueryNameGeneratorInterface $queryNameGenerator, string $resourceClass, string $operationName = null)
    {
        if (
            null === $value ||
            !$this->isPropertyEnabled($property, $resourceClass) ||
            !$this->isPropertyMapped($property, $resourceClass, true)
        ) {
            return;
        }

        $alias = $queryBuilder->getRootAliases()[0];
        $field = $property;

        $associations = [];
        if ($this->isPropertyNested($property, $resourceClass)) {
            [$alias, $field, $associations] = $this->addJoinsForNestedProperty($property, $alias, $queryBuilder, $queryNameGenerator, $resourceClass);
        }

        $values = $this->normalizeValues((array) $value, $property);
        if (null === $values) {
            return;
        }

        $caseSensitive = true;
        $metadata = $this->getNestedMetadata($resourceClass, $associations);

        $doctrineTypeField = $this->getDoctrineFieldType($property, $resourceClass);
        $values = array_map([$this, 'getIdFromValue'], $values);

        $strategy = $this->properties[$property] ?? self::STRATEGY_EXACT;

        // prefixing the strategy with i makes it case insensitive
        if (0 === strpos($strategy, 'i')) {
            $strategy = substr($strategy, 1);
            $caseSensitive = false;
        }

        if ($metadata->hasField($field)) {
            if (!$this->hasValidValues($values, $doctrineTypeField)) {
                $this->logger->notice('Invalid filter ignored', [
                    'exception' => new InvalidArgumentException(sprintf('Values for field "%s" are not valid according to the doctrine type.', $field)),
                ]);

                return;
            }

            $this->addWhereByStrategy($strategy, $queryBuilder, $queryNameGenerator, $alias, $field, $doctrineTypeField, $values, $caseSensitive);
        }

        // metadata doesn't have the field, nor an association on the field
        if (!$metadata->hasAssociation($field)) {
            return;
        }

        $associationFieldIdentifier = 'id';

        if (null !== $this->identifiersExtractor) {
            $associationResourceClass = $metadata->getAssociationTargetClass($field);
            $associationFieldIdentifier = $this->identifiersExtractor->getIdentifiersFromResourceClass($associationResourceClass)[0];
            $doctrineTypeField = $this->getDoctrineFieldType($associationFieldIdentifier, $associationResourceClass);
        }

        if (!$this->hasValidValues($values, $doctrineTypeField)) {
            $this->logger->notice('Invalid filter ignored', [
                'exception' => new InvalidArgumentException(sprintf('Values for field "%s" are not valid according to the doctrine type.', $field)),
            ]);

            return;
        }

        $valueParameter = $queryNameGenerator->generateParameterName($field);
        if ($metadata->isCollectionValuedAssociation($field)) {
            $associationAlias = QueryBuilderHelper::addJoinOnce($queryBuilder, $queryNameGenerator, $alias, $field);
            $associationField = $associationFieldIdentifier;
        } else {
            $associationAlias = $alias;
            $associationField = $field;
        }

        $this->addWhereByStrategy($strategy, $queryBuilder, $queryNameGenerator, $associationAlias, $associationField, $doctrineTypeField, $values, $caseSensitive, $valueParameter);
    }

    /**
     * Adds where clause according to the strategy.
     *
     * @throws InvalidArgumentException If strategy does not exist
     */
    protected function addWhereByStrategy(string $strategy, QueryBuilder $queryBuilder, QueryNameGeneratorInterface $queryNameGenerator, string $alias, string $field, $fieldType, $values, bool $caseSensitive, string $valueParameter = null)
    {
        $wrapCase = $this->createWrapCase($caseSensitive);
        $valueParameter = $valueParameter ?? $queryNameGenerator->generateParameterName($field);
        $values = (array) $values;

        if (self::STRATEGY_EXACT !== $strategy && 1 !== \count($values)) {
            $this->logger->notice('Invalid filter ignored', [
                'exception' => new InvalidArgumentException(sprintf('"%s" strategy selected for "%s" property, but only "%s" strategy supports multiple values', $strategy, $field, self::STRATEGY_EXACT)),
            ]);

            return;
        }

        switch ($strategy) {
            case null:
            case self::STRATEGY_EXACT:
                if (1 === \count($values)) {
                    $queryBuilder
                        ->andWhere(sprintf($wrapCase('%s.%s').' = '.$wrapCase(':%s'), $alias, $field, $valueParameter))
                        ->setParameter($valueParameter, $values[0], $fieldType);
                } else {
                    $queryBuilder
                        ->andWhere(sprintf($wrapCase('%s.%s').' IN (:%s)', $alias, $field, $valueParameter))
                        ->setParameter($valueParameter, $caseSensitive ? $values : array_map('strtolower', $values));
                }
                break;
            case self::STRATEGY_PARTIAL:
                $queryBuilder
                    ->andWhere(sprintf($wrapCase('%s.%s').' LIKE '.$wrapCase('CONCAT(\'%%\', :%s, \'%%\')'), $alias, $field, $valueParameter))
                    ->setParameter($valueParameter, $values[0], $fieldType);
                break;
            case self::STRATEGY_START:
                $queryBuilder
                    ->andWhere(sprintf($wrapCase('%s.%s').' LIKE '.$wrapCase('CONCAT(:%s, \'%%\')'), $alias, $field, $valueParameter))
                    ->setParameter($valueParameter, $values[0], $fieldType);
                break;
            case self::STRATEGY_END:
                $queryBuilder
                    ->andWhere(sprintf($wrapCase('%s.%s').' LIKE '.$wrapCase('CONCAT(\'%%\', :%s)'), $alias, $field, $valueParameter))
                    ->setParameter($valueParameter, $values[0], $fieldType);
                break;
            case self::STRATEGY_WORD_START:
                $queryBuilder
                    ->andWhere(sprintf($wrapCase('%1$s.%2$s').' LIKE '.$wrapCase('CONCAT(:%3$s, \'%%\')').' OR '.$wrapCase('%1$s.%2$s').' LIKE '.$wrapCase('CONCAT(\'%% \', :%3$s, \'%%\')'), $alias, $field, $valueParameter))
                    ->setParameter($valueParameter, $values[0], $fieldType);
                break;
            default:
                throw new InvalidArgumentException(sprintf('strategy %s does not exist.', $strategy));
        }
    }

    /**
     * Creates a function that will wrap a Doctrine expression according to the
     * specified case sensitivity.
     *
     * For example, "o.name" will get wrapped into "LOWER(o.name)" when $caseSensitive
     * is false.
     */
    protected function createWrapCase(bool $caseSensitive): \Closure
    {
        return static function (string $expr) use ($caseSensitive): string {
            if ($caseSensitive) {
                return $expr;
            }

            return sprintf('LOWER(%s)', $expr);
        };
    }

    /**
     * {@inheritdoc}
     */
    protected function getType(string $doctrineType): string
    {
        switch ($doctrineType) {
            case DBALType::TARRAY:
                return 'array';
            case DBALType::BIGINT:
            case DBALType::INTEGER:
            case DBALType::SMALLINT:
                return 'int';
            case DBALType::BOOLEAN:
                return 'bool';
            case DBALType::DATE:
            case DBALType::TIME:
            case DBALType::DATETIME:
            case DBALType::DATETIMETZ:
                return \DateTimeInterface::class;
            case DBALType::FLOAT:
                return 'float';
        }

        if (\defined(DBALType::class.'::DATE_IMMUTABLE')) {
            switch ($doctrineType) {
                case DBALType::DATE_IMMUTABLE:
                case DBALType::TIME_IMMUTABLE:
                case DBALType::DATETIME_IMMUTABLE:
                case DBALType::DATETIMETZ_IMMUTABLE:
                    return \DateTimeInterface::class;
            }
        }

        return 'string';
    }
}

1	<?php
2
3	/*
4	* This file is part of the API Platform project.
5	*
6	* (c) Kévin Dunglas <dunglas@gmail.com>
7	*
8	* For the full copyright and license information, please view the LICENSE
9	* file that was distributed with this source code.
10	*/
11
12	declare(strict_types=1);
13
14	namespace ApiPlatform\Core\Bridge\Doctrine\Orm\Filter;
15
16	use ApiPlatform\Core\Api\IdentifiersExtractorInterface;
17	use ApiPlatform\Core\Api\IriConverterInterface;
18	use ApiPlatform\Core\Bridge\Doctrine\Common\Filter\SearchFilterInterface;
19	use ApiPlatform\Core\Bridge\Doctrine\Common\Filter\SearchFilterTrait;
20	use ApiPlatform\Core\Bridge\Doctrine\Orm\Util\QueryBuilderHelper;
21	use ApiPlatform\Core\Bridge\Doctrine\Orm\Util\QueryNameGeneratorInterface;
22	use ApiPlatform\Core\Exception\InvalidArgumentException;
23	use Doctrine\Common\Persistence\ManagerRegistry;
24	use Doctrine\DBAL\Types\Type as DBALType;
25	use Doctrine\ORM\QueryBuilder;
26	use Psr\Log\LoggerInterface;
27	use Symfony\Component\HttpFoundation\RequestStack;
28	use Symfony\Component\PropertyAccess\PropertyAccess;
29	use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
30	use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
31
32	/**
33	* Filter the collection by given properties.
34	*
35	* @author Kévin Dunglas <dunglas@gmail.com>
36	*/
37	class SearchFilter extends AbstractContextAwareFilter implements SearchFilterInterface
38	{
39	use SearchFilterTrait;
40
41	public const DOCTRINE_INTEGER_TYPE = DBALType::INTEGER;
42
43	public function __construct(ManagerRegistry $managerRegistry, ?RequestStack $requestStack, IriConverterInterface $iriConverter, PropertyAccessorInterface $propertyAccessor = null, LoggerInterface $logger = null, array $properties = null, IdentifiersExtractorInterface $identifiersExtractor = null, NameConverterInterface $nameConverter = null)
44	{
45	parent::__construct($managerRegistry, $requestStack, $logger, $properties, $nameConverter);	49✔
46
47	if (null === $identifiersExtractor) {	49✔
48	@trigger_error('Not injecting ItemIdentifiersExtractor is deprecated since API Platform 2.5 and can lead to unexpected behaviors, it will not be possible anymore in API Platform 3.0.', E_USER_DEPRECATED);	1✔
49	}
50
51	$this->iriConverter = $iriConverter;	49✔
52	$this->identifiersExtractor = $identifiersExtractor;	49✔
53	$this->propertyAccessor = $propertyAccessor ?: PropertyAccess::createPropertyAccessor();	49✔
54	}	49✔
55
56	protected function getIriConverter(): IriConverterInterface
57	{
58	return $this->iriConverter;	44✔
59	}
60
61	protected function getPropertyAccessor(): PropertyAccessorInterface
62	{
63	return $this->propertyAccessor;	4✔
64	}
65
66	/**
67	* {@inheritdoc}
68	*/
69	protected function filterProperty(string $property, $value, QueryBuilder $queryBuilder, QueryNameGeneratorInterface $queryNameGenerator, string $resourceClass, string $operationName = null)
70	{
71	if (
72	null === $value \|\|	46✔
73	!$this->isPropertyEnabled($property, $resourceClass) \|\|	46✔
74	!$this->isPropertyMapped($property, $resourceClass, true)	46✔
75	) {
76	return;	2✔
77	}
78
79	$alias = $queryBuilder->getRootAliases()[0];	44✔
80	$field = $property;	44✔
81
82	$associations = [];	44✔
83	if ($this->isPropertyNested($property, $resourceClass)) {	44✔
84	[$alias, $field, $associations] = $this->addJoinsForNestedProperty($property, $alias, $queryBuilder, $queryNameGenerator, $resourceClass);	10✔
85	}
86
87	$values = $this->normalizeValues((array) $value, $property);	44✔
88	if (null === $values) {	44✔
89	return;	2✔
90	}
91
92	$caseSensitive = true;	44✔
93	$metadata = $this->getNestedMetadata($resourceClass, $associations);	44✔
94
95	$doctrineTypeField = $this->getDoctrineFieldType($property, $resourceClass);	44✔
96	$values = array_map([$this, 'getIdFromValue'], $values);	44✔
97
98	$strategy = $this->properties[$property] ?? self::STRATEGY_EXACT;	44✔
99
100	// prefixing the strategy with i makes it case insensitive
101	if (0 === strpos($strategy, 'i')) {	44✔
102	$strategy = substr($strategy, 1);	12✔
103	$caseSensitive = false;	12✔
104	}
105
106	if ($metadata->hasField($field)) {	44✔
107	if (!$this->hasValidValues($values, $doctrineTypeField)) {	38✔
108	$this->logger->notice('Invalid filter ignored', [	×
109	'exception' => new InvalidArgumentException(sprintf('Values for field "%s" are not valid according to the doctrine type.', $field)),	×
110	]);
111
112	return;	×
113	}
114
115	$this->addWhereByStrategy($strategy, $queryBuilder, $queryNameGenerator, $alias, $field, $doctrineTypeField, $values, $caseSensitive);	38✔
116	}
117
118	// metadata doesn't have the field, nor an association on the field
119	if (!$metadata->hasAssociation($field)) {	44✔
120	return;	38✔
121	}
122
123	$associationFieldIdentifier = 'id';	8✔
124
125	if (null !== $this->identifiersExtractor) {	8✔
126	$associationResourceClass = $metadata->getAssociationTargetClass($field);	8✔
127	$associationFieldIdentifier = $this->identifiersExtractor->getIdentifiersFromResourceClass($associationResourceClass)[0];	8✔
128	$doctrineTypeField = $this->getDoctrineFieldType($associationFieldIdentifier, $associationResourceClass);	8✔
129	}
130
131	if (!$this->hasValidValues($values, $doctrineTypeField)) {	8✔
132	$this->logger->notice('Invalid filter ignored', [	6✔
133	'exception' => new InvalidArgumentException(sprintf('Values for field "%s" are not valid according to the doctrine type.', $field)),	6✔
134	]);
135
136	return;	6✔
137	}
138
139	$valueParameter = $queryNameGenerator->generateParameterName($field);	2✔
140	if ($metadata->isCollectionValuedAssociation($field)) {	2✔
141	$associationAlias = QueryBuilderHelper::addJoinOnce($queryBuilder, $queryNameGenerator, $alias, $field);	2✔
142	$associationField = $associationFieldIdentifier;	2✔
143	} else {
144	$associationAlias = $alias;	2✔
145	$associationField = $field;	2✔
146	}
147
148	$this->addWhereByStrategy($strategy, $queryBuilder, $queryNameGenerator, $associationAlias, $associationField, $doctrineTypeField, $values, $caseSensitive, $valueParameter);	2✔
149	}	2✔
150
151	/**
152	* Adds where clause according to the strategy.
153	*
154	* @throws InvalidArgumentException If strategy does not exist
155	*/
156	protected function addWhereByStrategy(string $strategy, QueryBuilder $queryBuilder, QueryNameGeneratorInterface $queryNameGenerator, string $alias, string $field, $fieldType, $values, bool $caseSensitive, string $valueParameter = null)
157	{
158	$wrapCase = $this->createWrapCase($caseSensitive);	40✔
159	$valueParameter = $valueParameter ?? $queryNameGenerator->generateParameterName($field);	40✔
160	$values = (array) $values;	40✔
161
162	if (self::STRATEGY_EXACT !== $strategy && 1 !== \count($values)) {	40✔
163	$this->logger->notice('Invalid filter ignored', [	×
164	'exception' => new InvalidArgumentException(sprintf('"%s" strategy selected for "%s" property, but only "%s" strategy supports multiple values', $strategy, $field, self::STRATEGY_EXACT)),	×
165	]);
166
167	return;	×
168	}
169
170	switch ($strategy) {	40✔
171	case null:
172	case self::STRATEGY_EXACT:	40✔
173	if (1 === \count($values)) {	24✔
174	$queryBuilder
175	->andWhere(sprintf($wrapCase('%s.%s').' = '.$wrapCase(':%s'), $alias, $field, $valueParameter))	20✔
176	->setParameter($valueParameter, $values[0], $fieldType);	20✔
177	} else {
178	$queryBuilder
179	->andWhere(sprintf($wrapCase('%s.%s').' IN (:%s)', $alias, $field, $valueParameter))	6✔
180	->setParameter($valueParameter, $caseSensitive ? $values : array_map('strtolower', $values));	6✔
181	}
182	break;	24✔
183	case self::STRATEGY_PARTIAL:	16✔
184	$queryBuilder
185	->andWhere(sprintf($wrapCase('%s.%s').' LIKE '.$wrapCase('CONCAT(\'%%\', :%s, \'%%\')'), $alias, $field, $valueParameter))	4✔
186	->setParameter($valueParameter, $values[0], $fieldType);	4✔
187	break;	4✔
188	case self::STRATEGY_START:	12✔
189	$queryBuilder
190	->andWhere(sprintf($wrapCase('%s.%s').' LIKE '.$wrapCase('CONCAT(:%s, \'%%\')'), $alias, $field, $valueParameter))	4✔
191	->setParameter($valueParameter, $values[0], $fieldType);	4✔
192	break;	4✔
193	case self::STRATEGY_END:	8✔
194	$queryBuilder
195	->andWhere(sprintf($wrapCase('%s.%s').' LIKE '.$wrapCase('CONCAT(\'%%\', :%s)'), $alias, $field, $valueParameter))	4✔
196	->setParameter($valueParameter, $values[0], $fieldType);	4✔
197	break;	4✔
198	case self::STRATEGY_WORD_START:	4✔
199	$queryBuilder
200	->andWhere(sprintf($wrapCase('%1$s.%2$s').' LIKE '.$wrapCase('CONCAT(:%3$s, \'%%\')').' OR '.$wrapCase('%1$s.%2$s').' LIKE '.$wrapCase('CONCAT(\'%% \', :%3$s, \'%%\')'), $alias, $field, $valueParameter))	4✔
201	->setParameter($valueParameter, $values[0], $fieldType);	4✔
202	break;	4✔
203	default:
204	throw new InvalidArgumentException(sprintf('strategy %s does not exist.', $strategy));	×
205	}
206	}	40✔
207
208	/**
209	* Creates a function that will wrap a Doctrine expression according to the
210	* specified case sensitivity.
211	*
212	* For example, "o.name" will get wrapped into "LOWER(o.name)" when $caseSensitive
213	* is false.
214	*/
215	protected function createWrapCase(bool $caseSensitive): \Closure
216	{
217	return static function (string $expr) use ($caseSensitive): string {
218	if ($caseSensitive) {	40✔
219	return $expr;	28✔
220	}
221
222	return sprintf('LOWER(%s)', $expr);	12✔
223	};	40✔
224	}
225
226	/**
227	* {@inheritdoc}
228	*/
229	protected function getType(string $doctrineType): string
230	{
231	switch ($doctrineType) {
232	case DBALType::TARRAY:	2✔
233	return 'array';	×
234	case DBALType::BIGINT:	2✔
235	case DBALType::INTEGER:	2✔
236	case DBALType::SMALLINT:	2✔
237	return 'int';	2✔
238	case DBALType::BOOLEAN:	2✔
239	return 'bool';	1✔
240	case DBALType::DATE:	2✔
241	case DBALType::TIME:	2✔
242	case DBALType::DATETIME:	2✔
243	case DBALType::DATETIMETZ:	2✔
244	return \DateTimeInterface::class;	2✔
245	case DBALType::FLOAT:	2✔
246	return 'float';	1✔
247	}
248
249	if (\defined(DBALType::class.'::DATE_IMMUTABLE')) {	2✔
250	switch ($doctrineType) {
251	case DBALType::DATE_IMMUTABLE:	2✔
252	case DBALType::TIME_IMMUTABLE:	2✔
253	case DBALType::DATETIME_IMMUTABLE:	2✔
254	case DBALType::DATETIMETZ_IMMUTABLE:	2✔
255	return \DateTimeInterface::class;	×
256	}
257	}
258
259	return 'string';	2✔
260	}
261	}

api-platform / core / #25089

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous