#26684

pending completion

Build # #26684

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/3a90e420eef787808798d6674ba7114ccd64a670">3a90e420e<a href="https://github.com/api-platform/core/commit/3a90e420eef787808798d6674ba7114ccd64a670">">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/6df637e2af3744b29839d58d65988e87a58b0a80">6df637e2a</a>">6df637e2a</a><a href="https://github.com/api-platform/core/commit/3a90e420eef787808798d6674ba7114ccd64a670"> into 0037f60a9">0037f60a9</a>

Run Details

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

9557 of 11508 relevant lines covered (83.05%)

14.09 hits per line

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

0.0

/src/Bridge/Doctrine/MongoDbOdm/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\MongoDbOdm\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\Exception\InvalidArgumentException;
use Doctrine\ODM\MongoDB\Aggregation\Builder;
use Doctrine\ODM\MongoDB\Mapping\ClassMetadata as MongoDBClassMetadata;
use Doctrine\ODM\MongoDB\Types\Type as MongoDbType;
use Doctrine\Persistence\ManagerRegistry;
use Doctrine\Persistence\Mapping\ClassMetadata;
use MongoDB\BSON\Regex;
use Psr\Log\LoggerInterface;
use Symfony\Component\PropertyAccess\PropertyAccess;
use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
use Symfony\Component\Serializer\NameConverter\NameConverterInterface;

/**
 * Filter the collection by given properties.
 *
 * @experimental
 *
 * @author Kévin Dunglas <dunglas@gmail.com>
 * @author Alan Poulain <contact@alanpoulain.eu>
 */
final class SearchFilter extends AbstractFilter implements SearchFilterInterface
{
    use SearchFilterTrait;

    public const DOCTRINE_INTEGER_TYPE = [MongoDbType::INTEGER, MongoDbType::INT];

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

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

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

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

    /**
     * {@inheritdoc}
     */
    protected function filterProperty(string $property, $value, Builder $aggregationBuilder, string $resourceClass, string $operationName = null, array &$context = [])
    {
        if (
            null === $value ||
            !$this->isPropertyEnabled($property, $resourceClass) ||
            !$this->isPropertyMapped($property, $resourceClass, true)
        ) {
            return;
        }

        $matchField = $field = $property;

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

        $associations = [];
        if ($this->isPropertyNested($property, $resourceClass)) {
            [$matchField, $field, $associations] = $this->addLookupsForNestedProperty($property, $aggregationBuilder, $resourceClass);
        }

        /**
         * @var MongoDBClassMetadata
         */
        $metadata = $this->getNestedMetadata($resourceClass, $associations);

        $caseSensitive = true;

        if ($metadata->hasField($field) && !$metadata->hasAssociation($field)) {
            if ('id' === $field) {
                $values = array_map([$this, 'getIdFromValue'], $values);
            }

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

                return;
            }

            $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;
            }

            $inValues = [];
            foreach ($values as $inValue) {
                $inValues[] = $this->addEqualityMatchStrategy($strategy, $field, $inValue, $caseSensitive, $metadata);
            }

            $aggregationBuilder
                ->match()
                ->field($matchField)
                ->in($inValues);
        }

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

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

        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.', $property)),
            ]);

            return;
        }

        $aggregationBuilder
            ->match()
            ->field($matchField)
            ->in($values);
    }

    /**
     * Add equality match stage according to the strategy.
     *
     * @throws InvalidArgumentException If strategy does not exist
     *
     * @return Regex|string
     */
    private function addEqualityMatchStrategy(string $strategy, string $field, $value, bool $caseSensitive, ClassMetadata $metadata)
    {
        $type = $metadata->getTypeOfField($field);

        if (MongoDbType::STRING !== $type) {
            return MongoDbType::getType($type)->convertToDatabaseValue($value);
        }

        $quotedValue = preg_quote($value);

        switch ($strategy) {
            case null:
            case self::STRATEGY_EXACT:
                return $caseSensitive ? $value : new Regex("^$quotedValue$", 'i');
            case self::STRATEGY_PARTIAL:
                return new Regex($quotedValue, $caseSensitive ? '' : 'i');
            case self::STRATEGY_START:
                return new Regex("^$quotedValue", $caseSensitive ? '' : 'i');
            case self::STRATEGY_END:
                return new Regex("$quotedValue$", $caseSensitive ? '' : 'i');
            case self::STRATEGY_WORD_START:
                return new Regex("(^$quotedValue.*|.*\s$quotedValue.*)", $caseSensitive ? '' : 'i');
            default:
                throw new InvalidArgumentException(sprintf('strategy %s does not exist.', $strategy));
        }
    }

    /**
     * {@inheritdoc}
     */
    protected function getType(string $doctrineType): string
    {
        switch ($doctrineType) {
            case MongoDbType::INT:
            case MongoDbType::INTEGER:
                return 'int';
            case MongoDbType::BOOL:
            case MongoDbType::BOOLEAN:
                return 'bool';
            case MongoDbType::DATE:
                return \DateTimeInterface::class;
            case MongoDbType::FLOAT:
                return 'float';
        }

        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\MongoDbOdm\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\Exception\InvalidArgumentException;
21	use Doctrine\ODM\MongoDB\Aggregation\Builder;
22	use Doctrine\ODM\MongoDB\Mapping\ClassMetadata as MongoDBClassMetadata;
23	use Doctrine\ODM\MongoDB\Types\Type as MongoDbType;
24	use Doctrine\Persistence\ManagerRegistry;
25	use Doctrine\Persistence\Mapping\ClassMetadata;
26	use MongoDB\BSON\Regex;
27	use Psr\Log\LoggerInterface;
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	* @experimental
36	*
37	* @author Kévin Dunglas <dunglas@gmail.com>
38	* @author Alan Poulain <contact@alanpoulain.eu>
39	*/
40	final class SearchFilter extends AbstractFilter implements SearchFilterInterface
41	{
42	use SearchFilterTrait;
43
44	public const DOCTRINE_INTEGER_TYPE = [MongoDbType::INTEGER, MongoDbType::INT];
45
46	public function __construct(ManagerRegistry $managerRegistry, IriConverterInterface $iriConverter, IdentifiersExtractorInterface $identifiersExtractor, PropertyAccessorInterface $propertyAccessor = null, LoggerInterface $logger = null, array $properties = null, NameConverterInterface $nameConverter = null)
47	{
48	parent::__construct($managerRegistry, $logger, $properties, $nameConverter);	×
49
50	$this->iriConverter = $iriConverter;	×
51	$this->propertyAccessor = $propertyAccessor ?: PropertyAccess::createPropertyAccessor();	×
52	$this->identifiersExtractor = $identifiersExtractor;	×
53	}	×
54
55	protected function getIriConverter(): IriConverterInterface
56	{
57	return $this->iriConverter;	×
58	}
59
60	protected function getPropertyAccessor(): PropertyAccessorInterface
61	{
62	return $this->propertyAccessor;	×
63	}
64
65	/**
66	* {@inheritdoc}
67	*/
68	protected function filterProperty(string $property, $value, Builder $aggregationBuilder, string $resourceClass, string $operationName = null, array &$context = [])
69	{
70	if (
71	null === $value \|\|	×
72	!$this->isPropertyEnabled($property, $resourceClass) \|\|	×
73	!$this->isPropertyMapped($property, $resourceClass, true)	×
74	) {
75	return;	×
76	}
77
78	$matchField = $field = $property;	×
79
80	$values = $this->normalizeValues((array) $value, $property);	×
81	if (null === $values) {	×
82	return;	×
83	}
84
85	$associations = [];	×
86	if ($this->isPropertyNested($property, $resourceClass)) {	×
87	[$matchField, $field, $associations] = $this->addLookupsForNestedProperty($property, $aggregationBuilder, $resourceClass);	×
88	}
89
90	/**
91	* @var MongoDBClassMetadata
92	*/
93	$metadata = $this->getNestedMetadata($resourceClass, $associations);	×
94
95	$caseSensitive = true;	×
96
97	if ($metadata->hasField($field) && !$metadata->hasAssociation($field)) {	×
98	if ('id' === $field) {	×
99	$values = array_map([$this, 'getIdFromValue'], $values);	×
100	}
101
102	if (!$this->hasValidValues($values, $this->getDoctrineFieldType($property, $resourceClass))) {	×
103	$this->logger->notice('Invalid filter ignored', [	×
104	'exception' => new InvalidArgumentException(sprintf('Values for field "%s" are not valid according to the doctrine type.', $field)),	×
105	]);
106
107	return;	×
108	}
109
110	$strategy = $this->properties[$property] ?? self::STRATEGY_EXACT;	×
111
112	// prefixing the strategy with i makes it case insensitive
113	if (0 === strpos($strategy, 'i')) {	×
114	$strategy = substr($strategy, 1);	×
115	$caseSensitive = false;	×
116	}
117
118	$inValues = [];	×
119	foreach ($values as $inValue) {	×
120	$inValues[] = $this->addEqualityMatchStrategy($strategy, $field, $inValue, $caseSensitive, $metadata);	×
121	}
122
123	$aggregationBuilder
124	->match()	×
125	->field($matchField)	×
126	->in($inValues);	×
127	}
128
129	// metadata doesn't have the field, nor an association on the field
130	if (!$metadata->hasAssociation($field)) {	×
131	return;	×
132	}
133
134	$values = array_map([$this, 'getIdFromValue'], $values);	×
135	$associationFieldIdentifier = 'id';	×
136	$doctrineTypeField = $this->getDoctrineFieldType($property, $resourceClass);	×
137
138	if (null !== $this->identifiersExtractor) {	×
139	$associationResourceClass = $metadata->getAssociationTargetClass($field);	×
140	$associationFieldIdentifier = $this->identifiersExtractor->getIdentifiersFromResourceClass($associationResourceClass)[0];	×
141	$doctrineTypeField = $this->getDoctrineFieldType($associationFieldIdentifier, $associationResourceClass);	×
142	}
143
144	if (!$this->hasValidValues($values, $doctrineTypeField)) {	×
145	$this->logger->notice('Invalid filter ignored', [	×
146	'exception' => new InvalidArgumentException(sprintf('Values for field "%s" are not valid according to the doctrine type.', $property)),	×
147	]);
148
149	return;	×
150	}
151
152	$aggregationBuilder
153	->match()	×
154	->field($matchField)	×
155	->in($values);	×
156	}	×
157
158	/**
159	* Add equality match stage according to the strategy.
160	*
161	* @throws InvalidArgumentException If strategy does not exist
162	*
163	* @return Regex\|string
164	*/
165	private function addEqualityMatchStrategy(string $strategy, string $field, $value, bool $caseSensitive, ClassMetadata $metadata)
166	{
167	$type = $metadata->getTypeOfField($field);	×
168
169	if (MongoDbType::STRING !== $type) {	×
170	return MongoDbType::getType($type)->convertToDatabaseValue($value);	×
171	}
172
173	$quotedValue = preg_quote($value);	×
174
175	switch ($strategy) {	×
176	case null:
177	case self::STRATEGY_EXACT:	×
178	return $caseSensitive ? $value : new Regex("^$quotedValue$", 'i');	×
179	case self::STRATEGY_PARTIAL:	×
180	return new Regex($quotedValue, $caseSensitive ? '' : 'i');	×
181	case self::STRATEGY_START:	×
182	return new Regex("^$quotedValue", $caseSensitive ? '' : 'i');	×
183	case self::STRATEGY_END:	×
184	return new Regex("$quotedValue$", $caseSensitive ? '' : 'i');	×
185	case self::STRATEGY_WORD_START:	×
186	return new Regex("(^$quotedValue.\|.\s$quotedValue.*)", $caseSensitive ? '' : 'i');	×
187	default:
188	throw new InvalidArgumentException(sprintf('strategy %s does not exist.', $strategy));	×
189	}
190	}
191
192	/**
193	* {@inheritdoc}
194	*/
195	protected function getType(string $doctrineType): string
196	{
197	switch ($doctrineType) {
198	case MongoDbType::INT:	×
199	case MongoDbType::INTEGER:	×
200	return 'int';	×
201	case MongoDbType::BOOL:	×
202	case MongoDbType::BOOLEAN:	×
203	return 'bool';	×
204	case MongoDbType::DATE:	×
205	return \DateTimeInterface::class;	×
206	case MongoDbType::FLOAT:	×
207	return 'float';	×
208	}
209
210	return 'string';	×
211	}
212	}

api-platform / core / #26684

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